diff --git a/.claude/settings.json b/.claude/settings.json new file mode 100644 index 0000000000..92706fed20 --- /dev/null +++ b/.claude/settings.json @@ -0,0 +1,16 @@ +{ + "hooks": { + "SessionStart": [ + { + "hooks": [ + { + "type": "command", + "command": "d=\"${CLAUDE_PROJECT_DIR:-.}\"; [ -x \"$d/venv/bin/python\" ] || { mkdir -p \"$d/.temp\"; env -u VIRTUAL_ENV \"$d/script/setup\" >\"$d/.temp/setup.log\" 2>&1 || echo '{\"systemMessage\":\"script/setup failed; see .temp/setup.log\"}'; }", + "statusMessage": "Setting up dev environment (script/setup)...", + "timeout": 900 + } + ] + } + ] + } +} diff --git a/.github/actions/cache-clang-tidy-idedata/action.yml b/.github/actions/cache-clang-tidy-idedata/action.yml new file mode 100644 index 0000000000..18f3c2b31a --- /dev/null +++ b/.github/actions/cache-clang-tidy-idedata/action.yml @@ -0,0 +1,50 @@ +name: Cache clang-tidy idedata +description: > + Cache the clang-tidy idedata and the headers it references under .temp + (headers only, about 30MB per env). Run after restore-python and cache-esp-idf. +inputs: + environment: + description: 'clang-tidy environment (e.g. esp32-idf-tidy).' + required: true +runs: + using: composite + steps: + - name: Compute cache key + id: key + shell: bash + run: | + . venv/bin/activate + [ -n "${{ inputs.environment }}" ] || { echo "::error::cache-clang-tidy-idedata: 'environment' input is empty"; exit 1; } + hash=$(python -c 'import sys; sys.path.insert(0, "script"); from clang_tidy_hash import idedata_cache_hash; print(idedata_cache_hash("${{ inputs.environment }}"))') + pyver=$(python -c 'import platform; print(platform.python_version())') + # Generating idedata is what installs ESP-IDF; never skip it over a missing + # install. This also skips the save, so a dev run that installs ESP-IDF + # warms the idedata cache on the next run. + if [ -d ~/.esphome-idf/frameworks ]; then + echo "skip=false" >> "$GITHUB_OUTPUT" + else + echo "ESP-IDF install missing, not using the clang-tidy idedata cache" + echo "skip=true" >> "$GITHUB_OUTPUT" + fi + echo "key=${{ runner.os }}-tidy-idedata-${{ inputs.environment }}-$hash-py$pyver" >> "$GITHUB_OUTPUT" + { + echo "path<> "$GITHUB_OUTPUT" + # Mirror cache-esp-idf: write on dev, restore-only on PRs. The post-step + # save only runs when the job succeeded, so a failed generation is never saved. + # Extend the extension list if a component ships extensionless headers. + - name: Cache clang-tidy idedata (write on dev) + if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && steps.key.outputs.skip != 'true' + uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ steps.key.outputs.path }} + key: ${{ steps.key.outputs.key }} + - name: Cache clang-tidy idedata (restore-only off dev) + if: github.ref != 'refs/heads/dev' && !contains(github.event.pull_request.labels.*.name, 'ci-cache-write') && steps.key.outputs.skip != 'true' + uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ steps.key.outputs.path }} + key: ${{ steps.key.outputs.key }} diff --git a/.github/actions/cache-esp-idf/action.yml b/.github/actions/cache-esp-idf/action.yml index b884e1e4c6..38bcc80eb6 100644 --- a/.github/actions/cache-esp-idf/action.yml +++ b/.github/actions/cache-esp-idf/action.yml @@ -26,6 +26,9 @@ runs: # The native-IDF version is pinned in code, not in any file that feeds the # other cache keys, so resolve it explicitly. Keying on it means the cache # invalidates on a version bump (actions/cache never overwrites a key). + # Also key on the Python version: the cached IDF venv links to the + # runner's toolcache interpreter and is reinstalled every run after a + # runner image bump. id: version shell: bash run: | @@ -36,19 +39,32 @@ runs: version=$(python -c 'from esphome.components.esp32 import ESP_IDF_FRAMEWORK_VERSION_LOOKUP as L; print(L["recommended"])') fi echo "version=$version" >> "$GITHUB_OUTPUT" + echo "python-version=$(python -c 'import platform; print(platform.python_version())')" >> "$GITHUB_OUTPUT" # Mirror the adjacent PlatformIO cache: only dev-branch runs write the # shared cache (so it lives in the default-branch scope readable by all # PRs), and PRs are restore-only -- they never push multi-GB artifacts into - # their own scope / the repo quota (e.g. on a version-bump PR). + # their own scope / the repo quota (e.g. on a version-bump PR). The + # ci-cache-write label lets a PR write into its own scope to test the hit path; + # that costs about 1GB of the repo cache quota per run, so remove it when done. + # -slim: bump when prune-esp-idf changes what it removes; a key is never overwritten. - name: Cache ESP-IDF install (write on dev) - if: github.ref == 'refs/heads/dev' && inputs.restore-only != 'true' + if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && inputs.restore-only != 'true' uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ~/.esphome-idf - key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }} + key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }}-py${{ steps.version.outputs.python-version }}-slim - name: Cache ESP-IDF install (restore-only off dev) - if: github.ref != 'refs/heads/dev' || inputs.restore-only == 'true' + if: github.ref != 'refs/heads/dev' && !contains(github.event.pull_request.labels.*.name, 'ci-cache-write') || inputs.restore-only == 'true' uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5 with: path: ~/.esphome-idf - key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }} + key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }}-py${{ steps.version.outputs.python-version }}-slim + # Install explicitly so the prune below sees the toolchains on a cache miss + # too, instead of the install happening inside the first build step. + - name: Install ESP-IDF + shell: bash + run: | + . venv/bin/activate + python -c 'from esphome.espidf.framework import check_esp_idf_install; check_esp_idf_install("${{ steps.version.outputs.version }}")' + - name: Prune ESP-IDF install + uses: ./.github/actions/prune-esp-idf diff --git a/.github/actions/prune-esp-idf/action.yml b/.github/actions/prune-esp-idf/action.yml new file mode 100644 index 0000000000..e0e7c5bd4e --- /dev/null +++ b/.github/actions/prune-esp-idf/action.yml @@ -0,0 +1,34 @@ +name: Prune ESP-IDF install +description: > + Remove the picolibc sysroots (1.1GB of the 3.9GB install) from the native + ESP-IDF toolchains; IDF 5.x links newlib. Skipped when an IDF 6 install is + present, which links picolibc (see esp32/__init__.py). +runs: + using: composite + steps: + - name: Prune picolibc + shell: bash + run: | + shopt -s nullglob + prefix="${ESPHOME_ESP_IDF_PREFIX:-$HOME/.esphome-idf}" + prefix="${prefix/#\~/$HOME}" + for fw in "$prefix"/frameworks/*/; do + case "$(basename "$fw")" in + [6-9].*) echo "IDF $(basename "$fw") installed, keeping picolibc"; exit 0 ;; + esac + done + n=0 + for dir in "$prefix"/tools/*-esp-elf/*/*-esp-elf/picolibc; do + echo "Removing $dir ($(du -sh "$dir" | cut -f1))" + rm -rf "$dir" + n=$((n + 1)) + done + # The marker rides along in the cache entry so a restored slim tree stays quiet. + if [ "$n" -gt 0 ]; then + touch "$prefix/.picolibc-pruned" + elif [ -d "$prefix/tools" ] && [ ! -f "$prefix/.picolibc-pruned" ]; then + echo "::warning::no picolibc sysroots matched under $prefix/tools" + fi + if [ -d "$prefix" ]; then + du -sh "$prefix" + fi diff --git a/.github/workflows/ci-docker.yml b/.github/workflows/ci-docker.yml index 42be51cdd9..829bdd5f98 100644 --- a/.github/workflows/ci-docker.yml +++ b/.github/workflows/ci-docker.yml @@ -119,16 +119,22 @@ jobs: # pushed image) keeps it working for fork PRs, which never push to ghcr.io. - name: Export image for compile-test if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker' - run: docker save "ghcr.io/esphome/esphome-amd64:${{ steps.tag.outputs.tag }}" | gzip > compile-test-image.tar.gz + # zstd over gzip: docker save is on the critical path for every + # compile-test job, and zstd -T0 is multithreaded (export 50s -> 9s). + # docker load auto-detects the format; its time is layer extraction, + # not decompression, so it is unchanged. shell: bash adds pipefail so + # a failed docker save cannot upload a truncated artifact. + shell: bash + run: docker save "ghcr.io/esphome/esphome-amd64:${{ steps.tag.outputs.tag }}" | zstd -T0 -3 > compile-test-image.tar.zst - name: Upload compile-test image artifact if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker' uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: - # The tar is already gzipped, so upload it as-is. archive: false skips - # the redundant zip and makes the file name the artifact name (the - # `name` input is ignored in that mode). - path: compile-test-image.tar.gz + # The tar is already compressed, so upload it as-is. archive: false + # skips the redundant zip and makes the file name the artifact name + # (the `name` input is ignored in that mode). + path: compile-test-image.tar.zst retention-days: 1 archive: false @@ -206,9 +212,9 @@ jobs: - name: Download image artifact uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: - name: compile-test-image.tar.gz + name: compile-test-image.tar.zst - name: Load image - run: docker load --input compile-test-image.tar.gz + run: docker load --input compile-test-image.tar.zst - name: Compile ${{ matrix.id }} run: | docker run --rm \ diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a2762faa4d..a874a023b9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -92,6 +92,7 @@ jobs: outputs: core-ci: ${{ steps.determine.outputs.core-ci }} integration-tests: ${{ steps.determine.outputs.integration-tests }} + integration-run-all: ${{ steps.determine.outputs.integration-run-all }} integration-test-buckets: ${{ steps.determine.outputs.integration-test-buckets }} clang-tidy: ${{ steps.determine.outputs.clang-tidy }} clang-tidy-mode: ${{ steps.determine.outputs.clang-tidy-mode }} @@ -152,6 +153,9 @@ jobs: # Extract individual fields echo "core-ci=$(echo "$output" | jq -r '.core_ci')" >> $GITHUB_OUTPUT echo "integration-tests=$(echo "$output" | jq -r '.integration_tests')" >> $GITHUB_OUTPUT + # A missing key must fail here, not silently disable the junit upload + run_all=$(echo "$output" | jq -r 'if has("integration_run_all") then .integration_run_all else error("integration_run_all missing") end') + echo "integration-run-all=${run_all}" >> $GITHUB_OUTPUT echo "integration-test-buckets=$(echo "$output" | jq -c '.integration_test_buckets')" >> $GITHUB_OUTPUT echo "clang-tidy=$(echo "$output" | jq -r '.clang_tidy')" >> $GITHUB_OUTPUT echo "clang-tidy-mode=$(echo "$output" | jq -r '.clang_tidy_mode')" >> $GITHUB_OUTPUT @@ -355,6 +359,15 @@ jobs: fail-fast: false matrix: bucket: ${{ fromJson(needs.determine-jobs.outputs.integration-test-buckets) }} + env: + # What the cache steps persist; libdeps is excluded (keyed per xdist + # worker and env, it never crosses runs). + INTEGRATION_PIO_CACHE_PATH: | + ~/.esphome-integration-tests/platformio/platforms + ~/.esphome-integration-tests/platformio/packages + ~/.esphome-integration-tests/platformio/appstate.json + ~/.esphome-integration-tests/platformio/.cache + ~/.esphome-integration-tests/platformio/.esphome.pio.stamp.json steps: - name: Check out code from GitHub uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 @@ -373,6 +386,14 @@ jobs: uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 with: python-version: "3.13" + - name: Restore integration PlatformIO cache + # Native platform + toolchain installed by shared_platformio_cache in + # tests/integration/conftest.py; a miss self-heals, so no restore-keys. + id: pio-cache + uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ env.INTEGRATION_PIO_CACHE_PATH }} + key: integration-pio-v1-${{ runner.os }}-py${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements.txt', 'tests/integration/fixtures/cache_init.yaml', 'esphome/components/host/__init__.py') }} - name: Restore Python virtual environment id: cache-venv uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 @@ -410,12 +431,36 @@ jobs: run: | . venv/bin/activate mapfile -t test_files < <(echo "$BUCKET_TESTS" | jq -r '.[]') + if [ "${#test_files[@]}" -eq 0 ]; then + echo "::error::Empty integration test bucket; pytest would collect the whole tree" + exit 1 + fi echo "Bucket ${{ matrix.bucket.name }}: running ${#test_files[@]} integration tests" - pytest -vv --no-cov --tb=native --durations=30 -n auto "${test_files[@]}" + pytest -vv --no-cov --tb=native --durations=30 -n auto --dist worksteal \ + --junitxml=junit-integration.xml "${test_files[@]}" + - name: Upload junit timings + # Consumed by sync-integration-durations.yml through + # script/update_integration_test_durations.py; only full matrix dev + # runs produce usable data. + if: github.ref == 'refs/heads/dev' && needs.determine-jobs.outputs.integration-run-all == 'true' + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: junit-integration-${{ strategy.job-index }} + path: junit-integration.xml + if-no-files-found: error + # A full cron period of margin for the weekly refresh + retention-days: 14 - name: Print ccache statistics # esphome stores the PlatformIO ccache under the machine-global cache # dir (see _ccache_env() in esphome/platformio/toolchain.py). run: CCACHE_DIR="$HOME/.cache/esphome/platformio-ccache" ccache -s + - name: Save integration PlatformIO cache + # Bucket 0 only; the others would race the same immutable key. + if: success() && (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && strategy.job-index == 0 && steps.pio-cache.outputs.cache-hit != 'true' + uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ env.INTEGRATION_PIO_CACHE_PATH }} + key: ${{ steps.pio-cache.outputs.cache-primary-key }} import-time: name: Check import esphome.__main__ time @@ -536,7 +581,7 @@ jobs: apt-get install -y libc6-dbg - name: Run CodSpeed benchmarks - uses: CodSpeedHQ/action@4296e51e7041e24dadb86d1d6e8b9320d223dbe8 # v5.0.3 + uses: CodSpeedHQ/action@373d6868929f444bc08d901fd0eb0ad52a8875ea # v5.2.1 with: run: | . venv/bin/activate @@ -649,6 +694,12 @@ jobs: with: framework: arduino + - name: Cache clang-tidy idedata + if: matrix.cache_idf + uses: ./.github/actions/cache-clang-tidy-idedata + with: + environment: esp32-arduino-tidy + - name: Cache nRF Connect SDK install if: matrix.cache_sdk_nrf uses: ./.github/actions/cache-sdk-nrf @@ -698,6 +749,10 @@ jobs: # Also cache libdeps, store them in a ~/.platformio subfolder PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps + - name: Prune ESP-IDF install before cache save + if: matrix.cache_idf && (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) + uses: ./.github/actions/prune-esp-idf + - name: Suggested changes run: script/ci-suggest-changes ${{ matrix.ignore_errors && '|| true' || '' }} # yamllint disable-line rule:line-length @@ -730,6 +785,11 @@ jobs: - name: Cache ESP-IDF install uses: ./.github/actions/cache-esp-idf + - name: Cache clang-tidy idedata + uses: ./.github/actions/cache-clang-tidy-idedata + with: + environment: esp32-idf-tidy + - name: Register problem matchers run: | echo "::add-matcher::.github/workflows/matchers/gcc.json" @@ -764,6 +824,10 @@ jobs: # Also cache libdeps, store them in a ~/.platformio subfolder PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps + - name: Prune ESP-IDF install before cache save + if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) + uses: ./.github/actions/prune-esp-idf + - name: Suggested changes run: script/ci-suggest-changes if: always() @@ -809,6 +873,11 @@ jobs: - name: Cache ESP-IDF install uses: ./.github/actions/cache-esp-idf + - name: Cache clang-tidy idedata + uses: ./.github/actions/cache-clang-tidy-idedata + with: + environment: esp32-idf-tidy + - name: Register problem matchers run: | echo "::add-matcher::.github/workflows/matchers/gcc.json" @@ -843,6 +912,10 @@ jobs: # Also cache libdeps, store them in a ~/.platformio subfolder PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps + - name: Prune ESP-IDF install before cache save + if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) + uses: ./.github/actions/prune-esp-idf + - name: Suggested changes run: script/ci-suggest-changes if: always() @@ -866,16 +939,19 @@ jobs: name: Run script/clang-tidy for ESP32 S3 # yamllint disable-line rule:line-length options: --environment esp32s3-idf-tidy --grep SOC_TEMP_SENSOR_SUPPORTED --grep USE_ESP32_VARIANT_ESP32S3 --grep USE_LOGGER_USB_CDC + tidy_environment: esp32s3-idf-tidy - id: clang-tidy name: Run script/clang-tidy for ESP32 P4 # P4 has no native Wi-Fi/BLE; those run over the hosted co-processor, # so their code paths differ -- lint them under the P4 build too. # yamllint disable-line rule:line-length options: --environment esp32p4-idf-tidy --grep USE_ESP32_VARIANT_ESP32P4 --grep USE_ESP32_HOSTED --grep USE_WIFI --grep USE_BLE + tidy_environment: esp32p4-idf-tidy - id: clang-tidy name: Run script/clang-tidy for ESP32 C6 # yamllint disable-line rule:line-length options: --environment esp32c6-idf-tidy --grep SOC_LP_I2C_SUPPORTED --grep USE_ESP32_VARIANT_ESP32C6 --grep USE_OPENTHREAD --grep USE_ZIGBEE + tidy_environment: esp32c6-idf-tidy steps: - name: Check out code from GitHub @@ -893,6 +969,11 @@ jobs: - name: Cache ESP-IDF install uses: ./.github/actions/cache-esp-idf + - name: Cache clang-tidy idedata + uses: ./.github/actions/cache-clang-tidy-idedata + with: + environment: ${{ matrix.tidy_environment }} + - name: Register problem matchers run: | echo "::add-matcher::.github/workflows/matchers/gcc.json" @@ -926,6 +1007,10 @@ jobs: script/clang-tidy --fix --changed ${{ matrix.options }} fi + - name: Prune ESP-IDF install before cache save + if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) + uses: ./.github/actions/prune-esp-idf + - name: Suggested changes run: script/ci-suggest-changes if: always() diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index b46f9adab6..aab3dea592 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -56,7 +56,7 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8 + uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9 with: languages: ${{ matrix.language }} build-mode: ${{ matrix.build-mode }} @@ -84,6 +84,6 @@ jobs: exit 1 - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8 + uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9 with: category: "/language:${{matrix.language}}" diff --git a/.github/workflows/sync-integration-durations.yml b/.github/workflows/sync-integration-durations.yml new file mode 100644 index 0000000000..d09a1cf242 --- /dev/null +++ b/.github/workflows/sync-integration-durations.yml @@ -0,0 +1,98 @@ +--- +name: Refresh integration test durations + +on: + workflow_dispatch: + schedule: + - cron: "45 5 * * 1" + +# Repo writes (branch push, PR open) happen via the App token minted below, +# so the workflow's GITHUB_TOKEN does not need any write scopes. +permissions: + contents: read + actions: read # gh api / gh run download for the CI junit artifacts + +jobs: + sync: + name: Refresh integration test durations + runs-on: ubuntu-latest + if: github.repository == 'esphome/esphome' + steps: + - name: Generate a token + id: generate-token + uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0 + with: + client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }} + private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }} + permission-contents: write # push the sync branch + permission-pull-requests: write # open or refresh the sync PR + + - name: Checkout + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + + - name: Setup Python + uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + with: + python-version: "3.13" + + - name: Refresh from the newest usable dev run + env: + GH_TOKEN: ${{ github.token }} + run: | + # Only full matrix dev runs upload junit-integration-* artifacts + # (see the integration-tests job); the merge script re-checks + # coverage regardless. + # Newest-first candidates via their bucket-0 artifact. Fork PRs run + # their own ci.yml, so name and branch are spoofable; require + # same-repo. Assignment failures trip set -e and fail loudly. + candidates=$( + gh api "repos/${GITHUB_REPOSITORY}/actions/artifacts?name=junit-integration-0&per_page=100" \ + --jq '.artifacts[] | select(.expired | not) | .workflow_run + | select(.head_branch == "dev" and .head_repository_id != null + and .head_repository_id == .repository_id) + | .id' + ) + # Green runs first, then the rest newest first; a run missing a + # bucket fails the coverage check and the next one is tried + green="" + rest="" + for id in ${candidates}; do + conclusion=$(gh api "repos/${GITHUB_REPOSITORY}/actions/runs/${id}" --jq '.conclusion // ""') + if [ "${conclusion}" = "success" ]; then + green="${green} ${id}" + elif [ -n "${conclusion}" ]; then + rest="${rest} ${id}" + fi + done + # helpers.py imports colorama; the script needs nothing else + pip install colorama + for id in ${green} ${rest}; do + rm -rf /tmp/junit + if ! gh run download "${id}" --repo "${GITHUB_REPOSITORY}" -p "junit-integration-*" -D /tmp/junit; then + echo "::warning::Could not download artifacts for run ${id}; trying the next" + continue + fi + status=0 + python script/update_integration_test_durations.py /tmp/junit || status=$? + if [ "${status}" -eq 0 ]; then + echo "Refreshed from run ${id}" + exit 0 + fi + # Only EXIT_LOW_COVERAGE (3) from the script advances to the next run + [ "${status}" -eq 3 ] || exit 1 + echo "::warning::Run ${id} covers too few test files; trying the next" + done + echo "::error::No dev CI run with usable junit artifacts in range; the feed is starved" + exit 1 + + - name: Commit changes + uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1 + with: + commit-message: "[ci] Refresh integration test durations" + committer: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com> + author: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com> + branch: sync/integration-durations + delete-branch: true + title: "[ci] Refresh integration test durations" + body-path: .github/PULL_REQUEST_TEMPLATE.md + token: ${{ steps.generate-token.outputs.token }} diff --git a/AGENTS.md b/AGENTS.md index f006ee6087..e932c50f32 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -44,6 +44,16 @@ This document provides essential context for AI models interacting with this pro ## 4. Coding Conventions & Style Guide +**Read the developer documentation before writing a component.** https://developers.esphome.io covers the +component lifecycle, the main loop, and the reasoning behind the rules below in far more depth than this +file does, and it is the authority when they disagree. The most useful starting points: + +* https://developers.esphome.io/architecture/components/ - component lifecycle, `setup()`, `loop()`, + setup priorities, and how a component is registered. +* https://developers.esphome.io/architecture/components/advanced/ - choosing between `loop()`, + `set_interval`, `set_timeout` and `defer`; waking the loop from another thread; the RAM cost of each. +* https://developers.esphome.io/contributing/code/ - contribution rules, public API and breaking changes. + * **Formatting:** * **Python:** Uses `ruff` and `flake8` for linting and formatting. Configuration is in `pyproject.toml`. * **C++:** Uses `clang-format` for formatting. Configuration is in `.clang-format`. @@ -142,6 +152,47 @@ This document provides essential context for AI models interacting with this pro * **Indentation:** Use spaces (two per indentation level), not tabs * **Type aliases:** Prefer `using type_t = int;` over `typedef int type_t;` * **Line length:** Wrap lines at no more than 120 characters + * **Timing in `loop()`:** Never call `millis()` in a `loop()` body. The current tick's timestamp is + already cached - use `App.get_loop_component_start_time()` (from `esphome/core/application.h`). + Only reach for `millis()` when you genuinely need sub-tick resolution inside a long operation. + * **The main loop runs every 16 ms.** A rate-limit gate shorter than that does nothing: the check + passes on essentially every pass of the loop, so it costs a comparison and buys nothing. Pick an + interval comfortably coarser than 16 ms, or drop the gate entirely and accept running every loop. + ```cpp + // Bad - a 10ms gate against a 16ms loop never holds anything back + static constexpr uint32_t POLL_INTERVAL_MS = 10; + const uint32_t now = millis(); + if (now - this->last_poll_ < POLL_INTERVAL_MS) + return; + this->last_poll_ = now; + ``` + ```cpp + // Good - an interval that actually rate limits, off the cached timestamp + static constexpr uint32_t POLL_INTERVAL_MS = 100; + const uint32_t now = App.get_loop_component_start_time(); + if (now - this->last_poll_ < POLL_INTERVAL_MS) + return; + this->last_poll_ = now; + ``` + Pick the primitive by cadence: under 250 ms use a gated `loop()`; 500 ms and above use + `set_interval`. Full reasoning, including why `set_interval` costs more below 500 ms: + https://developers.esphome.io/architecture/components/advanced/#quick-rule-of-thumb + * **Don't override a default with the same value:** if a base class method already returns what you + want, do not override it. `Component::get_setup_priority()` returns `setup_priority::DATA`, so a + component that wants `DATA` should simply leave it alone. + ```cpp + // Bad - this is exactly what the base class already does + float get_setup_priority() const override { return setup_priority::DATA; } + ``` + * **Logging string literals:** wrap literals passed as `%s` arguments in `LOG_STR_LITERAL()` so they + can be stored in flash rather than RAM. + ```cpp + // Bad + ESP_LOGV(TAG, "Key %u %s", key, pressed ? "pressed" : "released"); + + // Good + ESP_LOGV(TAG, "Key %u %s", key, pressed ? LOG_STR_LITERAL("pressed") : LOG_STR_LITERAL("released")); + ``` * **Constructor parameters vs setters:** Component properties that are both **required** and **invariant** (never change after construction) should be constructor parameters rather than set via setter methods. This makes the dependency explicit and prevents use of the object in an incompletely-initialized state. @@ -562,6 +613,33 @@ This document provides essential context for AI models interacting with this pro Use `cg.add_define("MAX_SERVICES", count)` to set the size from Python configuration. Like `std::array` but with vector-like API (`push_back()`, `size()`) and no STL reallocation code. + **Listener and child-entity registration lists are the most common case, and the most commonly + missed.** A `register_*()` method called once per child at code generation time has a count that + is known at compile time, so it should never be a `std::vector`. Use `cg.slot_counter()`: it + returns a function that each consumer calls once per slot it will occupy, and after every + `to_code` has run it emits the define with the final count. When nothing registers, no define is + emitted and the storage plus its registration method compile out entirely. + ```python + # hub component's __init__.py + _request_listener_slot = cg.slot_counter("MY_COMPONENT_LISTENER_COUNT") + + + async def register_listener(hub: MockObj, var: MockObj) -> None: + _request_listener_slot() + cg.add(hub.register_listener(var)) + ``` + ```cpp + #ifdef MY_COMPONENT_LISTENER_COUNT + void register_listener(MyComponentListener *listener); + #endif + protected: + #ifdef MY_COMPONENT_LISTENER_COUNT + StaticVector listeners_; + #endif + ``` + Request slots from `to_code`, not from a job that runs after `CoroPriority.FINAL` - a late + request raises rather than silently undercounting. + 3. **Runtime-known sizes:** Use `FixedVector` from `esphome/core/helpers.h` when the size is only known at runtime initialization. ```cpp // Bad - generates STL realloc code (_M_realloc_insert) @@ -599,9 +677,25 @@ This document provides essential context for AI models interacting with this pro ``` Linear search on small datasets (1-16 elements) is often faster than hashing/tree overhead, but this depends on lookup frequency and access patterns. For frequent lookups in hot code paths, the O(1) vs O(n) complexity difference may still matter even for small datasets. `std::vector` with simple structs is usually fine—it's the heavy containers (`map`, `set`, `unordered_map`) that should be avoided for small datasets unless profiling shows otherwise. - 5. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices. + 5. **Strings set once from configuration:** Use `StringRef` (`esphome/core/string_ref.h`) rather than + `std::string`. Code generation passes a string literal that lives in flash for the life of the + program, so storing a `std::string` copies it onto the heap for nothing. `StringRef` is a + non-owning pointer plus length; it does not copy, and it must only ever refer to storage that + outlives it (a string literal, or a buffer owned elsewhere). + ```cpp + // Bad - heap copy of a literal that is already in flash + void set_keys(std::string keys) { this->keys_ = std::move(keys); } + std::string keys_; + ``` + ```cpp + // Good - no allocation + void set_keys(const char *keys) { this->keys_ = StringRef(keys); } + StringRef keys_; + ``` - 6. **Detection:** Look for these patterns in compiler output: + 6. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices. + + 7. **Detection:** Look for these patterns in compiler output: - Large code sections with STL symbols (vector, map, set) - `alloc`, `realloc`, `dealloc` in symbol names - `_M_realloc_insert`, `_M_default_append` (vector reallocation) diff --git a/CODEOWNERS b/CODEOWNERS index b898788b1a..3429a93aa7 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -131,6 +131,7 @@ esphome/components/cst816/* @clydebarrow esphome/components/cst9220/* @clydebarrow esphome/components/ct_clamp/* @jesserockz esphome/components/current_based/* @djwmarcx +esphome/components/d01/* @ch604 esphome/components/dac7678/* @NickB1 esphome/components/daikin_arc/* @MagicBear esphome/components/daikin_brc/* @hagak @@ -148,6 +149,7 @@ esphome/components/display_menu_base/* @numo68 esphome/components/dlms_meter/* @latonita @PolarGoose @SimonFischer04 @Tomer27cz esphome/components/dps310/* @kbx81 esphome/components/ds1307/* @badbadc0ffee +esphome/components/ds1603l/* @JakeLC15 esphome/components/ds2484/* @mrk-its esphome/components/ds248x/* @tomwellnitz esphome/components/dsmr/* @glmnet @PolarGoose @@ -350,6 +352,7 @@ esphome/components/mipi_spi/* @clydebarrow esphome/components/mitsubishi/* @RubyBailey esphome/components/mitsubishi_cn105/* @crnjan esphome/components/mixer/speaker/* @kahrendt +esphome/components/mk2pvrouter/* @FredM67 esphome/components/mlx90393/* @functionpointer esphome/components/mlx90614/* @jesserockz esphome/components/mmc5603/* @benhoff @@ -577,6 +580,7 @@ esphome/components/tuya/select/* @bearpawmaxim esphome/components/tuya/sensor/* @jesserockz esphome/components/tuya/switch/* @jesserockz esphome/components/tuya/text_sensor/* @dentra +esphome/components/tuya/water_heater/* @iago-veiga esphome/components/uart/* @esphome/core esphome/components/uart/button/* @ssieb esphome/components/uart/event/* @eoasmxd diff --git a/THREAT_MODEL.md b/THREAT_MODEL.md index 5816f38176..b4f557e55b 100644 --- a/THREAT_MODEL.md +++ b/THREAT_MODEL.md @@ -23,7 +23,8 @@ For this repository there are two trusted inputs by design: 1. **The configuration.** Anyone who can supply or edit a YAML config is trusted (see below). 2. **Authenticated peers of a running device** — clients holding the device's - API encryption key / password, OTA password, or web server credentials. + API/OTA encryption key, API password, OTA password, or web server + credentials. The security boundary is therefore **unauthenticated network traffic vs. those trusted inputs.** A bug that lets an unauthenticated attacker cross it is a @@ -76,8 +77,8 @@ These *are* security bugs in this repo, and we want to hear about them privately captive portal, etc.) **without** valid credentials. - Authentication or encryption bypass on the device — reaching API calls, OTA updates, or the web server without the configured key/password. -- Flaws that weaken the device's API encryption (Noise), OTA, or web server auth - below their documented guarantees. +- Flaws that weaken the device's API or OTA encryption (Noise), OTA auth, or + web server auth below their documented guarantees. ## The web server is an open HTTP API by design @@ -121,6 +122,37 @@ and any memory-safety or protocol bug in the server reachable without credential This section documents the current design and scope; it is not a judgment that the design is optimal or that it will not change. +## OTA update encryption + +The `esphome` OTA platform optionally encrypts updates with the same Noise +`NNpsk0` pattern the native API uses; one key protects the device. With an +`encryption:` block configured the guarantees are: the firmware image is +confidential in transit, the uploader is authenticated by the pre-shared key, +and the plaintext negotiation preceding the handshake is bound into the +handshake prologue, so stripping or tampering with it fails the first MAC. +Both ends fail closed with no override: a device built with a key refuses +plaintext uploads, and the CLI refuses to send plaintext when a key is +configured. + +Defeating any of that without the key is in scope: a keyed device accepting a +plaintext or downgraded upload, getting past the MAC, or recovering image +contents from captured traffic. + +The following are **not** vulnerabilities, by design: + +- Plaintext OTA on a device with no `encryption:` block. That is the + documented default, authenticated (if at all) by the OTA password. +- The enablement window: turning encryption on takes one last upload of the + encryption-enabled firmware over the existing plaintext channel, with the + pre-existing plaintext exposure. +- The web OTA `/update` endpoint alongside encryption. The `web_server` + component keeps it always reachable, and `captive_portal:` auto-loads it + for the fallback AP window; validation warns about both combinations, and + the operator keeps the recovery path. +- CLI retry behavior on transport or MAC failures; every attempt renegotiates + a fresh handshake with fresh ephemerals, so retrying does not weaken + authentication. + ## Explicitly out of scope - Local attackers who already have shell access on the host that runs `esphome`. diff --git a/docker/generate_tags.py b/docker/generate_tags.py index 31f98c4614..b35aed91f0 100755 --- a/docker/generate_tags.py +++ b/docker/generate_tags.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import argparse +import os import re CHANNEL_DEV = "dev" @@ -64,7 +65,10 @@ def main(): suffix = f"-{args.suffix}" if args.suffix else "" - image_name = f"esphome/esphome{suffix}" + repository = ( + (os.environ.get("GITHUB_REPOSITORY") or "esphome/esphome").strip().lower() + ) + image_name = f"{repository}{suffix}" print(f"channel={channel}") diff --git a/esphome/__main__.py b/esphome/__main__.py index 632d2ba3d0..b3d58ad13b 100644 --- a/esphome/__main__.py +++ b/esphome/__main__.py @@ -26,7 +26,9 @@ from esphome.const import ( CONF_DEASSERT_RTS_DTR, CONF_DISABLED, CONF_DISCOVER_IP, + CONF_ENCRYPTION, CONF_ESPHOME, + CONF_KEY, CONF_LEVEL, CONF_LOG, CONF_LOG_TOPIC, @@ -1336,6 +1338,19 @@ def _upload_via_native_api( remote_port = int(ota_conf[CONF_PORT]) password = ota_conf.get(CONF_PASSWORD) + # Fail closed: an encryption block whose key did not resolve must never + # fall back to a plaintext upload + noise_psk = None + if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None: + noise_psk = encryption_conf.get(CONF_KEY) + if not noise_psk: + raise EsphomeError( + "OTA encryption is configured but no key was resolved; " + "set the key under 'ota: encryption:' or 'api: encryption:'" + ) + # Ensure the key is a string, as required by the underlying OTA implementation. + # It arrives here as a SensitiveStr which aioesphomeapi rejects. + noise_psk = str(noise_psk) def check_partition_access(option_string: str) -> None: if not ota_conf.get("allow_partition_access"): @@ -1366,7 +1381,9 @@ def _upload_via_native_api( if ota_type == espota2.OTA_TYPE_UPDATE_BOOTLOADER: _validate_bootloader_binary(binary) - return espota2.run_ota(network_devices, remote_port, password, binary, ota_type) + return espota2.run_ota( + network_devices, remote_port, password, binary, ota_type, noise_psk + ) def _upload_via_web_server( @@ -1375,6 +1392,16 @@ def _upload_via_web_server( from esphome import web_server_ota from esphome.web_server_helpers import get_web_server_connection + if any( + ota_item.get(CONF_PLATFORM) == CONF_ESPHOME + and ota_item.get(CONF_ENCRYPTION) is not None + for ota_item in config.get(CONF_OTA, []) + ): + _LOGGER.warning( + "This config has OTA encryption, but the web_server OTA path sends " + "the image over plaintext HTTP; use the esphome OTA platform to " + "keep it confidential" + ) remote_port, username, password = get_web_server_connection(config) return web_server_ota.run_ota( network_devices, remote_port, username, password, binary @@ -1670,20 +1697,26 @@ def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None: if exit_code != 0: return exit_code if CORE.is_host: - if CORE.using_toolchain_esp_idf: - from esphome.espidf import toolchain - - program_path = str(toolchain.get_elf_path()) - else: - from esphome.platformio.toolchain import get_idedata - - program_path = str(get_idedata(config).firmware_elf_path) - _LOGGER.info("Successfully compiled program to path '%s'", program_path) + _LOGGER.info( + "Successfully compiled program to path '%s'", _host_program_path(config) + ) else: _LOGGER.info("Successfully compiled program.") return 0 +def _host_program_path(config: ConfigType) -> str: + """Return the compiled host ELF path.""" + if CORE.using_toolchain_esp_idf: + from esphome.espidf import toolchain + + return str(toolchain.get_elf_path()) + from esphome.platformio.toolchain import get_idedata + + # Memoized by compile_program's own call; this is a dict lookup + return str(get_idedata(config).firmware_elf_path) + + def command_upload(args: ArgsProtocol, config: ConfigType) -> int | None: # Get devices, resolving special identifiers like OTA devices = choose_upload_log_host( @@ -1728,14 +1761,7 @@ def command_run(args: ArgsProtocol, config: ConfigType) -> int | None: return exit_code _LOGGER.info("Successfully compiled program.") if CORE.is_host: - if CORE.using_toolchain_esp_idf: - from esphome.espidf import toolchain - - program_path = str(toolchain.get_elf_path()) - else: - from esphome.platformio.toolchain import get_idedata - - program_path = str(get_idedata(config).firmware_elf_path) + program_path = _host_program_path(config) _LOGGER.info("Running program from path '%s'", program_path) return run_external_process(program_path) diff --git a/esphome/arduino/__init__.py b/esphome/arduino/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/esphome/arduino/library.py b/esphome/arduino/library.py new file mode 100644 index 0000000000..e224e62589 --- /dev/null +++ b/esphome/arduino/library.py @@ -0,0 +1,531 @@ +"""Arduino-core backend for the shared PlatformIO library converter. + +Bundled names build straight from the framework tree; everything else goes +through ``esphome.platformio.library``. Mirrors ``lib_ldf_mode=off``: each +library builds its own archive; all include dirs join one global path. + +Deviations from PlatformIO: flat-layout libraries get the recursive default +source filter; ``dot_a_linkage`` is honored; bundled libraries never run a +manifest ``extraScript``; manifest ``-I`` flags join the global include path; +``precompiled``/``ldflags`` properties are refused by name. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +import logging +from pathlib import Path +import re + +from esphome.core import CORE, EsphomeError, Library +from esphome.helpers import walk_files +from esphome.platformio.extra_script import apply_extra_script +from esphome.platformio.library import ( + DEFAULT_BUILD_INCLUDE_DIR, + DEFAULT_BUILD_SRC_FILTER, + ESPHOME_DATA_KEY, + ESPHOME_DATA_LINK_FLAGS_KEY, + LIBRARY_HEADER_SUFFIXES, + SRC_FILE_EXTENSIONS, + ConvertedLibrary, + IncompatiblePlatform, + InvalidLibrary, + LibraryBackend, + _url_or_none, + check_library_data, + collect_filtered_files, + convert_libraries, + ensure_list, + is_lib_ignored, + lex_build_flags, + lib_ignore_set, + normalize_dependencies, + parse_library_json, + parse_library_properties, + warn_properties_depends, +) + +_LOGGER = logging.getLogger(__name__) + + +@dataclass +class ArduinoLibrary: + """One resolved library, ready for the ninja generator.""" + + name: str + sources: list[Path] = field(default_factory=list) + include_dirs: list[Path] = field(default_factory=list) + # Extra compile flags private to this library's own sources + flags: list[str] = field(default_factory=list) + # PlatformIO's build.libArchive / Arduino's dot_a_linkage: when False the + # objects go to the linker directly (symbols nothing references survive) + lib_archive: bool = True + # Link inputs the library contributes (-L dirs / -l libs, e.g. from + # precompiled vendor blobs) and -Wl, options for the firmware link + link_dirs: list[Path] = field(default_factory=list) + link_libs: list[str] = field(default_factory=list) + link_flags: list[str] = field(default_factory=list) + + +# Source-like suffixes the case-sensitive suffix map rejects +_UNMAPPED_SOURCE_SUFFIXES = frozenset( + {s.lower() for s in SRC_FILE_EXTENSIONS} | {".ino"} +) + +# Filename-plain names: an allowlist excludes separators, drive colons, +# and dot-only names by shape +_SAFE_LIBRARY_NAME_RE = re.compile(r"[A-Za-z0-9_][A-Za-z0-9_. +-]*\Z") + + +def _is_safe_library_name(name: object) -> bool: + """Whether a name may be joined under the framework's libraries dir.""" + return isinstance(name, str) and _SAFE_LIBRARY_NAME_RE.fullmatch(name) is not None + + +def _manifest_build(name: str, data: object) -> dict: + """The manifest's ``build`` section; malformed manifests fail by name.""" + build = data.get("build", {}) if isinstance(data, dict) else None + if not isinstance(build, dict): + raise EsphomeError(f"Library {name} has a malformed manifest") + return build + + +def _resolve_src_dir(name: str, read_path: Path, build: dict) -> str: + """Resolve PIO's source dir: manifest srcDir, else src/Src, else the root.""" + if "srcDir" not in build: + return next((d for d in ("src", "Src") if (read_path / d).is_dir()), ".") + # A declared srcDir (falsy included) that does not resolve is a manifest error + src_dir = build["srcDir"] + if not (isinstance(src_dir, str) and src_dir and (read_path / src_dir).is_dir()): + raise EsphomeError( + f"Library {name} declares srcDir {src_dir!r} which does not exist" + ) + return src_dir + + +def _reject_unsupported_link_fields(name: str, data: dict) -> None: + # PIO honors these; ignoring them would fail at link with no stated + # cause. Property values are strings, so "false" is not a declaration. + precompiled = data.get("precompiled") + if precompiled and str(precompiled).strip().lower() != "false": + raise EsphomeError( + f"Library {name} declares precompiled, which this backend does not support" + ) + if data.get("ldflags"): + raise EsphomeError( + f"Library {name} declares ldflags, which this backend does not support" + ) + + +def _resolve_lib_archive(name: str, data: dict, build: dict) -> bool: + """build.libArchive, else dot_a_linkage (an Arduino IDE property PIO + ignores; a deliberate extra), else archive.""" + + # Strict parse: bool("false") is True + def _parse(key: str, raw: object) -> bool: + if isinstance(raw, bool): + return raw + value = str(raw).strip().lower() + if value in ("true", "false"): + return value == "true" + raise EsphomeError(f"Library {name} has a malformed {key} value {raw!r}") + + if "libArchive" in build: + return _parse("libArchive", build["libArchive"]) + if "dot_a_linkage" in data: + return _parse("dot_a_linkage", data["dot_a_linkage"]) + return True + + +def _classify_build_flags( + name: str, read_path: Path, lib: ArduinoLibrary, flag_tokens: list[str] +) -> list[str]: + """Route the lexed build.flags into the library's flag lists. + + Returns the ``-I`` arguments for the include-dir resolution. + """ + include_flags: list[str] = [] + for tok in flag_tokens: + if tok.startswith("-I"): + include_flags.append(tok[2:]) + elif tok.startswith("-L"): + link_dir = (read_path / tok[2:]).resolve() + if not link_dir.is_dir(): + # Kept (the linker ignores missing -L dirs); the warning + # names the culprit before a bare "cannot find -lfoo" + _LOGGER.warning( + "Library %s declares library dir %s which does not exist", + name, + tok[2:], + ) + lib.link_dirs.append(link_dir) + elif tok.startswith("-l"): + lib.link_libs.append(tok[2:]) + elif tok.startswith("-Wl,"): + lib.link_flags.append(tok) + else: + lib.flags.append(tok) + return include_flags + + +def _resolve_include_dirs( + name: str, + read_path: Path, + lib: ArduinoLibrary, + build: dict, + src_dir: str, + include_flags: list[str], +) -> None: + include_dir = build.get("includeDir", DEFAULT_BUILD_INCLUDE_DIR) + if not isinstance(include_dir, str): + raise EsphomeError(f"Library {name} has a malformed includeDir") + for d, explicit in [ + (include_dir, "includeDir" in build), + (src_dir, False), # _resolve_src_dir already validated it + *((flag, True) for flag in include_flags), + ]: + if (path := (read_path / d)).is_dir(): + lib.include_dirs.append(path.resolve()) + elif explicit: + # Warn-and-drop (unlike srcDir): a missing include dir is + # harmless until a header is needed, and the compile names it + _LOGGER.warning( + "Library %s declares include dir %s which does not exist", name, d + ) + + +def _collect_lib_sources( + name: str, + read_path: Path, + lib: ArduinoLibrary, + src_dir: str, + src_filter: list[str], +) -> None: + sources: list[Path] = [] + dropped: list[str] = [] + saw_header = False + for f in collect_filtered_files(read_path / src_dir, src_filter): + path = Path(f) + suffix = path.suffix + if suffix in SRC_FILE_EXTENSIONS: + # resolve() per file: srcFilter patterns may escape src_dir + sources.append(path.resolve()) + elif suffix.lower() in _UNMAPPED_SOURCE_SUFFIXES: + # A source-like suffix the case-sensitive map rejects (.CPP, + # .ino) is a dropped compilation unit; headers fall through + dropped.append(path.name) + elif suffix.lower() in LIBRARY_HEADER_SUFFIXES: + saw_header = True + lib.sources = sorted(sources) + if dropped: + _LOGGER.warning( + "Library %s: %d file(s) with unmapped source suffixes are not compiled: %s", + name, + len(dropped), + ", ".join(sorted(dropped)), + ) + if not lib.sources and not saw_header: + # Matched headers mean header-only; a filter matching nothing is + # a manifest/tree problem (a truly empty tree raises elsewhere) + _LOGGER.warning("Library %s: no source files matched", name) + + +def _library_info(name: str, read_path: Path, data: dict) -> ArduinoLibrary: + """Resolve one library's sources, include dirs, and flags (PIO semantics).""" + build = _manifest_build(name, data) + _reject_unsupported_link_fields(name, data) + src_dir = _resolve_src_dir(name, read_path, build) + src_filter = ensure_list(build.get("srcFilter", DEFAULT_BUILD_SRC_FILTER)) + if not all(isinstance(entry, str) for entry in src_filter): + raise EsphomeError(f"Library {name} has a malformed srcFilter") + lib = ArduinoLibrary(name=name, lib_archive=_resolve_lib_archive(name, data, build)) + # PlatformIO shell-lexes each build.flags entry + include_flags = _classify_build_flags( + name, read_path, lib, lex_build_flags(build.get("flags", []), f"library {name}") + ) + _resolve_include_dirs(name, read_path, lib, build, src_dir, include_flags) + _collect_lib_sources(name, read_path, lib, src_dir, src_filter) + return lib + + +def _bundled_library(framework_path: Path, name: str) -> ArduinoLibrary: + """A library bundled with the Arduino core, read from the framework tree. + + ``library.json`` wins over ``library.properties`` when both exist, as in + PlatformIO's LibBuilderFactory; only the JSON manifest can carry a + ``build`` section (srcDir, srcFilter, flags). + """ + lib_dir = framework_path / "libraries" / name + manifest_json = lib_dir / "library.json" + if manifest_json.is_file(): + try: + data = parse_library_json(manifest_json) + except ValueError as err: # JSONDecodeError + raise EsphomeError( + f"Bundled library {name} has a corrupt library.json ({err}); " + "the framework install may be incomplete (run 'esphome clean-all')" + ) from err + elif (manifest := lib_dir / "library.properties").is_file(): + data = parse_library_properties(manifest) + else: + # Debug, not warning: the legacy manifest-less layout is legal and + # the 3.1.2 core ships one such library (FSTools), so a warning + # would be unactionable noise on every build using it + _LOGGER.debug("Bundled library %s has no manifest; using defaults", name) + data = {} + if isinstance(data, dict): + # Bundled manifest deps are never walked; make the skip visible + if data.get("dependencies"): + _LOGGER.warning( + "Bundled library %s declares dependencies, which are not " + "resolved automatically; add them with add_library() if needed", + name, + ) + warn_properties_depends(name, data) + build = data.get("build") + if isinstance(build, dict) and build.get("extraScript"): + # Scripts only run on the converted path; building without + # the script's flags would miscompile + raise EsphomeError( + f"Bundled library {name} declares an extraScript, which is " + "not run for bundled libraries" + ) + lib = _library_info(name, lib_dir, data) + _assert_tree_has_code( + name, + lib_dir, + "the framework install may be incomplete (run 'esphome clean-all')", + ) + return lib + + +def _assert_tree_has_code(name: str, root: Path, hint: str) -> None: + """An empty or half-extracted tree can never link; fail by name (a + warning would scroll away and resurface as undefined symbols).""" + if not any( + Path(p).suffix in SRC_FILE_EXTENSIONS + or Path(p).suffix.lower() in LIBRARY_HEADER_SUFFIXES + for p in walk_files(root) + ): + raise EsphomeError(f"Library {name} has no sources or headers; {hint}") + + +def _external_short_name(name: str) -> str: + """The short library name of a requested spec. + + "owner/Name" and plain names take the last path segment; "Name=" + takes the declared name. Git tails (".git", "#ref") are stripped like + the walk's URL normalization; the comparand is a manifest dependency + name, never a spec. + """ + head, sep, tail = name.partition("=") + if sep and "://" in tail: + return head + short = name.rsplit("/", maxsplit=1)[-1] + return short.partition("#")[0].removesuffix(".git") + + +def _check_unfulfilled_provides( + provided_requests: set[str], satisfied: set[str], still_requested: set[str] +) -> None: + """Fail by name when a walk-skipped dependency was never added. + + An unfulfilled provides() promise only surfaces as undefined symbols + at link. The walk records across re-resolutions, so a name no final + manifest still requests is stale state, never a failure. + """ + if missing := sorted((provided_requests & still_requested) - satisfied): + raise EsphomeError( + "provides() skipped these dependencies but nothing added them: " + f"{', '.join(missing)}; the build is missing libraries" + ) + + +def resolve_libraries( + framework_path: Path, *, pio_platform: str, board_mcu: str, cache_key: str +) -> list[ArduinoLibrary]: + """Resolve every ``cg.add_library()`` entry into an :class:`ArduinoLibrary`. + + ``pio_platform``/``board_mcu`` filter manifests the way PlatformIO would + for that core (e.g. ``espressif8266``/``esp8266``); ``cache_key`` keys the + shared converter's download cache. + + The returned list is not topologically sorted, so the caller must link + the archives inside one ``--start-group``/``--end-group`` pair (the + bundled-first grouping is incidental). + """ + bundled: list[ArduinoLibrary] = [] + external: list[Library] = [] + # PlatformIO's lib_ignore covers framework-bundled libraries too; the + # shared converter only filters the registry/git ones. + lib_ignore = lib_ignore_set() + # Exact directory names keep membership case-sensitive everywhere + # (an is_dir() probe would match "wire" on macOS/Windows and build + # the bundled Wire twice) + libraries_dir = framework_path / "libraries" + if not libraries_dir.is_dir(): + # A registry fallback would fail later with a misleading + # package-not-found error per bundled name + raise EsphomeError( + f"{libraries_dir} is missing; the framework install may be " + "incomplete (run 'esphome clean-all')" + ) + bundled_dir_names = frozenset(p.name for p in libraries_dir.iterdir() if p.is_dir()) + + def _provided(name: object) -> bool: + return _is_safe_library_name(name) and name in bundled_dir_names + + for library in CORE.platformio_libraries.values(): + if is_lib_ignored(library.name, lib_ignore): + continue + # Bundled only for a bare name with a matching framework dir; pinned + # or unmatched names resolve from the registry, as under PlatformIO. + if not library.repository and not library.version and _provided(library.name): + # Bundled manifest deps are not walked; _bundled_library warns + bundled.append(_bundled_library(framework_path, library.name)) + else: + external.append(library) + + converted: list[ArduinoLibrary] = [] + bundled_names = {lib.name for lib in bundled} + converted_manifest_names: set[str] = set() + # Bundled candidates skipped on purpose (platform filter); the + # provides() reconciliation must count them as satisfied + knowingly_skipped: set[str] = set() + # Dependency names of the manifests actually emitted; a walk recording + # for a since-re-resolved manifest must not fail the reconciliation + final_dep_names: set[str] = set() + # Ordered set of bundled dependency names to add once conversion is done + pending_bundled: dict[str, None] = {} + # Deps matching a separately-requested external are already in the build + # (a duplicate archive means duplicate-symbol link errors) + external_short_names = { + _external_short_name(lib.name) for lib in external if lib.name + } + + def _add_bundled_dependencies(component: ConvertedLibrary) -> None: + # A version-less bare name ("Hash") is a core-bundled library the + # shared converter cannot resolve from the registry + for dep in normalize_dependencies( + component.data.get("dependencies"), component.name + ): + # normalize_dependencies guarantees a non-empty str name + name = dep["name"] + final_dep_names.add(name) + if "/" in name: + owner, _, pkg = name.partition("/") + if _is_safe_library_name(owner) and _is_safe_library_name(pkg): + # Owner-qualified; the converter resolves it from the registry + continue + if not _is_safe_library_name(name): + # The name becomes a path component; never join a traversal + _LOGGER.warning( + "Ignoring malformed dependency entry %r of library %s", + dep, + component.name, + ) + continue + if name in external_short_names: + if _provided(name): + # A bundled copy is suppressed; a coincidental name + # collision would surface as link errors + _LOGGER.warning( + "Dependency %s of %s is assumed satisfied by a " + "requested external library; the bundled copy is " + "not added", + name, + component.name, + ) + else: + _LOGGER.debug( + "Dependency %s of %s assumed satisfied by a requested " + "external library", + name, + component.name, + ) + continue + if name in bundled_names or is_lib_ignored(name, lib_ignore): + continue + if _url_or_none(dep.get("version")) is not None: + # A URL names one specific source; never add the bundled copy + continue + if dep.get("owner") or not _provided(name): + # Only owner-less framework-tree names take the bundled + # copy (PIO's process_dependencies); the walk reports drops + continue + try: + # framework=None: the walk already warned for non-platform + # causes; debug keeps one fault from warning twice (pinned + # by test_nonplatform_rejection_warns_once_through_real_converter) + check_library_data(dep, pio_platform, None) + except IncompatiblePlatform as err: + # A knowing skip (platform filter), not a broken promise + knowingly_skipped.add(name) + _LOGGER.debug("Skip bundled candidate %s: %s", name, err) + continue + except InvalidLibrary as err: + # Malformed manifest data never counts as satisfied; the + # walk owns the warning (see the warns-once test above) + _LOGGER.debug("Skip malformed bundled candidate %s: %s", name, err) + continue + # Deferred: a later manifest name may satisfy this + pending_bundled.setdefault(name) + + def _emit(component: ConvertedLibrary) -> None: + apply_extra_script( + component, board_mcu=lambda: board_mcu, pio_platform=pio_platform + ) + _assert_tree_has_code( + component.get_require_name(), + component.source_dir, + "the download may be incomplete (run 'esphome clean-all')", + ) + if isinstance(manifest_name := component.data.get("name"), str): + converted_manifest_names.add(manifest_name) + lib = _library_info( + component.get_require_name(), component.source_dir, component.data + ) + # Extra-script LINKFLAGS travel outside build.flags; dropping + # them would link wrong with no stated cause + lib.link_flags.extend( + component.data.get(ESPHOME_DATA_KEY, {}).get( + ESPHOME_DATA_LINK_FLAGS_KEY, [] + ) + ) + converted.append(lib) + _add_bundled_dependencies(component) + + backend = LibraryBackend( + platform=pio_platform, + framework="arduino", + emit=_emit, + cache_key=cache_key, + # The walk must not resolve bundled names from the registry; + # _add_bundled_dependencies adds them after emit + provides=_provided, + ) + if external: + convert_libraries(external, backend) + for name in pending_bundled: + if name in converted_manifest_names: + # The converted library is this one; the bundled copy would + # double the archive. Warn like the external_short_names twin. + _LOGGER.warning( + "Dependency %s is assumed satisfied by a converted library's " + "manifest name; the bundled copy is not added", + name, + ) + continue + bundled_names.add(name) + bundled.append(_bundled_library(framework_path, name)) + + _check_unfulfilled_provides( + backend.provided_requests, + bundled_names + | converted_manifest_names + | external_short_names + | knowingly_skipped, + final_dep_names, + ) + + return bundled + converted diff --git a/esphome/build_gen/build_tool.py b/esphome/build_gen/build_tool.py new file mode 100644 index 0000000000..00aa1ec69d --- /dev/null +++ b/esphome/build_gen/build_tool.py @@ -0,0 +1,108 @@ +"""Tiny cross-platform build steps invoked from the generated ninja file. + +Plain script (not ``python -m``): it runs from ninja with whatever Python +started esphome and must not depend on the package being importable. + +Subcommands: + ar remove stale archive, then ``ar rcs`` + copy copy a file + +The ar rspfile carries one object path per line (the generating rule must +use ``$in_newline``, never ``$in``). +""" + +from pathlib import Path +import shutil +import subprocess +import sys + + +def _read_rspfile(rspfile: str) -> list[str]: + r"""The object paths listed in ``rspfile``, unquoted. + + GNU ar treats backslashes in response files as escapes (corrupts + Windows paths), so the caller expands the list into argv; strip the + simple surrounding quote ninja adds to special paths, then undo + ninja's POSIX escape for an embedded quote ('a'\\''b.o' -> a'b.o). + """ + return [ + line[1:-1].replace("'\\''", "'") + if len(line) >= 2 and line[0] == line[-1] and line[0] in "'\"" + else line + for line in Path(rspfile).read_text(encoding="utf-8").splitlines() + if line + ] + + +def _run_ar(ar: str, archive: str, rspfile: str) -> int: + # Remove first: ``ar rcs`` replaces members but never drops ones whose + # source was removed from the build, which would leak stale objects. + Path(archive).unlink(missing_ok=True) + objects = _read_rspfile(rspfile) + if not objects: + # An empty archive would "succeed" here and fail far away at link + print(f"ar: no objects listed in {rspfile} for {archive}", file=sys.stderr) + return 1 + # Batch by argv length: expanding the rspfile gives back the Windows + # 32767-char command-line limit it existed to avoid. "rcs" creates, + # "qs" appends; the s keeps the symbol index explicit on every ar. + op = "rcs" + ok = False + try: + while objects: + batch = [objects.pop(0)] + batch_len = len(batch[0]) + while objects and batch_len + len(objects[0]) < 25000: + batch_len += len(objects[0]) + 1 + batch.append(objects.pop(0)) + rc = subprocess.run( + [ar, op, archive, *batch], check=False, close_fds=False + ).returncode + if rc != 0: + return rc + op = "qs" + ok = True + return 0 + finally: + if not ok: + # Any failure (bad exit, missing ar binary, interrupt) must not + # leave a truncated archive behind + Path(archive).unlink(missing_ok=True) + + +def _run_copy(src: str, dst: str) -> int: + try: + shutil.copyfile(src, dst) + except OSError as err: + # Never leave a partially written output (e.g. a firmware image); + # SameFileError means dst IS src, where unlinking destroys the input + if not isinstance(err, shutil.SameFileError): + Path(dst).unlink(missing_ok=True) + print(f"copy: {src} -> {dst} failed: {err}", file=sys.stderr) + return 1 + return 0 + + +# mode -> (handler, expected operand count); surplus argv means a +# mis-specified ninja rule and must error, not silently drop operands +_MODES = {"ar": (_run_ar, 3), "copy": (_run_copy, 2)} + + +def main() -> int: + mode = sys.argv[1] if len(sys.argv) > 1 else "" + if entry := _MODES.get(mode): + handler, argc = entry + args = sys.argv[2:] + if len(args) != argc: + print( + f"build_tool {mode}: expected {argc} arguments, got {len(args)}", + file=sys.stderr, + ) + return 1 + return handler(*args) + print(f"unknown build_tool mode: {mode}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": # pragma: no cover + sys.exit(main()) diff --git a/esphome/codegen.py b/esphome/codegen.py index 2aa6a70abd..5debb52b4e 100644 --- a/esphome/codegen.py +++ b/esphome/codegen.py @@ -78,6 +78,7 @@ from esphome.cpp_types import ( # noqa: F401 StringRef, arduino_json_ns, bool_, + char, const_char_ptr, double, esphome_ns, diff --git a/esphome/components/adc/__init__.py b/esphome/components/adc/__init__.py index 5c763a4f4c..c397e746b0 100644 --- a/esphome/components/adc/__init__.py +++ b/esphome/components/adc/__init__.py @@ -13,6 +13,7 @@ from esphome.components.esp32 import ( VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3, + VARIANT_ESP32S31, get_esp32_variant, ) import esphome.config_validation as cv @@ -156,6 +157,17 @@ ESP32_VARIANT_ADC1_PIN_TO_CHANNEL = { 9: adc_channel_t.ADC_CHANNEL_8, 10: adc_channel_t.ADC_CHANNEL_9, }, + # https://github.com/espressif/esp-idf/blob/master/components/soc/esp32s31/include/soc/adc_channel.h + VARIANT_ESP32S31: { + 42: adc_channel_t.ADC_CHANNEL_0, + 43: adc_channel_t.ADC_CHANNEL_1, + 44: adc_channel_t.ADC_CHANNEL_2, + 45: adc_channel_t.ADC_CHANNEL_3, + 46: adc_channel_t.ADC_CHANNEL_4, + 47: adc_channel_t.ADC_CHANNEL_5, + 48: adc_channel_t.ADC_CHANNEL_6, + 49: adc_channel_t.ADC_CHANNEL_7, + }, } # pin to adc2 channel mapping @@ -225,6 +237,17 @@ ESP32_VARIANT_ADC2_PIN_TO_CHANNEL = { 19: adc_channel_t.ADC_CHANNEL_8, 20: adc_channel_t.ADC_CHANNEL_9, }, + # https://github.com/espressif/esp-idf/blob/master/components/soc/esp32s31/include/soc/adc_channel.h + VARIANT_ESP32S31: { + 50: adc_channel_t.ADC_CHANNEL_0, + 51: adc_channel_t.ADC_CHANNEL_1, + 52: adc_channel_t.ADC_CHANNEL_2, + 53: adc_channel_t.ADC_CHANNEL_3, + 54: adc_channel_t.ADC_CHANNEL_4, + 55: adc_channel_t.ADC_CHANNEL_5, + 56: adc_channel_t.ADC_CHANNEL_6, + 57: adc_channel_t.ADC_CHANNEL_7, + }, } diff --git a/esphome/components/adc/adc_sensor_esp32.cpp b/esphome/components/adc/adc_sensor_esp32.cpp index a0f7a1ed08..c9887cea7c 100644 --- a/esphome/components/adc/adc_sensor_esp32.cpp +++ b/esphome/components/adc/adc_sensor_esp32.cpp @@ -74,9 +74,7 @@ void ADCSensor::setup() { if (this->calibration_handle_ == nullptr) { adc_cali_handle_t handle = nullptr; -#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \ - USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3 - // RISC-V variants (except C2) and S3 use curve fitting calibration +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) adc_cali_curve_fitting_config_t cali_config = {}; // Zero initialize first #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0) cali_config.chan = this->channel_; @@ -94,7 +92,7 @@ void ADCSensor::setup() { ESP_LOGW(TAG, "Curve fitting calibration failed with error %d, will use uncalibrated readings", err); this->setup_flags_.calibration_complete = false; } -#else // ESP32, ESP32-S2, and ESP32-C2 use line fitting calibration +#elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) adc_cali_line_fitting_config_t cali_config = { .unit_id = this->adc_unit_, .atten = this->attenuation_, @@ -112,7 +110,11 @@ void ADCSensor::setup() { ESP_LOGW(TAG, "Line fitting calibration failed with error %d, will use uncalibrated readings", err); this->setup_flags_.calibration_complete = false; } -#endif // ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3 +#else // No calibration scheme available + (void) handle; + ESP_LOGD(TAG, "No calibration scheme for this variant, readings are uncalibrated"); + this->setup_flags_.calibration_complete = false; +#endif } this->setup_flags_.init_complete = true; @@ -121,23 +123,28 @@ void ADCSensor::setup() { void ADCSensor::dump_config() { LOG_SENSOR("", "ADC Sensor", this); LOG_PIN(" Pin: ", this->pin_); - ESP_LOGCONFIG( - TAG, - " Channel: %d\n" - " Unit: %s\n" - " Attenuation: %s\n" - " Samples: %i\n" - " Sampling mode: %s\n" - " Setup Status:\n" - " Handle Init: %s\n" - " Config: %s\n" - " Calibration: %s\n" - " Overall Init: %s", - this->channel_, LOG_STR_ARG(adc_unit_to_str(this->adc_unit_)), - this->autorange_ ? "Auto" : LOG_STR_ARG(attenuation_to_str(this->attenuation_)), this->sample_count_, - LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)), - this->setup_flags_.handle_init_complete ? "OK" : "FAILED", this->setup_flags_.config_complete ? "OK" : "FAILED", - this->setup_flags_.calibration_complete ? "OK" : "FAILED", this->setup_flags_.init_complete ? "OK" : "FAILED"); +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) || defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) + const char *calibration_status = this->setup_flags_.calibration_complete ? "OK" : "FAILED"; +#else + const char *calibration_status = "N/A"; // This variant has no calibration scheme +#endif + ESP_LOGCONFIG(TAG, + " Channel: %d\n" + " Unit: %s\n" + " Attenuation: %s\n" + " Samples: %i\n" + " Sampling mode: %s\n" + " Setup Status:\n" + " Handle Init: %s\n" + " Config: %s\n" + " Calibration: %s\n" + " Overall Init: %s", + this->channel_, LOG_STR_ARG(adc_unit_to_str(this->adc_unit_)), + this->autorange_ ? "Auto" : LOG_STR_ARG(attenuation_to_str(this->attenuation_)), this->sample_count_, + LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)), + this->setup_flags_.handle_init_complete ? "OK" : "FAILED", + this->setup_flags_.config_complete ? "OK" : "FAILED", calibration_status, + this->setup_flags_.init_complete ? "OK" : "FAILED"); LOG_UPDATE_INTERVAL(this); } @@ -184,12 +191,11 @@ float ADCSensor::sample_fixed_attenuation_() { } else { ESP_LOGW(TAG, "ADC calibration conversion failed with error %d, disabling calibration", err); if (this->calibration_handle_ != nullptr) { -#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \ - USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3 +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) adc_cali_delete_scheme_curve_fitting(this->calibration_handle_); -#else // Other ESP32 variants use line fitting calibration +#elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) adc_cali_delete_scheme_line_fitting(this->calibration_handle_); -#endif // ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3 +#endif this->calibration_handle_ = nullptr; } } @@ -217,10 +223,9 @@ float ADCSensor::sample_autorange_() { // Need to recalibrate for the new attenuation if (this->calibration_handle_ != nullptr) { // Delete old calibration handle -#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \ - USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3 +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) adc_cali_delete_scheme_curve_fitting(this->calibration_handle_); -#else +#elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) adc_cali_delete_scheme_line_fitting(this->calibration_handle_); #endif this->calibration_handle_ = nullptr; @@ -229,8 +234,7 @@ float ADCSensor::sample_autorange_() { // Create new calibration handle for this attenuation adc_cali_handle_t handle = nullptr; -#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \ - USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3 +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) adc_cali_curve_fitting_config_t cali_config = {}; #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0) cali_config.chan = this->channel_; @@ -242,7 +246,7 @@ float ADCSensor::sample_autorange_() { err = adc_cali_create_scheme_curve_fitting(&cali_config, &handle); ESP_LOGVV(TAG, "Autorange atten=%d: Calibration handle creation %s (err=%d)", atten, (err == ESP_OK) ? "SUCCESS" : "FAILED", err); -#else +#elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) adc_cali_line_fitting_config_t cali_config = { .unit_id = this->adc_unit_, .atten = atten, @@ -264,10 +268,9 @@ float ADCSensor::sample_autorange_() { if (err != ESP_OK) { ESP_LOGW(TAG, "ADC read failed in autorange with error %d", err); if (handle != nullptr) { -#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \ - USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3 +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) adc_cali_delete_scheme_curve_fitting(handle); -#else +#elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) adc_cali_delete_scheme_line_fitting(handle); #endif } @@ -286,10 +289,9 @@ float ADCSensor::sample_autorange_() { ESP_LOGVV(TAG, "Autorange atten=%d: UNCALIBRATED FALLBACK - raw=%d -> %.6fV (3.3V ref)", atten, raw, voltage); } // Clean up calibration handle -#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \ - USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3 +#if defined(ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED) adc_cali_delete_scheme_curve_fitting(handle); -#else +#elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED) adc_cali_delete_scheme_line_fitting(handle); #endif } else { diff --git a/esphome/components/adc/sensor.py b/esphome/components/adc/sensor.py index 5d1031825e..8cdea4f01a 100644 --- a/esphome/components/adc/sensor.py +++ b/esphome/components/adc/sensor.py @@ -3,6 +3,7 @@ import logging import esphome.codegen as cg from esphome.components import sensor, voltage_sampler from esphome.components.esp32 import ( + VARIANT_ESP32S31, get_esp32_variant, include_builtin_idf_component, require_adc_oneshot_iram, @@ -56,6 +57,14 @@ def validate_config(config: ConfigType) -> ConfigType: if config[CONF_RAW] and config.get(CONF_ATTENUATION, None) == "auto": raise cv.Invalid("Automatic attenuation cannot be used when raw output is set") + # The S31 ADC supports a single attenuation level (SOC_ADC_ATTEN_NUM is 1) + if ( + CORE.is_esp32 + and get_esp32_variant() == VARIANT_ESP32S31 + and config.get(CONF_ATTENUATION, "0db") != "0db" + ): + raise cv.Invalid("ESP32-S31 only supports 'attenuation: 0db'") + if config.get(CONF_ATTENUATION, None) == "auto" and config.get(CONF_SAMPLES, 1) > 1: raise cv.Invalid( "Automatic attenuation cannot be used when multisampling is set" diff --git a/esphome/components/alpha3/alpha3.cpp b/esphome/components/alpha3/alpha3.cpp index 048c365616..92b00d87cb 100644 --- a/esphome/components/alpha3/alpha3.cpp +++ b/esphome/components/alpha3/alpha3.cpp @@ -162,8 +162,9 @@ void Alpha3::send_request_(uint8_t *request, size_t len) { auto status = esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->geni_handle_, len, request, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE); - if (status) + if (status) { ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status); + } } void Alpha3::update() { diff --git a/esphome/components/api/__init__.py b/esphome/components/api/__init__.py index 2e891a9663..3568318dad 100644 --- a/esphome/components/api/__init__.py +++ b/esphome/components/api/__init__.py @@ -5,6 +5,7 @@ from typing import Any from esphome import automation from esphome.automation import Condition import esphome.codegen as cg +from esphome.components.const import CONF_DESCRIPTION from esphome.components.logger import request_log_listener # ENCRYPTION_SCHEMA and validate_encryption_key are re-exported for external @@ -41,10 +42,12 @@ from esphome.const import ( CONF_TAG, CONF_THEN, CONF_TRIGGER_ID, + CONF_TYPE, CONF_VARIABLES, ) from esphome.core import CORE, ID, CoroPriority, EsphomeError, coroutine_with_priority from esphome.cpp_generator import MockObj, TemplateArgsType +from esphome.helpers import fnv1_hash from esphome.types import ConfigFragmentType, ConfigType # Compat alias: downstream consumers (e.g. device-builder) referenced the @@ -125,6 +128,7 @@ SERVICE_ARG_FALLBACK_TYPES: dict[str, MockObj] = { } CONF_BATCH_DELAY = "batch_delay" CONF_CUSTOM_SERVICES = "custom_services" +CONF_EXAMPLE = "example" CONF_HOMEASSISTANT_SERVICES = "homeassistant_services" CONF_HOMEASSISTANT_STATES = "homeassistant_states" CONF_LISTEN_BACKLOG = "listen_backlog" @@ -228,14 +232,30 @@ def _validate_supports_response(value: Any) -> str: return cv.enum(SUPPORTS_RESPONSE_OPTIONS, lower=True)(value) +# ESP8266 copies every string of an action into a stack buffer sized by codegen; keep it small +ESP8266_ACTION_STRINGS_MAX_TOTAL = 384 + +VARIABLE_SCHEMA = cv.Schema( + { + cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True), + cv.Optional(CONF_DESCRIPTION): cv.string_strict, + cv.Optional(CONF_EXAMPLE): cv.string_strict, + } +) + +# Accepts the plain `name: type` shorthand or the full mapping form +validate_variable = cv.maybe_simple_value(VARIABLE_SCHEMA, key=CONF_TYPE) + + ACTIONS_SCHEMA = automation.validate_automation( { cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger), cv.Exclusive(CONF_SERVICE, group_of_exclusion=CONF_ACTION): cv.valid_name, cv.Exclusive(CONF_ACTION, group_of_exclusion=CONF_ACTION): cv.valid_name, + cv.Optional(CONF_DESCRIPTION): cv.string_strict, cv.Optional(CONF_VARIABLES, default={}): cv.Schema( { - cv.validate_id_name: cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True), + cv.validate_id_name: validate_variable, } ), # No default - auto-detected by _auto_detect_supports_response @@ -352,6 +372,85 @@ CONFIG_SCHEMA = cv.All( ) +def _has_action_metadata(actions: list[ConfigType]) -> bool: + # Empty strings count as unset, matching _action_strings + return any( + conf.get(CONF_DESCRIPTION) + or any( + var_.get(CONF_DESCRIPTION) or var_.get(CONF_EXAMPLE) + for var_ in conf[CONF_VARIABLES].values() + ) + for conf in actions + ) + + +def _action_strings(conf: ConfigType, has_metadata: bool) -> list[str | None]: + """Strings of one action in the table order UserServiceStatic (user_services.h) expects.""" + # An empty description or example is treated as unset + strings: list[str | None] = [conf[CONF_ACTION]] + if has_metadata: + strings.append(conf.get(CONF_DESCRIPTION) or None) + for name, var_ in conf[CONF_VARIABLES].items(): + strings.append(name) + if has_metadata: + strings += [ + var_.get(CONF_DESCRIPTION) or None, + var_.get(CONF_EXAMPLE) or None, + ] + return strings + + +def _action_strings_size(strings: list[str | None]) -> int: + """Bytes needed to copy every string out of flash, each with its terminator.""" + return sum( + len(string.encode("utf-8")) + 1 for string in strings if string is not None + ) + + +def _validate_esp8266_action_strings(config: ConfigType) -> ConfigType: + if not CORE.is_esp8266: + return config + actions = config.get(CONF_ACTIONS, []) + has_metadata = _has_action_metadata(actions) + for conf in actions: + size = _action_strings_size(_action_strings(conf, has_metadata)) + if size > ESP8266_ACTION_STRINGS_MAX_TOTAL: + raise cv.Invalid( + f"Action '{conf[CONF_ACTION]}' has {size} bytes of name, variable name, " + f"description and example text; ESP8266 allows at most " + f"{ESP8266_ACTION_STRINGS_MAX_TOTAL} bytes per action" + ) + return config + + +FINAL_VALIDATE_SCHEMA = _validate_esp8266_action_strings + + +def _add_action_strings( + index: int, strings: list[str | None], interned: dict[str, MockObj] +) -> MockObj: + """Emit the PROGMEM string table for one action. + + Each string is its own PROGMEM array because on ESP8266 .rodata is RAM, and identical + strings are shared between actions through `interned`. + """ + entries: list[MockObj] = [] + for string in strings: + if string is None: + entries.append(cg.nullptr) + continue + if (var := interned.get(string)) is None: + var = interned[string] = cg.progmem_array( + ID(f"api_action_str{len(interned)}", is_declaration=True, type=cg.char), + string, + ) + entries.append(var) + return cg.progmem_array( + ID(f"api_action{index}_strings", is_declaration=True, type=cg.const_char_ptr), + entries, + ) + + @coroutine_with_priority(CoroPriority.WEB) async def to_code(config: ConfigType) -> None: var = cg.new_Pvariable(config[CONF_ID]) @@ -371,8 +470,10 @@ async def to_code(config: ConfigType) -> None: cg.add_define("MAX_API_CONNECTIONS", config[CONF_MAX_CONNECTIONS]) cg.add_define("API_MAX_SEND_QUEUE", config[CONF_MAX_SEND_QUEUE]) + actions = config.get(CONF_ACTIONS, []) + has_user_actions = bool(actions) or config[CONF_CUSTOM_SERVICES] # Set USE_API_USER_DEFINED_ACTIONS if any services are enabled - if config.get(CONF_ACTIONS) or config[CONF_CUSTOM_SERVICES]: + if has_user_actions: cg.add_define("USE_API_USER_DEFINED_ACTIONS") # Set USE_API_CUSTOM_SERVICES if external components need dynamic service registration @@ -385,10 +486,17 @@ async def to_code(config: ConfigType) -> None: if config[CONF_HOMEASSISTANT_STATES]: cg.add_define("USE_API_HOMEASSISTANT_STATES") - if actions := config.get(CONF_ACTIONS, []): + scratch_size = 0 + if actions: + # Metadata is compiled in for every action once any action declares it, because the + # string table layout is fixed by the define rather than per action + has_metadata = _has_action_metadata(actions) + if has_metadata: + cg.add_define("USE_API_USER_DEFINED_ACTION_METADATA") + interned_strings: dict[str, MockObj] = {} # Collect all triggers first, then register all at once with initializer_list triggers: list[cg.MockObj] = [] - for conf in actions: + for index, conf in enumerate(actions): func_args: list[tuple[MockObj, str]] = [] service_template_args: list[MockObj] = [] # User service argument types @@ -421,22 +529,23 @@ async def to_code(config: ConfigType) -> None: conf.get(CONF_THEN, []) ) - service_arg_names: list[str] = [] for name, var_ in conf[CONF_VARIABLES].items(): - if has_non_synchronous and var_ in SERVICE_ARG_FALLBACK_TYPES: - native = SERVICE_ARG_FALLBACK_TYPES[var_] + var_type = var_[CONF_TYPE] + if has_non_synchronous and var_type in SERVICE_ARG_FALLBACK_TYPES: + native = SERVICE_ARG_FALLBACK_TYPES[var_type] else: - native = SERVICE_ARG_NATIVE_TYPES[var_] + native = SERVICE_ARG_NATIVE_TYPES[var_type] service_template_args.append(native) func_args.append((native, name)) - service_arg_names.append(name) + strings = _action_strings(conf, has_metadata) + table = _add_action_strings(index, strings, interned_strings) + if CORE.is_esp8266: + scratch_size = max(scratch_size, _action_strings_size(strings)) # Template args: supports_response mode, then user service arg types templ = cg.TemplateArguments(supports_response, *service_template_args) + # Key is hashed here because the name is not readable at runtime on ESP8266 trigger = cg.new_Pvariable( - conf[CONF_TRIGGER_ID], - templ, - conf[CONF_ACTION], - service_arg_names, + conf[CONF_TRIGGER_ID], templ, table, fnv1_hash(conf[CONF_ACTION]) ) triggers.append(trigger) auto = await automation.build_automation(trigger, func_args, conf) @@ -458,6 +567,9 @@ async def to_code(config: ConfigType) -> None: cg.add(auto.add_actions([unregister_action])) # Register all services at once - single allocation, no reallocations cg.add(var.initialize_user_services(triggers)) + if CORE.is_esp8266 and has_user_actions: + # Stack buffer that list-entities copies PROGMEM strings into, sized for the largest action + cg.add_define("API_USER_ACTION_STRINGS_SCRATCH_SIZE", max(scratch_size, 1)) if CONF_ON_CLIENT_CONNECTED in config: cg.add_define("USE_API_CLIENT_CONNECTED_TRIGGER") diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto index c11700782e..3a0e0abea9 100644 --- a/esphome/components/api/api.proto +++ b/esphome/components/api/api.proto @@ -1034,6 +1034,8 @@ message ListEntitiesServicesArgument { option (ifdef) = "USE_API_USER_DEFINED_ACTIONS"; string name = 1; ServiceArgType type = 2; + string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"]; + string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"]; } message ListEntitiesServicesResponse { option (id) = 41; @@ -1044,6 +1046,7 @@ message ListEntitiesServicesResponse { fixed32 key = 2 [(force) = true]; repeated ListEntitiesServicesArgument args = 3 [(fixed_vector) = true]; SupportsResponseType supports_response = 4; + string description = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"]; } message ExecuteServiceArgument { option (ifdef) = "USE_API_USER_DEFINED_ACTIONS"; diff --git a/esphome/components/api/api_buffer.cpp b/esphome/components/api/api_buffer.cpp index 6db18b0365..fc45a4e971 100644 --- a/esphome/components/api/api_buffer.cpp +++ b/esphome/components/api/api_buffer.cpp @@ -1,13 +1,20 @@ #include "api_buffer.h" +#include namespace esphome::api { -void APIBuffer::grow_(size_t n) { - auto new_data = make_buffer(n); +bool APIBuffer::grow_(size_t n) { + // nothrow (no zero-fill) so OOM is reportable; plain new aborts instead + // (NEW_OOM_ABORT on ESP8266 Arduino, exception stub on ESP-IDF). + // RAMAllocator is no fit here: unique_ptr needs delete[]-compatible memory. + std::unique_ptr new_data(new (std::nothrow) uint8_t[n]); + if (new_data == nullptr) + return false; if (this->size_) std::memcpy(new_data.get(), this->data_.get(), this->size_); this->data_ = std::move(new_data); this->capacity_ = n; + return true; } } // namespace esphome::api diff --git a/esphome/components/api/api_buffer.h b/esphome/components/api/api_buffer.h index 1d0cccf61c..396dadbe58 100644 --- a/esphome/components/api/api_buffer.h +++ b/esphome/components/api/api_buffer.h @@ -9,16 +9,6 @@ namespace esphome::api { -/// Helper to use make_unique_for_overwrite where available (skips zero-fill), -/// falling back to make_unique on older GCC (ESP8266, LibreTiny). -inline std::unique_ptr make_buffer(size_t n) { -#if defined(USE_ESP8266) || defined(USE_LIBRETINY) - return std::make_unique(n); -#else - return std::make_unique_for_overwrite(n); -#endif -} - /// Byte buffer that skips zero-initialization on resize(). /// /// std::vector::resize() zero-fills new bytes via memset. For the @@ -36,23 +26,23 @@ inline std::unique_ptr make_buffer(size_t n) { class APIBuffer { public: void clear() { this->size_ = 0; } - inline void reserve(size_t n) ESPHOME_ALWAYS_INLINE { - if (n > this->capacity_) - this->grow_(n); - } - inline void resize(size_t n) ESPHOME_ALWAYS_INLINE { - this->reserve(n); - this->size_ = n; // no zero-fill - } + /// Returns false if allocation fails; the buffer is left unchanged. + [[nodiscard]] inline bool reserve(size_t n) ESPHOME_ALWAYS_INLINE { return n <= this->capacity_ || this->grow_(n); } + /// Returns false if allocation fails; the buffer is left unchanged. No zero-fill. + [[nodiscard]] inline bool resize(size_t n) ESPHOME_ALWAYS_INLINE { return this->reserve_and_resize(n, n); } /// Reserve capacity for max(reserve_size, new_size) bytes, then set size to new_size. /// Single grow_ check regardless of argument order. - inline void reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE { - this->reserve(std::max(reserve_size, new_size)); + /// Returns false if allocation fails; the buffer is left unchanged. + [[nodiscard]] inline bool reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE { + if (!this->reserve(std::max(reserve_size, new_size))) + return false; this->size_ = new_size; + return true; } uint8_t *data() { return this->data_.get(); } const uint8_t *data() const { return this->data_.get(); } size_t size() const { return this->size_; } + size_t capacity() const { return this->capacity_; } bool empty() const { return this->size_ == 0; } uint8_t &operator[](size_t i) { return this->data_[i]; } const uint8_t &operator[](size_t i) const { return this->data_[i]; } @@ -64,7 +54,7 @@ class APIBuffer { } protected: - void grow_(size_t n); + bool grow_(size_t n); std::unique_ptr data_; size_t size_{0}; size_t capacity_{0}; diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp index 7b0cb7069e..9c609aa047 100644 --- a/esphome/components/api/api_connection.cpp +++ b/esphome/components/api/api_connection.cpp @@ -1,6 +1,6 @@ #include "api_connection.h" #ifdef USE_API -#include "api_connection_buffer.h" // for encode_to_buffer / get_batch_delay_ms_ inlines +#include "api_connection_buffer.h" // for the APIServer-dependent APIConnection inlines #ifdef USE_API_NOISE #include "api_frame_helper_noise.h" #endif @@ -2239,10 +2239,17 @@ bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type, this->log_send_message_(proto_msg->message_name(), proto_msg->dump_to(dump_buf)); } #endif + if (!this->prepare_first_message_buffer(payload_size)) [[unlikely]] { + this->fatal_out_of_memory_(); + return false; + } auto &shared_buf = this->parent_->get_shared_buffer_ref(); - this->prepare_first_message_buffer(shared_buf, payload_size); size_t write_start = shared_buf.size(); - shared_buf.resize(write_start + payload_size); +#ifdef ESPHOME_DEBUG_API + assert(shared_buf.capacity() >= write_start + payload_size); +#endif + // Capacity reserved above, cannot fail + (void) shared_buf.resize(write_start + payload_size); ProtoWriteBuffer buffer{&shared_buf, write_start}; encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf)); return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type); @@ -2278,6 +2285,9 @@ void APIConnection::on_no_setup_connection() { this->on_fatal_error(); this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup")); } +void APIConnection::fatal_out_of_memory_() { + this->fatal_error_with_log_(LOG_STR("Out of memory"), APIError::OUT_OF_MEMORY); +} void APIConnection::on_fatal_error() { // Don't close socket here - keep it open so getpeername() works for logging // Socket will be closed when client is removed from the list in APIServer::loop() @@ -2292,16 +2302,25 @@ bool APIConnection::schedule_message_front_(EntityBase *entity, uint16_t message bool APIConnection::send_message_smart_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size, uint8_t aux_data_index) { if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) { - auto &shared_buf = this->parent_->get_shared_buffer_ref(); - this->prepare_first_message_buffer(shared_buf, estimated_size); + // No local for the shared buffer here: keeping it live across + // dispatch_message_ costs a register and spills message_type into the + // batching path's dedup loop (measured on x86 GCC -Os) + if (!this->prepare_first_message_buffer(estimated_size)) [[unlikely]] { + this->fatal_out_of_memory_(); + return false; + } DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index}; if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) && - this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type)) { + this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) { #ifdef HAS_PROTO_MESSAGE_DUMP this->log_batch_item_(item); #endif return true; } + // An OOM during the immediate attempt marks the connection for removal; + // don't queue more work (schedule_message_'s push_back may allocate again) + if (this->flags_.remove) [[unlikely]] + return false; } return this->schedule_message_(entity, message_type, estimated_size, aux_data_index); } @@ -2351,7 +2370,11 @@ void APIConnection::process_batch_() { total_estimated_size = MAX_BATCH_PACKET_SIZE; } - this->prepare_first_message_buffer(shared_buf, header_padding, total_estimated_size); + if (!this->prepare_first_message_buffer(header_padding, total_estimated_size)) [[unlikely]] { + this->fatal_out_of_memory_(); + this->clear_batch_(); + return; + } // Fast path for single message - buffer already allocated above if (num_items == 1) { @@ -2366,8 +2389,11 @@ void APIConnection::process_batch_() { #endif this->clear_batch_(); } else if (payload_size == 0) { - // Message too large to fit in available space - ESP_LOGW(TAG, "Message too large to send: type=%u", item.message_type); + // payload_size == 0 with remove set means encoding hit OOM and the + // connection is being dropped; warn only for a genuinely oversized message + if (!this->flags_.remove) { + ESP_LOGW(TAG, "Message too large to send: type=%u", item.message_type); + } this->clear_batch_(); } return; @@ -2430,8 +2456,10 @@ void APIConnection::process_batch_multi_(APIBuffer &shared_buf, size_t num_items if (items_processed > 0) { // Add footer space for the last message (for Noise protocol MAC) - if (footer_size > 0) { - shared_buf.resize(shared_buf.size() + footer_size); + if (footer_size > 0 && !shared_buf.resize(shared_buf.size() + footer_size)) [[unlikely]] { + this->fatal_out_of_memory_(); + this->clear_batch_(); + return; } // Send all collected messages diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h index 5a554f4857..a4c49dccf4 100644 --- a/esphome/components/api/api_connection.h +++ b/esphome/components/api/api_connection.h @@ -352,22 +352,13 @@ class APIConnection final : public APIServerConnectionBase { } } - void prepare_first_message_buffer(APIBuffer &shared_buf, size_t header_padding, size_t total_size) { - shared_buf.clear(); - // Reserve space for header padding + message + footer - // - Header padding: space for protocol headers (7 bytes for Noise, 6 for Plaintext) - // - Footer: space for MAC (16 bytes for Noise, 0 for Plaintext) - // Reserve full size but only set initial size to header padding - // so message encoding starts at the correct position - shared_buf.reserve_and_resize(total_size, header_padding); - } + /// Clear the shared write buffer and reserve space for the first message. + /// Returns false if the allocation fails (out of memory). + /// Defined in api_connection_buffer.h (needs APIServer complete). + [[nodiscard]] bool prepare_first_message_buffer(size_t header_padding, size_t total_size); // Convenience overload - computes frame overhead internally - void prepare_first_message_buffer(APIBuffer &shared_buf, size_t payload_size) { - const uint8_t header_padding = this->helper_->frame_header_padding(); - const uint8_t footer_size = this->helper_->frame_footer_size(); - this->prepare_first_message_buffer(shared_buf, header_padding, payload_size + header_padding + footer_size); - } + [[nodiscard]] bool prepare_first_message_buffer(size_t payload_size); bool try_to_clear_buffer(bool log_out_of_space) { if (this->flags_.remove) @@ -853,6 +844,9 @@ class APIConnection final : public APIServerConnectionBase { this->on_fatal_error(); this->log_warning_(message, err); } + // Shared cold path for buffer allocation failures — noinline keeps the + // OOM handling out of the hot send paths + void __attribute__((noinline)) fatal_out_of_memory_(); }; } // namespace esphome::api diff --git a/esphome/components/api/api_connection_buffer.h b/esphome/components/api/api_connection_buffer.h index 1dd8a162e4..08520249bf 100644 --- a/esphome/components/api/api_connection_buffer.h +++ b/esphome/components/api/api_connection_buffer.h @@ -3,8 +3,8 @@ #include "esphome/core/defines.h" #ifdef USE_API -// Inline APIConnection methods that need APIServer complete. Include this -// instead of api_connection.h when calling encode_to_buffer or get_batch_delay_ms_. +// Inline APIConnection members that need APIServer complete. Include this +// instead of api_connection.h when calling them. #include "api_connection.h" #include "api_server.h" @@ -41,7 +41,10 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c return 0; auto &shared_buf = conn->parent_->get_shared_buffer_ref(); - shared_buf.resize(shared_buf.size() + to_add); + if (!shared_buf.resize(shared_buf.size() + to_add)) [[unlikely]] { + conn->fatal_out_of_memory_(); + return 0; + } ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size}; encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf)); @@ -50,5 +53,22 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c inline uint32_t APIConnection::get_batch_delay_ms_() const { return this->parent_->get_batch_delay(); } +inline bool APIConnection::prepare_first_message_buffer(size_t header_padding, size_t total_size) { + auto &shared_buf = this->parent_->get_shared_buffer_ref(); + shared_buf.clear(); + // Reserve space for header padding + message + footer + // - Header padding: space for protocol headers (7 bytes for Noise, 6 for Plaintext) + // - Footer: space for MAC (16 bytes for Noise, 0 for Plaintext) + // Reserve full size but only set initial size to header padding + // so message encoding starts at the correct position + return shared_buf.reserve_and_resize(total_size, header_padding); +} + +inline bool APIConnection::prepare_first_message_buffer(size_t payload_size) { + const uint8_t header_padding = this->helper_->frame_header_padding(); + const uint8_t footer_size = this->helper_->frame_footer_size(); + return this->prepare_first_message_buffer(header_padding, payload_size + header_padding + footer_size); +} + } // namespace esphome::api #endif diff --git a/esphome/components/api/api_frame_helper_noise.cpp b/esphome/components/api/api_frame_helper_noise.cpp index 9c4cc2aa78..138dbdddba 100644 --- a/esphome/components/api/api_frame_helper_noise.cpp +++ b/esphome/components/api/api_frame_helper_noise.cpp @@ -68,7 +68,10 @@ APIError APINoiseFrameHelper::init() { // init prologue size_t old_size = prologue_.size(); - prologue_.resize(old_size + PROLOGUE_INIT_LEN); + if (!prologue_.resize(old_size + PROLOGUE_INIT_LEN)) [[unlikely]] { + state_ = State::FAILED; + return APIError::OUT_OF_MEMORY; + } #ifdef USE_ESP8266 memcpy_P(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN); #else @@ -202,7 +205,10 @@ APIError APINoiseFrameHelper::try_read_frame_() { // During handshake, rx_buf_.size() is used in prologue construction, so // the buffer must be exactly msg_size to avoid prologue mismatch.) uint16_t alloc_size = msg_size + (is_data ? RX_BUF_NULL_TERMINATOR : 0); - this->rx_buf_.resize(alloc_size); + if (!this->rx_buf_.resize(alloc_size)) [[unlikely]] { + state_ = State::FAILED; + return APIError::OUT_OF_MEMORY; + } if (rx_buf_len_ < msg_size) { // more data to read @@ -269,7 +275,10 @@ APIError APINoiseFrameHelper::state_action_client_hello_() { // Resize for: existing prologue + 2 size bytes + frame data size_t old_size = this->prologue_.size(); size_t rx_size = this->rx_buf_.size(); - this->prologue_.resize(old_size + 2 + rx_size); + if (!this->prologue_.resize(old_size + 2 + rx_size)) [[unlikely]] { + state_ = State::FAILED; + return APIError::OUT_OF_MEMORY; + } this->prologue_[old_size] = (uint8_t) (rx_size >> 8); this->prologue_[old_size + 1] = (uint8_t) rx_size; if (rx_size > 0) { @@ -477,13 +486,15 @@ APIError APINoiseFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuf assert(this->state_ == State::DATA); #endif + APIBuffer *buf = buffer.get_buffer(); // Resize buffer to include footer space for Noise MAC - if (this->frame_footer_size_) - buffer.get_buffer()->resize(buffer.get_buffer()->size() + this->frame_footer_size_); + if (this->frame_footer_size_ && !buf->resize(buf->size() + this->frame_footer_size_)) [[unlikely]] { + state_ = State::FAILED; + return APIError::OUT_OF_MEMORY; + } - uint16_t payload_size = - static_cast(buffer.get_buffer()->size() - HEADER_PADDING - this->frame_footer_size_); - uint8_t *buf_start = buffer.get_buffer()->data(); + uint16_t payload_size = static_cast(buf->size() - HEADER_PADDING - this->frame_footer_size_); + uint8_t *buf_start = buf->data(); uint16_t encrypted_len; APIError aerr = this->encrypt_noise_message_(buf_start, payload_size, type, encrypted_len); if (aerr != APIError::OK) diff --git a/esphome/components/api/api_frame_helper_plaintext.cpp b/esphome/components/api/api_frame_helper_plaintext.cpp index 09ace7294a..d4e3354fa0 100644 --- a/esphome/components/api/api_frame_helper_plaintext.cpp +++ b/esphome/components/api/api_frame_helper_plaintext.cpp @@ -172,7 +172,10 @@ APIError APIPlaintextFrameHelper::try_read_frame_() { // Reserve space for body (+ null terminator so protobuf StringRef fields // can be safely null-terminated in-place after decode) - this->rx_buf_.resize(this->rx_header_parsed_len_ + RX_BUF_NULL_TERMINATOR); + if (!this->rx_buf_.resize(this->rx_header_parsed_len_ + RX_BUF_NULL_TERMINATOR)) [[unlikely]] { + state_ = State::FAILED; + return APIError::OUT_OF_MEMORY; + } if (rx_buf_len_ < rx_header_parsed_len_) { // more data to read diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp index f56d791b67..2de1f0a15c 100644 --- a/esphome/components/api/api_pb2.cpp +++ b/esphome/components/api/api_pb2.cpp @@ -1275,12 +1275,24 @@ uint8_t *ListEntitiesServicesArgument::encode(ProtoWriteBuffer &buffer PROTO_ENC uint8_t *__restrict__ pos = buffer.get_pos(); ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->name); ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast(this->type)); +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, this->description); +#endif +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->example); +#endif return pos; } uint32_t ListEntitiesServicesArgument::calculate_size() const { uint32_t size = 0; size += ProtoSize::calc_length(1, this->name.size()); size += this->type ? 2 : 0; +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + size += ProtoSize::calc_length(1, this->description.size()); +#endif +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + size += ProtoSize::calc_length(1, this->example.size()); +#endif return size; } uint8_t *ListEntitiesServicesResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const { @@ -1291,6 +1303,9 @@ uint8_t *ListEntitiesServicesResponse::encode(ProtoWriteBuffer &buffer PROTO_ENC ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 3, it); } ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast(this->supports_response)); +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, this->description); +#endif return pos; } uint32_t ListEntitiesServicesResponse::calculate_size() const { @@ -1303,6 +1318,9 @@ uint32_t ListEntitiesServicesResponse::calculate_size() const { } } size += this->supports_response ? 2 : 0; +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + size += ProtoSize::calc_length(1, this->description.size()); +#endif return size; } bool ExecuteServiceArgument::decode_varint(uint32_t field_id, proto_varint_value_t value) { diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h index bed28d2956..5c3429a63a 100644 --- a/esphome/components/api/api_pb2.h +++ b/esphome/components/api/api_pb2.h @@ -1317,6 +1317,12 @@ class ListEntitiesServicesArgument final : public ProtoMessage { public: StringRef name{}; enums::ServiceArgType type{}; +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + StringRef description{}; +#endif +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + StringRef example{}; +#endif uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const; uint32_t calculate_size() const; #ifdef HAS_PROTO_MESSAGE_DUMP @@ -1328,7 +1334,7 @@ class ListEntitiesServicesArgument final : public ProtoMessage { class ListEntitiesServicesResponse final : public ProtoMessage { public: static constexpr uint16_t MESSAGE_TYPE = 41; - static constexpr uint8_t ESTIMATED_SIZE = 50; + static constexpr uint8_t ESTIMATED_SIZE = 59; #ifdef HAS_PROTO_MESSAGE_DUMP const LogString *message_name() const override { return LOG_STR("list_entities_services_response"); } #endif @@ -1336,6 +1342,9 @@ class ListEntitiesServicesResponse final : public ProtoMessage { uint32_t key{0}; FixedVector args{}; enums::SupportsResponseType supports_response{}; +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + StringRef description{}; +#endif uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const; uint32_t calculate_size() const; #ifdef HAS_PROTO_MESSAGE_DUMP diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp index 846c0ad652..dced81ee30 100644 --- a/esphome/components/api/api_pb2_dump.cpp +++ b/esphome/components/api/api_pb2_dump.cpp @@ -1500,6 +1500,12 @@ const char *ListEntitiesServicesArgument::dump_to(DumpBuffer &out) const { MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesArgument")); dump_field(out, ESPHOME_PSTR("name"), this->name); dump_field(out, ESPHOME_PSTR("type"), static_cast(this->type)); +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + dump_field(out, ESPHOME_PSTR("description"), this->description); +#endif +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + dump_field(out, ESPHOME_PSTR("example"), this->example); +#endif return out.c_str(); } const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const { @@ -1512,6 +1518,9 @@ const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const { out.append("\n"); } dump_field(out, ESPHOME_PSTR("supports_response"), static_cast(this->supports_response)); +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + dump_field(out, ESPHOME_PSTR("description"), this->description); +#endif return out.c_str(); } const char *ExecuteServiceArgument::dump_to(DumpBuffer &out) const { diff --git a/esphome/components/api/api_server.cpp b/esphome/components/api/api_server.cpp index 751f2e4c3b..43d35363d3 100644 --- a/esphome/components/api/api_server.cpp +++ b/esphome/components/api/api_server.cpp @@ -433,8 +433,10 @@ void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call // Home Assistant subscribes to actions shortly *after* authenticating, so actions // fired right at connection time (on_client_connected, on_time_sync, ...) can // arrive before the subscription and are lost - warn instead of failing silently. - ESP_LOGW(TAG, "Home Assistant %s '%s' dropped; %s", call.is_event ? "event" : "action", call.service.c_str(), - this->is_connected() ? "client has not subscribed to actions (yet)" : "no client connected"); + ESP_LOGW(TAG, "Home Assistant %s '%s' dropped; %s", + call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"), call.service.c_str(), + this->is_connected() ? LOG_STR_LITERAL("client has not subscribed to actions (yet)") + : LOG_STR_LITERAL("no client connected")); } } #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES diff --git a/esphome/components/api/list_entities.cpp b/esphome/components/api/list_entities.cpp index 57ff616ca7..507b098fb4 100644 --- a/esphome/components/api/list_entities.cpp +++ b/esphome/components/api/list_entities.cpp @@ -99,7 +99,8 @@ ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(clie static constexpr uint8_t SERVICE_YIELD_INTERVAL = 3; bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) { - auto resp = service->encode_list_service_response(); + UserActionScratch scratch; + auto resp = service->encode_list_service_response(scratch); if (!this->client_->send_message(resp)) return false; // at_ is this service's index diff --git a/esphome/components/api/user_services.cpp b/esphome/components/api/user_services.cpp index 28a43c656c..fad3cde29b 100644 --- a/esphome/components/api/user_services.cpp +++ b/esphome/components/api/user_services.cpp @@ -1,9 +1,52 @@ #include "user_services.h" +#include "esphome/core/hal.h" #include "esphome/core/log.h" #include "esphome/core/string_ref.h" namespace esphome::api { +StringRef UserServiceStatic::str_(size_t idx, std::span &scratch) const { + const char *s = progmem_read_ptr(&this->strings_[idx]); + if (s == nullptr) + return {}; +#ifdef USE_ESP8266 + // Codegen sizes the scratch buffer for the largest service; the bound only guards other callers + if (scratch.empty()) + return {}; + size_t len = strnlen_P(s, scratch.size() - 1); + progmem_memcpy(scratch.data(), s, len); + scratch[len] = '\0'; + StringRef ref(scratch.data(), len); + scratch = scratch.subspan(len + 1); + return ref; +#else + return StringRef(s); +#endif +} + +ListEntitiesServicesResponse UserServiceStatic::encode_list_service_response_( + std::span arg_types, std::span scratch) const { + ListEntitiesServicesResponse msg; + msg.name = this->str_(0, scratch); + msg.key = this->key_; + msg.supports_response = this->supports_response_; +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + msg.description = this->str_(1, scratch); +#endif + msg.args.init(arg_types.size()); + for (size_t i = 0; i < arg_types.size(); i++) { + size_t base = USER_ACTION_HEADER_STRINGS + i * USER_ACTION_ARG_STRINGS; + auto &arg = msg.args.emplace_back(); + arg.type = arg_types[i]; + arg.name = this->str_(base, scratch); +#ifdef USE_API_USER_DEFINED_ACTION_METADATA + arg.description = this->str_(base + 1, scratch); + arg.example = this->str_(base + 2, scratch); +#endif + } + return msg; +} + template<> bool get_execute_arg_value(const ExecuteServiceArgument &arg) { return arg.bool_; } template<> int32_t get_execute_arg_value(const ExecuteServiceArgument &arg) { if (arg.legacy_int != 0) diff --git a/esphome/components/api/user_services.h b/esphome/components/api/user_services.h index ea57d0944b..3b17bdb7bc 100644 --- a/esphome/components/api/user_services.h +++ b/esphome/components/api/user_services.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -19,7 +20,9 @@ class APIServer; class UserServiceDescriptor { public: - virtual ListEntitiesServicesResponse encode_list_service_response() = 0; + /// Build the list-entities message. On ESP8266 the strings live in PROGMEM and are copied into + /// `scratch`, so the returned message is only valid while `scratch` is; other platforms ignore it. + virtual ListEntitiesServicesResponse encode_list_service_response(std::span scratch) = 0; virtual bool execute_service(const ExecuteServiceRequest &req) = 0; #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES @@ -34,29 +37,51 @@ template T get_execute_arg_value(const ExecuteServiceArgument &arg); template enums::ServiceArgType to_service_arg_type(); -// Base class for YAML-defined services (most common case) -// Stores only pointers to string literals in flash - no heap allocation -template class UserServiceBase : public UserServiceDescriptor { - public: - UserServiceBase(const char *name, const std::array &arg_names, - enums::SupportsResponseType supports_response = enums::SUPPORTS_RESPONSE_NONE) - : name_(name), arg_names_(arg_names), supports_response_(supports_response) { - this->key_ = fnv1_hash(name); - } +// Scratch buffer list-entities hands to encode_list_service_response(); only ESP8266 copies into it +#ifdef USE_ESP8266 +using UserActionScratch = std::array; +#else +using UserActionScratch = std::array; +#endif - ListEntitiesServicesResponse encode_list_service_response() override { - ListEntitiesServicesResponse msg; - msg.name = StringRef(this->name_); - msg.key = this->key_; - msg.supports_response = this->supports_response_; +// Non-template base for YAML-defined services so the list-entities encoder is compiled once. +// All strings live in one PROGMEM pointer table emitted by codegen (see _action_strings in +// __init__.py), so each service costs a single pointer of RAM. Layout: the action name, then +// each argument name; with USE_API_USER_DEFINED_ACTION_METADATA the action description follows +// the name and every argument is (name, description, example). Unset metadata is nullptr. +#ifdef USE_API_USER_DEFINED_ACTION_METADATA +static constexpr size_t USER_ACTION_HEADER_STRINGS = 2; +static constexpr size_t USER_ACTION_ARG_STRINGS = 3; +#else +static constexpr size_t USER_ACTION_HEADER_STRINGS = 1; +static constexpr size_t USER_ACTION_ARG_STRINGS = 1; +#endif +class UserServiceStatic : public UserServiceDescriptor { + public: + UserServiceStatic(const char *const *strings, uint32_t key, + enums::SupportsResponseType supports_response = enums::SUPPORTS_RESPONSE_NONE) + : strings_(strings), key_(key), supports_response_(supports_response) {} + + protected: + ListEntitiesServicesResponse encode_list_service_response_(std::span arg_types, + std::span scratch) const; + /// Reference table entry `idx`; nullptr gives an empty StringRef. + /// On ESP8266 the bytes are copied out of PROGMEM into `scratch` with a terminator, and the span + /// is advanced past the copy. + StringRef str_(size_t idx, std::span &scratch) const; + + const char *const *strings_; // PROGMEM pointer table, read with progmem_read_ptr() + uint32_t key_; + enums::SupportsResponseType supports_response_; +}; + +template class UserServiceBase : public UserServiceStatic { + public: + using UserServiceStatic::UserServiceStatic; + + ListEntitiesServicesResponse encode_list_service_response(std::span scratch) override { std::array arg_types = {to_service_arg_type()...}; - msg.args.init(sizeof...(Ts)); - for (size_t i = 0; i < sizeof...(Ts); i++) { - auto &arg = msg.args.emplace_back(); - arg.type = arg_types[i]; - arg.name = StringRef(this->arg_names_[i]); - } - return msg; + return this->encode_list_service_response_(arg_types, scratch); } bool execute_service(const ExecuteServiceRequest &req) override { @@ -89,12 +114,6 @@ template class UserServiceBase : public UserServiceDescriptor { void execute_(const ArgsContainer &args, uint32_t call_id, bool return_response, std::index_sequence /*type*/) { this->execute(call_id, return_response, (get_execute_arg_value(args[S]))...); } - - // Pointers to string literals in flash - no heap allocation - const char *name_; - std::array arg_names_; - uint32_t key_{0}; - enums::SupportsResponseType supports_response_{enums::SUPPORTS_RESPONSE_NONE}; }; // Separate class for custom_api_device services (rare case) @@ -106,7 +125,7 @@ template class UserServiceDynamic : public UserServiceDescriptor this->key_ = fnv1_hash(this->name_.c_str()); } - ListEntitiesServicesResponse encode_list_service_response() override { + ListEntitiesServicesResponse encode_list_service_response(std::span /*scratch*/) override { ListEntitiesServicesResponse msg; msg.name = StringRef(this->name_); msg.key = this->key_; @@ -167,8 +186,8 @@ template class UserServiceTrigger final : public UserServiceBase, public Trigger { public: - UserServiceTrigger(const char *name, const std::array &arg_names) - : UserServiceBase(name, arg_names, enums::SUPPORTS_RESPONSE_NONE) {} + UserServiceTrigger(const char *const *strings, uint32_t key) + : UserServiceBase(strings, key, enums::SUPPORTS_RESPONSE_NONE) {} protected: void execute(uint32_t /*call_id*/, bool /*return_response*/, Ts... x) override { this->trigger(x...); } @@ -179,8 +198,8 @@ template class UserServiceTrigger final : public UserServiceBase, public Trigger { public: - UserServiceTrigger(const char *name, const std::array &arg_names) - : UserServiceBase(name, arg_names, enums::SUPPORTS_RESPONSE_OPTIONAL) {} + UserServiceTrigger(const char *const *strings, uint32_t key) + : UserServiceBase(strings, key, enums::SUPPORTS_RESPONSE_OPTIONAL) {} protected: void execute(uint32_t call_id, bool return_response, Ts... x) override { @@ -193,8 +212,8 @@ template class UserServiceTrigger final : public UserServiceBase, public Trigger { public: - UserServiceTrigger(const char *name, const std::array &arg_names) - : UserServiceBase(name, arg_names, enums::SUPPORTS_RESPONSE_ONLY) {} + UserServiceTrigger(const char *const *strings, uint32_t key) + : UserServiceBase(strings, key, enums::SUPPORTS_RESPONSE_ONLY) {} protected: void execute(uint32_t call_id, bool /*return_response*/, Ts... x) override { this->trigger(call_id, x...); } @@ -205,8 +224,8 @@ template class UserServiceTrigger final : public UserServiceBase, public Trigger { public: - UserServiceTrigger(const char *name, const std::array &arg_names) - : UserServiceBase(name, arg_names, enums::SUPPORTS_RESPONSE_STATUS) {} + UserServiceTrigger(const char *const *strings, uint32_t key) + : UserServiceBase(strings, key, enums::SUPPORTS_RESPONSE_STATUS) {} protected: void execute(uint32_t call_id, bool /*return_response*/, Ts... x) override { this->trigger(call_id, x...); } diff --git a/esphome/components/aqi/aqi_sensor.cpp b/esphome/components/aqi/aqi_sensor.cpp index 4bb964d5ee..e78f301b30 100644 --- a/esphome/components/aqi/aqi_sensor.cpp +++ b/esphome/components/aqi/aqi_sensor.cpp @@ -23,8 +23,10 @@ void AQISensor::setup() { void AQISensor::dump_config() { ESP_LOGCONFIG(TAG, "AQI Sensor:"); - ESP_LOGCONFIG(TAG, " Calculation Type: %s", this->aqi_calc_type_ == AQI_TYPE ? "AQI" : "CAQI"); - ESP_LOGCONFIG(TAG, " Extended Range: %s", this->extended_range_ ? "enabled" : "disabled"); + ESP_LOGCONFIG(TAG, " Calculation Type: %s", + this->aqi_calc_type_ == AQI_TYPE ? LOG_STR_LITERAL("AQI") : LOG_STR_LITERAL("CAQI")); + ESP_LOGCONFIG(TAG, " Extended Range: %s", + this->extended_range_ ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled")); if (this->pm_2_5_sensor_ != nullptr) { ESP_LOGCONFIG(TAG, " PM2.5 Sensor: '%s'", this->pm_2_5_sensor_->get_name().c_str()); } diff --git a/esphome/components/binary_sensor/automation.cpp b/esphome/components/binary_sensor/automation.cpp index 1a3c1f7536..65c7dbbdb6 100644 --- a/esphome/components/binary_sensor/automation.cpp +++ b/esphome/components/binary_sensor/automation.cpp @@ -100,13 +100,15 @@ void MultiClickTriggerBase::schedule_is_valid_(uint32_t min_length) { } this->is_valid_ = false; this->set_timeout(MULTICLICK_IS_VALID_ID, min_length, [this]() { - ESP_LOGV(TAG, "Multi Click: You can now %s the button.", this->parent_->state ? "RELEASE" : "PRESS"); + ESP_LOGV(TAG, "Multi Click: You can now %s the button.", + this->parent_->state ? LOG_STR_LITERAL("RELEASE") : LOG_STR_LITERAL("PRESS")); this->is_valid_ = true; }); } void MultiClickTriggerBase::schedule_is_not_valid_(uint32_t max_length) { this->set_timeout(MULTICLICK_IS_NOT_VALID_ID, max_length, [this]() { - ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS"); + ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", + this->parent_->state ? LOG_STR_LITERAL("RELEASE") : LOG_STR_LITERAL("PRESS")); this->is_valid_ = false; this->schedule_cooldown_(); }); diff --git a/esphome/components/bk72xx_ble/bdk_scan.cpp b/esphome/components/bk72xx_ble/bdk_scan.cpp index f17f21c06b..3192fc79d7 100644 --- a/esphome/components/bk72xx_ble/bdk_scan.cpp +++ b/esphome/components/bk72xx_ble/bdk_scan.cpp @@ -62,8 +62,9 @@ BdkActivityState bdk_scan_state(uint8_t activity_idx) { uint8_t bdk_scan_acquire_activity() { uint8_t idx = app_ble_get_idle_actv_idx_handle(SCAN_ACTV); - if (idx == INVALID_ACTIVITY_IDX) + if (idx == INVALID_ACTIVITY_IDX) { ESP_LOGE(TAG, "Scan start failed: no idle activity handle"); + } return idx; } diff --git a/esphome/components/bk72xx_ble/bk72xx_ble.cpp b/esphome/components/bk72xx_ble/bk72xx_ble.cpp index 52401114e6..7a4efff455 100644 --- a/esphome/components/bk72xx_ble/bk72xx_ble.cpp +++ b/esphome/components/bk72xx_ble/bk72xx_ble.cpp @@ -181,8 +181,9 @@ void BK72xxBLE::enable() { break; } } - if (!bdaddr_live) + if (!bdaddr_live) { ESP_LOGW(TAG, "Controller address still unset after init; BLE stack may not have started"); + } #endif this->state_ = BLEComponentState::ACTIVE; @@ -210,8 +211,9 @@ void BK72xxBLE::loop() { // Re-check a settled scan; scan_start() refills the bring-up budget. // WARN: the only report of a drop that recovers inside its budget. if (this->scan_start(this->requested_.interval, this->requested_.window, this->requested_.active) != - ScanOpResult::SETTLED) + ScanOpResult::SETTLED) { ESP_LOGW(TAG, "Controller dropped the scan; restarting"); + } } // Drain the lock-free ring filled by the BLE task; all per-report work runs @@ -230,8 +232,9 @@ void BK72xxBLE::loop() { // Log dropped reports — only reachable when reports were processed; drops can // only occur while the queue is full, and only this loop drains it. uint16_t dropped = this->report_queue_.get_and_reset_dropped_count(); - if (dropped > 0) + if (dropped > 0) { ESP_LOGW(TAG, "Dropped %u scan reports due to queue overflow", dropped); + } } void BK72xxBLE::get_mac_lsb_first(uint8_t out[MAC_ADDRESS_SIZE]) const { @@ -449,8 +452,9 @@ ScanOpResult BK72xxBLE::advance_stop_(BdkActivityState state, bool ready) { if (!ready) { // Acting mid-operation could delete an activity whose start lands // afterwards, leaking the slot with the radio on; wait. - if (this->last_result_ == ScanOpResult::SETTLED) + if (this->last_result_ == ScanOpResult::SETTLED) { ESP_LOGD(TAG, "Scan stop deferred (controller busy)"); + } return ScanOpResult::PENDING; } // Settled, so CREATED unambiguously means "never started". @@ -474,8 +478,9 @@ ScanOpResult BK72xxBLE::advance_start_(BdkActivityState state, bool ready) { return ScanOpResult::PENDING; } if (!ready) { - if (this->last_result_ == ScanOpResult::SETTLED) + if (this->last_result_ == ScanOpResult::SETTLED) { ESP_LOGD(TAG, "Scan start deferred (controller busy)"); + } return ScanOpResult::PENDING; } if (state == BdkActivityState::CREATED) { diff --git a/esphome/components/bk72xx_ble_tracker/bk72xx_ble_tracker.cpp b/esphome/components/bk72xx_ble_tracker/bk72xx_ble_tracker.cpp index 1b4e6245ae..0939e1259f 100644 --- a/esphome/components/bk72xx_ble_tracker/bk72xx_ble_tracker.cpp +++ b/esphome/components/bk72xx_ble_tracker/bk72xx_ble_tracker.cpp @@ -69,8 +69,9 @@ void BK72xxBLETracker::on_ota_global_state(ota::OTAState state, float progress, this->stop_scan(); // The transfer starves the loop; a deferred stop would leave the radio // scanning for the whole update, so drain it here, bounded. - if (!this->parent_->flush_pending_stop(OTA_STOP_FLUSH_MS)) + if (!this->parent_->flush_pending_stop(OTA_STOP_FLUSH_MS)) { ESP_LOGE(TAG, "Scan still stopping at OTA start; the radio may contend with the update"); + } } else if (state == ota::OTA_ERROR || state == ota::OTA_ABORT) { // On success the device reboots, so restore only on a failed/aborted update; // loop() restarts the scan on its next iteration (continuous idle branch). diff --git a/esphome/components/ble_client/output/ble_binary_output.cpp b/esphome/components/ble_client/output/ble_binary_output.cpp index 1cb83b9d8b..5d53c59708 100644 --- a/esphome/components/ble_client/output/ble_binary_output.cpp +++ b/esphome/components/ble_client/output/ble_binary_output.cpp @@ -80,8 +80,9 @@ void BLEBinaryOutput::write_state(bool state) { esp_err_t err = esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, sizeof(state_as_uint), &state_as_uint, this->write_type_, ESP_GATT_AUTH_REQ_NONE); - if (err != ESP_GATT_OK) + if (err != ESP_GATT_OK) { ESP_LOGW(TAG, "[%s] Write error, err=%d", this->char_uuid_.to_str(char_buf), err); + } } } // namespace esphome::ble_client diff --git a/esphome/components/bme680/bme680.cpp b/esphome/components/bme680/bme680.cpp index ef98174e06..164424de09 100644 --- a/esphome/components/bme680/bme680.cpp +++ b/esphome/components/bme680/bme680.cpp @@ -327,10 +327,12 @@ void BME680Component::read_data_() { ESP_LOGD(TAG, "Got temperature=%.1f°C pressure=%.1fhPa humidity=%.1f%% gas_resistance=%.1fΩ", temperature, pressure, humidity, gas_resistance); - if (!gas_valid) + if (!gas_valid) { ESP_LOGW(TAG, "Gas measurement unsuccessful, reading invalid!"); - if (!heat_stable) + } + if (!heat_stable) { ESP_LOGW(TAG, "Heater unstable, reading invalid! (Normal for a few readings after a power cycle)"); + } if (this->temperature_sensor_ != nullptr) this->temperature_sensor_->publish_state(temperature); diff --git a/esphome/components/bme680_bsec/bme680_bsec.cpp b/esphome/components/bme680_bsec/bme680_bsec.cpp index 823f32c446..8e16a28e33 100644 --- a/esphome/components/bme680_bsec/bme680_bsec.cpp +++ b/esphome/components/bme680_bsec/bme680_bsec.cpp @@ -162,8 +162,9 @@ void BME680BSECComponent::dump_config() { " Supply Voltage: %sV\n" " Sample Rate: %s\n" " State Save Interval: %" PRIu32 "ms", - this->temperature_offset_, this->iaq_mode_ == IAQ_MODE_STATIC ? "Static" : "Mobile", - this->supply_voltage_ == SUPPLY_VOLTAGE_3V3 ? "3.3" : "1.8", + this->temperature_offset_, + this->iaq_mode_ == IAQ_MODE_STATIC ? LOG_STR_LITERAL("Static") : LOG_STR_LITERAL("Mobile"), + this->supply_voltage_ == SUPPLY_VOLTAGE_3V3 ? LOG_STR_LITERAL("3.3") : LOG_STR_LITERAL("1.8"), BME680_BSEC_SAMPLE_RATE_LOG(this->sample_rate_), this->state_save_interval_ms_); LOG_SENSOR(" ", "Temperature", this->temperature_sensor_); diff --git a/esphome/components/captive_portal/captive_index.h b/esphome/components/captive_portal/captive_index.h index a25ac8d010..84d79a6c66 100644 --- a/esphome/components/captive_portal/captive_index.h +++ b/esphome/components/captive_portal/captive_index.h @@ -7,146 +7,146 @@ namespace esphome::captive_portal { #ifdef USE_CAPTIVE_PORTAL_GZIP constexpr uint8_t INDEX_GZ[] PROGMEM = { - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x95, 0x16, 0x6b, 0x8f, 0xdb, 0x36, 0xf2, 0x7b, 0x7f, - 0x05, 0x8f, 0x4d, 0x1b, 0xa9, 0xb1, 0xa8, 0x87, 0xd7, 0xde, 0x44, 0x96, 0x54, 0xa4, 0x7b, 0x2d, 0x5a, 0xa0, 0x69, - 0x03, 0xec, 0x36, 0xf7, 0x21, 0x08, 0xb0, 0x34, 0x39, 0xb2, 0x98, 0xa5, 0x48, 0x1d, 0x49, 0xbf, 0x62, 0xf8, 0x7e, - 0xfb, 0x81, 0x92, 0xec, 0xf5, 0x2e, 0x9a, 0x03, 0x0e, 0x86, 0x85, 0x19, 0xce, 0x7b, 0x38, 0x0f, 0x16, 0xff, 0xe0, - 0x9a, 0xb9, 0x7d, 0x07, 0xa8, 0x71, 0xad, 0xac, 0x0a, 0xff, 0x45, 0x92, 0xaa, 0x55, 0x09, 0xaa, 0x2a, 0x1a, 0xa0, - 0xbc, 0x2a, 0x5a, 0x70, 0x14, 0xb1, 0x86, 0x1a, 0x0b, 0xae, 0xfc, 0xeb, 0xee, 0x97, 0xe8, 0x75, 0x55, 0x48, 0xa1, - 0x1e, 0x90, 0x01, 0x59, 0x0a, 0xa6, 0x15, 0x6a, 0x0c, 0xd4, 0x25, 0xa7, 0x8e, 0xe6, 0xa2, 0xa5, 0x2b, 0x18, 0x45, - 0x14, 0x6d, 0xa1, 0xdc, 0x08, 0xd8, 0x76, 0xda, 0x38, 0xc4, 0xb4, 0x72, 0xa0, 0x5c, 0x89, 0xb7, 0x82, 0xbb, 0xa6, - 0xe4, 0xb0, 0x11, 0x0c, 0xa2, 0x1e, 0x99, 0x08, 0x25, 0x9c, 0xa0, 0x32, 0xb2, 0x8c, 0x4a, 0x28, 0xd3, 0xc9, 0xda, - 0x82, 0xe9, 0x11, 0xba, 0x94, 0x50, 0x2a, 0x8d, 0xab, 0xc2, 0x32, 0x23, 0x3a, 0x87, 0xbc, 0xab, 0x65, 0xab, 0xf9, - 0x5a, 0x42, 0x15, 0xc7, 0xd4, 0x5a, 0x70, 0x36, 0x16, 0x8a, 0xc3, 0x8e, 0xd0, 0x6b, 0xb8, 0xa6, 0x2c, 0x4d, 0xc8, - 0x67, 0xfb, 0x0d, 0xd7, 0x6c, 0xdd, 0x82, 0x72, 0x44, 0x6a, 0x46, 0x9d, 0xd0, 0x8a, 0x58, 0xa0, 0x86, 0x35, 0x65, - 0x59, 0xe2, 0x1f, 0x2d, 0xdd, 0x00, 0xfe, 0xfe, 0xfb, 0xe0, 0xcc, 0xb4, 0x02, 0xf7, 0xb3, 0x04, 0x0f, 0xda, 0x9f, - 0xf6, 0x77, 0x74, 0xf5, 0x07, 0x6d, 0x21, 0xc0, 0xd4, 0x0a, 0x0e, 0x38, 0xfc, 0x98, 0x7c, 0x22, 0xd6, 0xed, 0x25, - 0x10, 0x2e, 0x6c, 0x27, 0xe9, 0xbe, 0xc4, 0x4b, 0xa9, 0xd9, 0x03, 0x0e, 0x17, 0xf5, 0x5a, 0x31, 0xaf, 0x1c, 0xe9, - 0x00, 0xc2, 0x83, 0x04, 0x87, 0x5c, 0xf9, 0x8e, 0xba, 0x86, 0xb4, 0x74, 0x17, 0x0c, 0x80, 0x50, 0x41, 0xf6, 0x43, - 0x00, 0xaf, 0xd2, 0x24, 0x09, 0x27, 0xfd, 0x27, 0x09, 0xe3, 0x34, 0x49, 0x16, 0x06, 0xdc, 0xda, 0x28, 0x44, 0x83, - 0xfb, 0xa2, 0xa3, 0xae, 0x41, 0xbc, 0xc4, 0xef, 0xd2, 0x0c, 0xa5, 0x6f, 0x48, 0x36, 0xfb, 0x9d, 0x5c, 0xa3, 0x2b, - 0x92, 0xcd, 0xd8, 0x75, 0x34, 0x43, 0xe9, 0x55, 0x34, 0x43, 0x59, 0x46, 0x66, 0x28, 0xf9, 0x82, 0x51, 0x2d, 0xa4, - 0x2c, 0xb1, 0xd2, 0x0a, 0x30, 0xb2, 0xce, 0xe8, 0x07, 0x28, 0x31, 0x5b, 0x1b, 0x03, 0xca, 0xdd, 0x68, 0xa9, 0x0d, - 0x8e, 0xab, 0x6f, 0xfe, 0x2f, 0x85, 0xce, 0x50, 0x65, 0x6b, 0x6d, 0xda, 0x12, 0xf7, 0xd9, 0x0f, 0x5e, 0x1c, 0xdc, - 0x11, 0xf9, 0x4f, 0x78, 0x41, 0x8c, 0xb4, 0x11, 0x2b, 0xa1, 0x4a, 0xec, 0x35, 0xbe, 0xc6, 0x71, 0x75, 0x1f, 0x1e, - 0xcf, 0xd1, 0x53, 0x1f, 0xfd, 0x18, 0x0f, 0x0f, 0x3e, 0xde, 0x17, 0x76, 0xb3, 0x42, 0xbb, 0x56, 0x2a, 0x5b, 0xe2, - 0xc6, 0xb9, 0x2e, 0x8f, 0xe3, 0xed, 0x76, 0x4b, 0xb6, 0x53, 0xa2, 0xcd, 0x2a, 0xce, 0x92, 0x24, 0x89, 0xed, 0x66, - 0x85, 0xd1, 0x50, 0x08, 0x38, 0xbb, 0xc2, 0xa8, 0x01, 0xb1, 0x6a, 0x5c, 0x0f, 0x57, 0x2f, 0x0e, 0x70, 0x2c, 0x3c, - 0x47, 0x75, 0xff, 0xe9, 0xc2, 0x8a, 0xb9, 0xb0, 0x02, 0x3f, 0xd2, 0x00, 0x9f, 0xc2, 0x7c, 0xd9, 0x87, 0x79, 0x4d, - 0x33, 0x94, 0xa1, 0xa4, 0xff, 0x65, 0x91, 0x87, 0x47, 0x2c, 0x7a, 0x86, 0xa1, 0x0b, 0xcc, 0x43, 0xed, 0x3c, 0x7a, - 0x73, 0x96, 0x4d, 0xfd, 0xc9, 0x26, 0x4d, 0x1e, 0x0f, 0xbc, 0xc0, 0xaf, 0xf3, 0x4b, 0x3c, 0xca, 0x3e, 0x5c, 0x32, - 0x78, 0x6b, 0x4d, 0xfa, 0x61, 0x4e, 0x67, 0x68, 0x36, 0x9e, 0xcc, 0x22, 0x0f, 0x9f, 0x31, 0x34, 0xdb, 0x64, 0x4d, - 0xda, 0x46, 0xf3, 0x68, 0x46, 0xa7, 0x68, 0x3a, 0x3a, 0x32, 0x45, 0xd3, 0x4d, 0xd6, 0xcc, 0x3f, 0xcc, 0x2f, 0xcf, - 0xa2, 0xe9, 0x97, 0x97, 0x71, 0x85, 0xc3, 0x1c, 0xe3, 0xc7, 0xc8, 0xf9, 0x65, 0xe4, 0xe4, 0xb3, 0x16, 0x2a, 0xc0, - 0x38, 0x3c, 0xd6, 0xe0, 0x58, 0x13, 0xe0, 0x98, 0x69, 0x55, 0x8b, 0x15, 0xf9, 0x6c, 0xb5, 0xc2, 0x21, 0x71, 0x0d, - 0xa8, 0xe0, 0x24, 0xea, 0x05, 0xa1, 0xa7, 0x04, 0xcf, 0x29, 0x2e, 0x3c, 0x9c, 0xeb, 0xdf, 0x09, 0x27, 0xa1, 0x74, - 0xc4, 0x37, 0xec, 0xe4, 0x6f, 0xba, 0xe2, 0xa7, 0xfd, 0x6f, 0x3c, 0xc0, 0x2d, 0x65, 0x38, 0x24, 0x42, 0x29, 0x30, - 0x77, 0xb0, 0x73, 0x25, 0x7e, 0xf7, 0xf6, 0x06, 0xbd, 0xe5, 0xdc, 0x80, 0xb5, 0x39, 0xc2, 0xaf, 0x1c, 0x69, 0x29, - 0xfb, 0xba, 0x78, 0x93, 0x3e, 0x95, 0xfe, 0x97, 0xf8, 0x45, 0xa0, 0x3f, 0xc0, 0x6d, 0xb5, 0x79, 0x18, 0xe5, 0xbd, - 0xfd, 0x85, 0x6f, 0x23, 0x56, 0x7e, 0x55, 0x8d, 0x02, 0x87, 0xc3, 0x89, 0xf8, 0x3a, 0x83, 0xb5, 0x82, 0xe3, 0x70, - 0x22, 0xbf, 0xce, 0xd1, 0x59, 0xdf, 0xbc, 0x8e, 0xd0, 0xce, 0x12, 0x2b, 0x05, 0x83, 0x20, 0x0d, 0x49, 0xad, 0xcd, - 0xcf, 0x94, 0x35, 0x8f, 0x09, 0xb2, 0x43, 0x47, 0xab, 0x47, 0x3d, 0xcc, 0x00, 0x75, 0x30, 0xaa, 0x0a, 0x30, 0x17, - 0x1b, 0x1c, 0x2e, 0x14, 0x61, 0x92, 0x5a, 0xeb, 0x47, 0x46, 0xe9, 0x9d, 0xf3, 0xe1, 0xe0, 0x89, 0x1a, 0x22, 0xfd, - 0xf5, 0xee, 0xdd, 0xef, 0xe5, 0x7d, 0x41, 0x87, 0x01, 0x89, 0xbf, 0xc5, 0xa8, 0x67, 0x3e, 0x33, 0x46, 0x12, 0x6a, - 0xe7, 0x2b, 0x5e, 0x07, 0x96, 0x18, 0x6b, 0x45, 0x78, 0x2c, 0x6c, 0x47, 0xd5, 0x73, 0xb6, 0x3e, 0xa6, 0xaa, 0x88, - 0x3d, 0xad, 0x2a, 0x62, 0x5a, 0xbd, 0x38, 0x98, 0xc0, 0xfa, 0xe1, 0xf6, 0x10, 0x1e, 0xef, 0x27, 0x8a, 0xfc, 0x7b, - 0x0d, 0x66, 0x7f, 0x0b, 0x12, 0x98, 0xd3, 0x26, 0xc0, 0xe4, 0x89, 0x60, 0x48, 0x1c, 0xec, 0xdc, 0xcd, 0x38, 0x7f, - 0x2d, 0xf1, 0x87, 0x13, 0x45, 0xb4, 0x62, 0x52, 0xb0, 0x87, 0xf2, 0x1c, 0x71, 0x78, 0x10, 0x64, 0x43, 0xe5, 0x1a, - 0x4e, 0x3c, 0x92, 0xd4, 0x9a, 0xad, 0x6d, 0x10, 0x1e, 0x27, 0x8c, 0xd0, 0xae, 0x03, 0xc5, 0x6f, 0x1a, 0x21, 0x79, - 0xa0, 0xc2, 0x63, 0xf8, 0x78, 0xd3, 0xcf, 0x8c, 0xfb, 0xd5, 0xf0, 0xd1, 0x80, 0xfc, 0x4f, 0xf9, 0xd2, 0x2f, 0x87, - 0x97, 0x9f, 0x70, 0x48, 0xfa, 0xf8, 0xef, 0x1f, 0x37, 0x84, 0x6f, 0xef, 0x57, 0xbb, 0x56, 0x4e, 0x7c, 0xe8, 0xd1, - 0x7c, 0x16, 0x1e, 0xef, 0x8f, 0xe1, 0x31, 0x5c, 0x14, 0xf1, 0x30, 0xe7, 0xab, 0xa2, 0x1f, 0xb9, 0xd5, 0x0f, 0x87, - 0xa5, 0xde, 0x45, 0x56, 0x7c, 0x11, 0x6a, 0x95, 0x0b, 0xd5, 0x80, 0x11, 0xee, 0xc8, 0xc5, 0x66, 0x22, 0x54, 0xb7, - 0x76, 0x87, 0x8e, 0x72, 0xee, 0x29, 0xb3, 0x6e, 0xb7, 0xa8, 0xb5, 0x72, 0x9e, 0x13, 0xf2, 0x14, 0xda, 0xe3, 0x40, - 0xef, 0x27, 0x4c, 0xfe, 0x66, 0xf6, 0xdd, 0x71, 0xa9, 0xf9, 0xfe, 0xe0, 0xd3, 0x10, 0x51, 0x29, 0x56, 0x2a, 0x67, - 0xa0, 0x1c, 0x98, 0x41, 0xa8, 0xa6, 0xad, 0x90, 0xfb, 0xdc, 0x52, 0x65, 0x23, 0x0b, 0x46, 0xd4, 0xc7, 0xe5, 0xda, - 0x39, 0xad, 0x0e, 0x4b, 0x6d, 0x38, 0x98, 0x3c, 0x59, 0x0c, 0x40, 0x64, 0x28, 0x17, 0x6b, 0x9b, 0x93, 0xa9, 0x81, - 0x76, 0xb1, 0xa4, 0xec, 0x61, 0x65, 0xf4, 0x5a, 0xf1, 0x88, 0xf9, 0xc9, 0x9b, 0x7f, 0x9b, 0xd6, 0x74, 0x0a, 0x6c, - 0x31, 0x62, 0x75, 0x5d, 0x2f, 0xa4, 0x50, 0x10, 0x0d, 0xb3, 0x2d, 0xcf, 0xc8, 0x95, 0x17, 0xbb, 0x70, 0x93, 0x64, - 0xfe, 0x60, 0xf0, 0x31, 0x4d, 0x92, 0xef, 0x16, 0xa7, 0x70, 0x92, 0x05, 0x5b, 0x1b, 0xab, 0x4d, 0xde, 0x69, 0xe1, - 0xdd, 0x3c, 0xb6, 0x54, 0xa8, 0x4b, 0xef, 0x7d, 0xd9, 0x2c, 0xc6, 0x75, 0x94, 0x0b, 0xd5, 0x9b, 0xe9, 0x97, 0xd2, - 0xa2, 0x15, 0x6a, 0xd8, 0xa9, 0x79, 0x36, 0x4f, 0xba, 0xdd, 0xf1, 0x54, 0x09, 0x87, 0x13, 0x77, 0x2d, 0x61, 0xb7, - 0xf8, 0xbc, 0xb6, 0x4e, 0xd4, 0xfb, 0x68, 0xdc, 0xc9, 0xb9, 0xed, 0x28, 0x83, 0x68, 0x09, 0x6e, 0x0b, 0xa0, 0x16, - 0xbd, 0x8d, 0x48, 0x38, 0x68, 0xed, 0x98, 0xa7, 0xb3, 0x9a, 0xbe, 0x60, 0x9f, 0xea, 0xfa, 0x5f, 0xdc, 0xbe, 0x8a, - 0x0e, 0x2d, 0x35, 0x2b, 0xa1, 0xa2, 0xa5, 0x76, 0x4e, 0xb7, 0x79, 0x74, 0xdd, 0xed, 0x16, 0xe3, 0x91, 0x57, 0x96, - 0xa7, 0xde, 0xcd, 0x7e, 0xd7, 0x9e, 0xf2, 0x9d, 0x76, 0x3b, 0x64, 0xb5, 0x14, 0x7c, 0xe4, 0xeb, 0x59, 0x50, 0x72, - 0x4e, 0x4f, 0x3a, 0xeb, 0x76, 0xc8, 0x9f, 0x9d, 0x52, 0x7d, 0x55, 0xbf, 0xa6, 0x69, 0xf2, 0x37, 0x37, 0xc2, 0xeb, - 0x3a, 0x5b, 0xd6, 0xe7, 0x4c, 0xf9, 0xb5, 0xe9, 0x57, 0x4b, 0x5f, 0x5a, 0x45, 0x3c, 0xbc, 0x6e, 0x7c, 0x65, 0x54, - 0x85, 0xcf, 0x70, 0x55, 0x34, 0x29, 0x12, 0xbc, 0x6c, 0x29, 0xab, 0x2e, 0x66, 0x5b, 0x11, 0x37, 0xe9, 0x89, 0xd4, - 0xa4, 0xd5, 0x93, 0xb9, 0x35, 0xd0, 0x7a, 0xef, 0xab, 0x1b, 0xad, 0x14, 0x30, 0x27, 0xd4, 0x0a, 0x39, 0x8d, 0xc6, - 0x14, 0x10, 0x42, 0x8a, 0xa5, 0xa9, 0xde, 0x4b, 0xa0, 0x16, 0xd0, 0x96, 0x0a, 0x47, 0x8a, 0x78, 0xe0, 0x1f, 0x3a, - 0x5d, 0xf0, 0x52, 0x81, 0x3b, 0xf7, 0x76, 0x33, 0x1d, 0x0c, 0xdc, 0x82, 0xf3, 0x9a, 0xbc, 0x81, 0x69, 0x55, 0xf8, - 0x15, 0x8c, 0x68, 0xdf, 0xa5, 0x65, 0xbc, 0x15, 0xb5, 0xf0, 0x4f, 0x98, 0xaa, 0xe8, 0x8b, 0xdc, 0x6b, 0xf0, 0x79, - 0x1e, 0x9e, 0x5b, 0x3d, 0x24, 0x41, 0xad, 0x5c, 0x53, 0x4e, 0x33, 0xd4, 0x49, 0xca, 0xa0, 0xd1, 0x92, 0x83, 0x29, - 0x6f, 0x6f, 0x7f, 0xfb, 0x67, 0xe5, 0x9d, 0x79, 0x94, 0xeb, 0xec, 0xc3, 0x20, 0xe6, 0x81, 0x51, 0x6a, 0x7e, 0x35, - 0x3c, 0xb2, 0x3a, 0x6a, 0xed, 0x56, 0x1b, 0xfe, 0x44, 0xc7, 0xfb, 0xf1, 0x70, 0xd0, 0xd3, 0xff, 0xfb, 0x56, 0xa9, - 0x6e, 0xe9, 0x06, 0x8a, 0x78, 0x44, 0x8a, 0xd8, 0x3b, 0x3c, 0xd0, 0x9b, 0x91, 0xaf, 0x49, 0xab, 0x3f, 0xef, 0xde, - 0xa2, 0xbf, 0x3a, 0x4e, 0x1d, 0x0c, 0x69, 0xeb, 0xa3, 0x6a, 0xc1, 0x35, 0x9a, 0x97, 0xef, 0xff, 0xbc, 0xbd, 0x3b, - 0x47, 0xb8, 0xee, 0x99, 0x10, 0x28, 0x36, 0x3c, 0xf7, 0xd6, 0xd2, 0x89, 0x8e, 0x1a, 0xd7, 0xab, 0x8d, 0xfc, 0x14, - 0x39, 0xc5, 0xd0, 0xd3, 0x6b, 0x21, 0x61, 0x08, 0x63, 0x10, 0xac, 0xd0, 0xc9, 0xab, 0x93, 0xb5, 0x67, 0x7e, 0xc5, - 0xc3, 0x6d, 0xc7, 0xc3, 0xd5, 0xc7, 0xfd, 0xcb, 0xf7, 0xbf, 0x81, 0xdb, 0x13, 0xb5, 0x09, 0x0b, 0x00, 0x00}; + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x95, 0x56, 0x6d, 0x8f, 0xdb, 0x36, 0x0c, 0xfe, 0xbe, + 0x5f, 0xa1, 0x79, 0xdd, 0x6a, 0xaf, 0xb1, 0xfc, 0x92, 0x4b, 0xda, 0x3a, 0x96, 0x8b, 0xee, 0xd6, 0x62, 0x03, 0xd6, + 0xad, 0xc0, 0xdd, 0xba, 0x0f, 0x45, 0x01, 0x2b, 0x32, 0x1d, 0xab, 0x27, 0x4b, 0x9e, 0xa4, 0xbc, 0x35, 0xc8, 0x7e, + 0xfb, 0x20, 0xdb, 0xc9, 0xe5, 0x8a, 0x16, 0xd8, 0x10, 0xc4, 0xa0, 0x44, 0xf2, 0xe1, 0x8b, 0x28, 0x52, 0xf9, 0xb7, + 0x95, 0x62, 0x76, 0xdf, 0x01, 0x6a, 0x6c, 0x2b, 0x8a, 0xdc, 0x7d, 0x91, 0xa0, 0x72, 0x45, 0x40, 0x16, 0x79, 0x03, + 0xb4, 0x2a, 0xf2, 0x16, 0x2c, 0x45, 0xac, 0xa1, 0xda, 0x80, 0x25, 0x7f, 0xde, 0xbe, 0x0e, 0x9f, 0x15, 0xb9, 0xe0, + 0xf2, 0x0e, 0x69, 0x10, 0x84, 0x33, 0x25, 0x51, 0xa3, 0xa1, 0x26, 0x15, 0xb5, 0x34, 0xe3, 0x2d, 0x5d, 0xc1, 0xa8, + 0x22, 0x69, 0x0b, 0x64, 0xc3, 0x61, 0xdb, 0x29, 0x6d, 0x11, 0x53, 0xd2, 0x82, 0xb4, 0xc4, 0xdb, 0xf2, 0xca, 0x36, + 0xa4, 0x82, 0x0d, 0x67, 0x10, 0xf6, 0x8b, 0x09, 0x97, 0xdc, 0x72, 0x2a, 0x42, 0xc3, 0xa8, 0x00, 0x92, 0x4c, 0xd6, + 0x06, 0x74, 0xbf, 0xa0, 0x4b, 0x01, 0x44, 0x2a, 0xaf, 0xc8, 0x0d, 0xd3, 0xbc, 0xb3, 0xc8, 0xb9, 0x4a, 0x5a, 0x55, + 0xad, 0x05, 0x20, 0xa6, 0x95, 0x31, 0x4a, 0xf3, 0x15, 0x97, 0x45, 0xa5, 0xd8, 0xba, 0x05, 0x69, 0xb1, 0x50, 0x8c, + 0x5a, 0xae, 0x24, 0x36, 0x40, 0x35, 0x6b, 0x08, 0x21, 0xe5, 0x0b, 0x43, 0x37, 0x50, 0xfe, 0xf0, 0x83, 0x7f, 0x16, + 0x5a, 0x81, 0x7d, 0x25, 0xc0, 0x91, 0xe6, 0xa7, 0xfd, 0x2d, 0x5d, 0xfd, 0x4e, 0x5b, 0xf0, 0x4b, 0x6a, 0x78, 0x05, + 0x65, 0xf0, 0x3e, 0xfe, 0x80, 0x8d, 0xdd, 0x0b, 0xc0, 0x15, 0x37, 0x9d, 0xa0, 0x7b, 0x52, 0x2e, 0x85, 0x62, 0x77, + 0x65, 0xb0, 0xa8, 0xd7, 0x92, 0x39, 0x70, 0x04, 0x3e, 0x04, 0x07, 0x01, 0x16, 0x49, 0xf2, 0x86, 0xda, 0x06, 0xb7, + 0x74, 0xe7, 0x0f, 0x04, 0x97, 0x7e, 0xfa, 0xa3, 0x0f, 0x4f, 0x92, 0x38, 0x0e, 0x26, 0xfd, 0x27, 0x0e, 0xa2, 0x24, + 0x8e, 0x17, 0x1a, 0xec, 0x5a, 0x4b, 0x64, 0xfd, 0x32, 0xef, 0xa8, 0x6d, 0x50, 0x45, 0xbc, 0x37, 0x49, 0x8a, 0x92, + 0xe7, 0x38, 0x9d, 0xfd, 0x86, 0x9f, 0xa2, 0x2b, 0x9c, 0xce, 0xd8, 0xd3, 0x70, 0x86, 0x92, 0xab, 0x70, 0x86, 0xd2, + 0x14, 0xcf, 0x50, 0xfc, 0xc9, 0x43, 0x35, 0x17, 0x82, 0x78, 0x52, 0x49, 0xf0, 0x90, 0xb1, 0x5a, 0xdd, 0x01, 0xf1, + 0xd8, 0x5a, 0x6b, 0x90, 0xf6, 0x5a, 0x09, 0xa5, 0xbd, 0xa8, 0xf8, 0xe6, 0x7f, 0x01, 0x5a, 0x4d, 0xa5, 0xa9, 0x95, + 0x6e, 0x89, 0xd7, 0xa7, 0xdb, 0x7f, 0x74, 0x90, 0x47, 0xe4, 0x3e, 0xc1, 0x05, 0x33, 0x1c, 0xf2, 0x4a, 0x3c, 0x87, + 0xf8, 0xcc, 0x8b, 0x8a, 0x32, 0x38, 0x9e, 0xa3, 0xb7, 0x2e, 0xfa, 0x31, 0x1e, 0xed, 0xbf, 0x2f, 0x73, 0xb3, 0x59, + 0xa1, 0x5d, 0x2b, 0xa4, 0x21, 0x5e, 0x63, 0x6d, 0x97, 0x45, 0xd1, 0x76, 0xbb, 0xc5, 0xdb, 0x29, 0x56, 0x7a, 0x15, + 0xa5, 0x71, 0x1c, 0x47, 0x66, 0xb3, 0xf2, 0xd0, 0x70, 0xf2, 0x5e, 0x7a, 0xe5, 0xa1, 0x06, 0xf8, 0xaa, 0xb1, 0x3d, + 0x5d, 0x3c, 0x3a, 0xc0, 0x31, 0x77, 0x12, 0x45, 0xf9, 0xe1, 0xc2, 0x8a, 0xbc, 0xb0, 0x02, 0x2f, 0x2e, 0xf2, 0xf6, + 0xb8, 0x0f, 0xf3, 0x29, 0x4d, 0x51, 0x8a, 0xe2, 0xfe, 0x97, 0x86, 0x8e, 0x1e, 0x57, 0xe1, 0x67, 0x2b, 0x74, 0xb1, + 0x72, 0x54, 0x3b, 0x0f, 0x9f, 0x9f, 0x75, 0x13, 0xb7, 0xb3, 0x49, 0xe2, 0xfb, 0x0d, 0xa7, 0xf0, 0xcb, 0xfc, 0x72, + 0x1d, 0xa6, 0xef, 0x2e, 0x05, 0x9c, 0xb5, 0x26, 0x79, 0x37, 0xa7, 0x33, 0x34, 0x1b, 0x77, 0x66, 0xa1, 0xa3, 0xcf, + 0x2b, 0x34, 0xdb, 0xa4, 0x4d, 0xd2, 0x86, 0xf3, 0x70, 0x46, 0xa7, 0x68, 0x3a, 0x3a, 0x32, 0x45, 0xd3, 0x4d, 0xda, + 0xcc, 0xdf, 0xcd, 0x2f, 0xf7, 0xc2, 0xe9, 0xa7, 0xc7, 0x2e, 0xb9, 0x59, 0x59, 0xde, 0x47, 0xae, 0x2f, 0x23, 0xc7, + 0x1f, 0x15, 0x97, 0x7e, 0xe9, 0xf2, 0x0f, 0x96, 0x35, 0x7e, 0x19, 0x31, 0x25, 0x6b, 0xbe, 0xc2, 0x1f, 0x8d, 0x92, + 0x65, 0x80, 0x6d, 0x03, 0xd2, 0x3f, 0xa9, 0xfa, 0x36, 0x38, 0xd8, 0x9e, 0xe3, 0x7f, 0x81, 0x73, 0xae, 0x7f, 0xcb, + 0xad, 0x00, 0x62, 0xb1, 0xbb, 0xa1, 0x93, 0x2f, 0xdc, 0x8a, 0x9f, 0xf6, 0xbf, 0x56, 0x7e, 0xd9, 0x52, 0x56, 0x06, + 0x98, 0x4b, 0x09, 0xfa, 0x16, 0x76, 0x96, 0x94, 0x6f, 0x5e, 0x5e, 0xa3, 0x97, 0x55, 0xa5, 0xc1, 0x98, 0x0c, 0x95, + 0x4f, 0x2c, 0x6e, 0x29, 0xfb, 0xba, 0x7a, 0x93, 0x3c, 0xd4, 0xfe, 0x8b, 0xbf, 0xe6, 0xe8, 0x77, 0xb0, 0x5b, 0xa5, + 0xef, 0x46, 0x7d, 0x67, 0x7f, 0xe1, 0xae, 0x91, 0x26, 0x5f, 0x85, 0x91, 0x60, 0xcb, 0x60, 0xc2, 0xbf, 0x2e, 0x60, + 0x0c, 0xaf, 0xca, 0x60, 0x42, 0xbf, 0x2e, 0xd1, 0x19, 0x77, 0x79, 0x2d, 0xa6, 0x9d, 0xc1, 0x46, 0x70, 0x06, 0x7e, + 0x12, 0xe0, 0x5a, 0xe9, 0x57, 0x94, 0x35, 0x0f, 0x12, 0xe4, 0x5c, 0x51, 0xf7, 0x38, 0x4c, 0x03, 0xb5, 0x30, 0x42, + 0xf9, 0x65, 0xc5, 0x37, 0x65, 0xb0, 0x50, 0x98, 0x09, 0x6a, 0x8c, 0x6b, 0x19, 0xc4, 0x39, 0xe7, 0xc2, 0x29, 0x27, + 0x6a, 0x88, 0xf4, 0x97, 0xdb, 0x37, 0xbf, 0x91, 0x32, 0xa7, 0x43, 0x47, 0xf4, 0xbe, 0xf3, 0x50, 0x2f, 0x4c, 0xbc, + 0x51, 0x30, 0x14, 0x50, 0xdb, 0xbe, 0xe2, 0x7d, 0x8b, 0xb5, 0x31, 0x3c, 0x38, 0xe6, 0xa6, 0xa3, 0xf2, 0x73, 0x31, + 0x17, 0x93, 0x57, 0xe4, 0x91, 0xe3, 0x15, 0x79, 0x44, 0x8b, 0x47, 0x07, 0xe9, 0xf7, 0xcd, 0xed, 0x2e, 0x38, 0x3a, + 0x6b, 0x7f, 0xaf, 0x41, 0xef, 0x6f, 0x40, 0x00, 0xb3, 0x4a, 0xfb, 0x25, 0xbe, 0x54, 0x74, 0x45, 0x01, 0x3b, 0x7b, + 0x3d, 0x36, 0x5c, 0x8b, 0xdd, 0xe6, 0x44, 0x61, 0x25, 0x99, 0xe0, 0xec, 0x8e, 0x9c, 0x23, 0x0e, 0x0e, 0x1c, 0x6f, + 0xa8, 0x58, 0xc3, 0x49, 0x86, 0xe2, 0x5a, 0xb1, 0xb5, 0xf1, 0x83, 0xe3, 0x44, 0x63, 0xda, 0x75, 0x20, 0xab, 0xeb, + 0x86, 0x8b, 0xca, 0x57, 0xc1, 0x31, 0xb8, 0x3f, 0xe9, 0xcf, 0x8c, 0xbb, 0x59, 0xf0, 0x5e, 0x83, 0xf8, 0x87, 0x3c, + 0x76, 0xd3, 0xe0, 0xf1, 0x87, 0x32, 0xc0, 0x7d, 0xfc, 0xe5, 0xfd, 0x48, 0x70, 0xd7, 0xfb, 0xc9, 0xae, 0x15, 0x13, + 0x17, 0x7a, 0x38, 0x9f, 0x05, 0xc7, 0xf2, 0x18, 0x1c, 0x83, 0x45, 0x1e, 0x0d, 0x8d, 0xbd, 0xc8, 0xfb, 0x96, 0xdb, + 0x8f, 0x94, 0x9e, 0x32, 0x0d, 0x80, 0x7d, 0xd0, 0xe2, 0x7f, 0x3c, 0x2c, 0xd5, 0x2e, 0x34, 0xfc, 0x13, 0x97, 0xab, + 0x8c, 0xcb, 0x06, 0x34, 0xb7, 0xc7, 0x8a, 0x6f, 0x26, 0x5c, 0x76, 0x6b, 0x7b, 0xe8, 0x68, 0x55, 0x39, 0xce, 0xac, + 0xdb, 0x2d, 0x6a, 0x25, 0xad, 0x93, 0x84, 0x2c, 0x81, 0xf6, 0x38, 0xf0, 0xfb, 0xe6, 0x93, 0x3d, 0x9f, 0x7d, 0x7f, + 0x5c, 0xaa, 0x6a, 0x7f, 0x70, 0x19, 0x0a, 0xa9, 0xe0, 0x2b, 0x99, 0x31, 0x90, 0x16, 0xf4, 0xa0, 0x54, 0xd3, 0x96, + 0x8b, 0x7d, 0x66, 0xa8, 0x34, 0xa1, 0x01, 0xcd, 0xeb, 0xe3, 0x72, 0x6d, 0xad, 0x92, 0x07, 0xe6, 0x9a, 0x6d, 0xf6, + 0x5d, 0x5d, 0xd7, 0x0b, 0xb6, 0xd6, 0x46, 0xe9, 0xac, 0x53, 0xbc, 0xd7, 0x5b, 0x52, 0x76, 0xb7, 0xd2, 0x6a, 0x2d, + 0xab, 0x70, 0x14, 0x4a, 0x6a, 0x3a, 0x05, 0xb6, 0x58, 0x2a, 0x5d, 0x81, 0xce, 0xe2, 0x91, 0x08, 0x35, 0xad, 0xf8, + 0xda, 0x64, 0x78, 0xaa, 0xa1, 0x5d, 0x0c, 0xee, 0x24, 0x71, 0xfc, 0xfd, 0xe2, 0xe4, 0x79, 0x7c, 0xe9, 0x37, 0x4e, + 0x9d, 0x94, 0xe0, 0x12, 0xc2, 0xa1, 0x57, 0x66, 0x29, 0xbe, 0xd2, 0xd0, 0x1e, 0x5b, 0xca, 0xe5, 0xa5, 0xf7, 0xae, + 0xa2, 0x16, 0x2d, 0x97, 0xc3, 0x28, 0xcd, 0xd2, 0x79, 0xdc, 0xed, 0x16, 0xe3, 0xe4, 0xca, 0xb8, 0xec, 0x11, 0xfa, + 0xf9, 0x75, 0x3c, 0x15, 0xc9, 0xe1, 0xe3, 0xda, 0x58, 0x5e, 0xef, 0xc3, 0x71, 0x24, 0x67, 0xa6, 0xa3, 0x0c, 0xc2, + 0x25, 0xd8, 0x2d, 0x80, 0x5c, 0xf4, 0xb0, 0x21, 0xb7, 0xd0, 0x9a, 0x53, 0x6a, 0x4e, 0x70, 0xb5, 0x80, 0xdd, 0x19, + 0xa6, 0xaf, 0xe5, 0xc3, 0x7f, 0x96, 0x76, 0x05, 0x76, 0x68, 0xa9, 0x5e, 0x71, 0x19, 0x2e, 0x95, 0xb5, 0xaa, 0xcd, + 0xc2, 0xa7, 0xdd, 0x6e, 0x31, 0x6e, 0x39, 0xb0, 0x2c, 0x89, 0xbb, 0xdd, 0xb1, 0x1f, 0xc3, 0xa7, 0x7c, 0x5f, 0xd5, + 0xcf, 0x68, 0x12, 0x7f, 0x21, 0xc7, 0x55, 0x5d, 0xa7, 0xcb, 0xfa, 0x94, 0xe3, 0xa4, 0xdb, 0x21, 0xa3, 0x04, 0xaf, + 0x46, 0xb8, 0x1e, 0x09, 0xc5, 0xe7, 0xd4, 0x26, 0xb3, 0x6e, 0x87, 0x92, 0xcb, 0xcc, 0xb8, 0x89, 0xea, 0xa6, 0x8e, + 0xab, 0xb5, 0x22, 0x8f, 0x86, 0x97, 0x8e, 0xab, 0x8c, 0x22, 0x77, 0x19, 0x2e, 0xf2, 0x26, 0x41, 0xbc, 0x22, 0x2d, + 0x65, 0xc5, 0x45, 0xdb, 0xcb, 0xa3, 0x26, 0x39, 0xb1, 0x9a, 0xa4, 0x78, 0xd0, 0xd2, 0x06, 0x5e, 0xef, 0x7d, 0x71, + 0xad, 0xa4, 0x04, 0x66, 0xb9, 0x5c, 0x21, 0xab, 0xd0, 0x98, 0x02, 0x8c, 0x71, 0xbe, 0xd4, 0xc5, 0x5b, 0x01, 0xd4, + 0x00, 0xda, 0x52, 0x6e, 0x71, 0x1e, 0x0d, 0xf2, 0x43, 0x13, 0xe0, 0x15, 0x91, 0x60, 0xcf, 0xd7, 0xbe, 0x99, 0x0e, + 0x06, 0x6e, 0xc0, 0x3a, 0x24, 0x67, 0x60, 0x5a, 0xe4, 0x6e, 0x3a, 0x23, 0xda, 0x5f, 0x60, 0x12, 0x6d, 0x79, 0xcd, + 0xdd, 0xeb, 0xa6, 0xc8, 0xfb, 0x22, 0x77, 0x08, 0x2e, 0xcf, 0xc3, 0xd3, 0xab, 0xa7, 0x04, 0xc8, 0x95, 0x6d, 0xc8, + 0x34, 0x45, 0x9d, 0xa0, 0x0c, 0x1a, 0x25, 0x2a, 0xd0, 0xe4, 0xe6, 0xe6, 0xd7, 0x9f, 0x0b, 0xe7, 0xcc, 0xbd, 0x5e, + 0x67, 0xee, 0x06, 0x35, 0x47, 0x8c, 0x5a, 0xf3, 0xab, 0xe1, 0xc1, 0xd5, 0x51, 0x63, 0xb6, 0x4a, 0x57, 0x0f, 0x30, + 0xde, 0x8e, 0x9b, 0x03, 0x4e, 0xff, 0xef, 0xaf, 0x4a, 0x71, 0x43, 0x37, 0x90, 0x47, 0xe3, 0x22, 0x8f, 0x9c, 0xc3, + 0x03, 0xbf, 0x19, 0xe5, 0x9a, 0xa4, 0xf8, 0xe3, 0xf6, 0x25, 0xfa, 0xb3, 0xab, 0xa8, 0x85, 0x21, 0x6d, 0x7d, 0x54, + 0x2d, 0xd8, 0x46, 0x55, 0xe4, 0xed, 0x1f, 0x37, 0xb7, 0xe7, 0x08, 0xd7, 0xbd, 0x10, 0x02, 0xc9, 0x86, 0xa7, 0xdf, + 0x5a, 0x58, 0xde, 0x51, 0x6d, 0x7b, 0xd8, 0xd0, 0x35, 0x98, 0x53, 0x0c, 0x3d, 0xbf, 0xe6, 0x02, 0x86, 0x30, 0x06, + 0xc5, 0x02, 0x9d, 0xbc, 0x3a, 0x59, 0xfb, 0xcc, 0xaf, 0x68, 0x38, 0xed, 0x68, 0x38, 0xfa, 0xa8, 0x7f, 0x05, 0xff, + 0x0b, 0x54, 0xcf, 0x54, 0x8b, 0x15, 0x0b, 0x00, 0x00}; #else // Brotli (default, smaller) constexpr uint8_t INDEX_BR[] PROGMEM = { - 0x1b, 0x08, 0x0b, 0x00, 0xe4, 0x7f, 0x9b, 0xad, 0xbb, 0x97, 0x53, 0xde, 0xb7, 0x25, 0x0e, 0x69, 0xd4, 0x69, 0x89, - 0xba, 0xa5, 0x55, 0x22, 0x04, 0x27, 0xeb, 0x00, 0x52, 0xac, 0xbc, 0xec, 0x5f, 0xfb, 0xb5, 0x7a, 0x12, 0x0a, 0xd6, - 0x48, 0x84, 0x4a, 0x48, 0x5a, 0xcb, 0xbd, 0xb7, 0x72, 0x66, 0x4e, 0x62, 0xd8, 0xbd, 0x7f, 0x88, 0x68, 0x86, 0x28, - 0xd6, 0xf1, 0xda, 0x2c, 0xa2, 0x32, 0x5c, 0xdd, 0xab, 0xb2, 0x15, 0xbc, 0x24, 0x13, 0xe6, 0xbd, 0x0c, 0x52, 0x63, - 0x82, 0x88, 0x6d, 0x74, 0x71, 0x51, 0x9c, 0xe2, 0x40, 0x56, 0xea, 0xb0, 0x5c, 0xb7, 0x1d, 0x81, 0x3a, 0x0c, 0xf2, - 0xd7, 0xa8, 0x5c, 0x35, 0x2d, 0x43, 0xb3, 0x42, 0x37, 0x7c, 0x60, 0xd8, 0xc1, 0x95, 0x91, 0x94, 0x3c, 0x29, 0x20, - 0x96, 0x20, 0xf6, 0x24, 0xb7, 0x83, 0x4a, 0x06, 0xf1, 0xc3, 0x2f, 0x88, 0x50, 0x55, 0x35, 0x2d, 0xe8, 0xb6, 0x21, - 0x38, 0x61, 0x8e, 0x44, 0x2a, 0xac, 0x39, 0xcf, 0x74, 0xaa, 0x31, 0x7f, 0x62, 0x32, 0x9b, 0x99, 0x42, 0x0a, 0xf6, - 0x6f, 0xd8, 0x89, 0x3f, 0x49, 0xb1, 0xa2, 0x52, 0x0a, 0x8e, 0xb3, 0x27, 0x0b, 0x07, 0x07, 0x58, 0xb0, 0x8f, 0xaa, - 0xdc, 0x68, 0x12, 0x0f, 0x95, 0xbf, 0xc7, 0x36, 0xd5, 0x60, 0x5a, 0xc7, 0x80, 0xac, 0x52, 0xf7, 0xa7, 0x2d, 0xb6, - 0x64, 0xda, 0xda, 0x11, 0x8d, 0x6a, 0xe5, 0xba, 0xe9, 0xda, 0xdc, 0x62, 0xc3, 0xcb, 0xae, 0xc1, 0xe1, 0x11, 0xb6, - 0x33, 0x29, 0x04, 0x09, 0xfe, 0x09, 0x08, 0xc2, 0x1f, 0x98, 0x16, 0x26, 0x0d, 0xce, 0xd7, 0x75, 0xfb, 0xd7, 0xa5, - 0x82, 0xd7, 0x32, 0x44, 0x72, 0xc1, 0xc2, 0xe4, 0x15, 0xcb, 0x50, 0xfc, 0xd3, 0x58, 0x64, 0x34, 0x41, 0x32, 0xbe, - 0x1f, 0x08, 0x43, 0x16, 0x14, 0xf7, 0x70, 0x2c, 0x1c, 0x61, 0x09, 0x78, 0x73, 0xd1, 0x30, 0xf6, 0xed, 0x85, 0x55, - 0x50, 0x02, 0xf0, 0x68, 0x50, 0x5c, 0x1a, 0xd7, 0x3b, 0x8e, 0xf2, 0x23, 0xc8, 0x88, 0x39, 0xd0, 0x84, 0xf7, 0xa6, - 0xd1, 0xa3, 0xfb, 0xe5, 0x44, 0xc0, 0x4c, 0x2f, 0x6f, 0x19, 0x70, 0x75, 0xf6, 0x1c, 0xb8, 0xce, 0x89, 0x4f, 0x01, - 0x8d, 0xa1, 0x71, 0xf2, 0x97, 0xf8, 0xe7, 0xd3, 0xf1, 0xe1, 0xfa, 0xfc, 0xc8, 0x03, 0x78, 0x14, 0xa0, 0x3d, 0x28, - 0xb7, 0xeb, 0x26, 0x52, 0x59, 0xa8, 0xb5, 0x0d, 0x5c, 0x8a, 0x6b, 0xe5, 0xf6, 0x30, 0xd6, 0xf7, 0x71, 0x31, 0xe8, - 0xbd, 0xc9, 0xfa, 0xf5, 0x71, 0x9d, 0xff, 0xf6, 0x69, 0x62, 0x5f, 0xb5, 0xc7, 0x06, 0x43, 0x54, 0xb5, 0x87, 0xf1, - 0xcc, 0x84, 0xe8, 0xb7, 0x56, 0x38, 0x43, 0x6a, 0xa6, 0x2f, 0x53, 0xd1, 0x89, 0x48, 0x8d, 0x72, 0x75, 0x4a, 0x17, - 0xf6, 0x8d, 0xb2, 0xeb, 0xb1, 0x6b, 0x29, 0x1e, 0xd5, 0x74, 0xc7, 0xb3, 0xf4, 0xf1, 0x04, 0x0d, 0xbf, 0x08, 0x81, - 0x8f, 0xfe, 0x8d, 0xfc, 0xf2, 0x35, 0x92, 0xa0, 0x24, 0x88, 0x12, 0x6a, 0xe6, 0x2f, 0x01, 0x94, 0x5c, 0x4b, 0xf9, - 0x6b, 0x9a, 0xf6, 0x1a, 0x35, 0x11, 0x8a, 0xc6, 0x04, 0x8d, 0x50, 0x64, 0x48, 0x2d, 0x8b, 0xdf, 0xdf, 0xa1, 0xd1, - 0xfd, 0x21, 0xd7, 0x40, 0x96, 0x00, 0xb1, 0x9f, 0x54, 0xc2, 0xe1, 0x00, 0x79, 0x15, 0x80, 0xf8, 0xca, 0x8e, 0xc5, - 0x06, 0x03, 0xdf, 0x72, 0x49, 0xc0, 0x08, 0x27, 0x90, 0xe3, 0x14, 0xc2, 0xac, 0xc3, 0x83, 0xc9, 0xf6, 0x9d, 0x12, - 0xab, 0x46, 0xae, 0x03, 0x74, 0x1d, 0x27, 0xce, 0x91, 0x1d, 0x4e, 0xb4, 0xbe, 0x80, 0xe7, 0x6a, 0x6d, 0x0a, 0x20, - 0x47, 0x6b, 0x00, 0x4e, 0x25, 0x52, 0xe6, 0xf5, 0xe9, 0x43, 0x84, 0xc1, 0x0d, 0x4b, 0x04, 0xb3, 0x91, 0x49, 0xf5, - 0xe9, 0xc4, 0x2e, 0x1b, 0xf9, 0x98, 0xf9, 0xea, 0x9e, 0xb8, 0xf6, 0x53, 0xf8, 0x42, 0xc2, 0x60, 0x5c, 0xa9, 0xd2, - 0xfe, 0x0a, 0xe5, 0xd4, 0x7d, 0x36, 0x76, 0x04, 0x12, 0x38, 0xa1, 0xc4, 0x30, 0xb8, 0xf2, 0x69, 0x86, 0x5b, 0xe7, - 0xe5, 0xa0, 0xc0, 0xfe, 0x91, 0x19, 0x03, 0x1e, 0xa9, 0x93, 0x26, 0x49, 0x58, 0xd5, 0xf6, 0x33, 0x4e, 0x0a, 0x89, - 0x64, 0x1e, 0xb4, 0x7a, 0x5d, 0x0d, 0x12, 0xcf, 0x2b, 0xdd, 0x35, 0x90, 0x55, 0xc3, 0x0e, 0xcd, 0x0e, 0xad, 0x6b, - 0x8f, 0x43, 0xd0, 0xb4, 0x6a, 0xdb, 0x4b, 0xe5, 0xa4, 0x9b, 0x09, 0x23, 0x1a, 0x43, 0xa9, 0xff, 0x61, 0x8b, 0x07, - 0xd6, 0x0f, 0x83, 0x23, 0xbe, 0x8a, 0x66, 0xa2, 0x10, 0x2f, 0x11, 0x01, 0x0d, 0xc6, 0x96, 0xba, 0x87, 0xaa, 0xa8, - 0x44, 0x7c, 0x1e, 0x34, 0xdb, 0xba, 0x41, 0x90, 0xf0, 0x7a, 0xdb, 0x63, 0x60, 0x96, 0x8d, 0x64, 0xcb, 0x2f, 0x28, - 0x96, 0x04, 0xd5, 0xc0, 0x7a, 0xe8, 0xec, 0xd1, 0x61, 0x1b, 0x09, 0x4b, 0x4c, 0x6e, 0x1b, 0x31, 0x98, 0x9c, 0x6d, - 0xdb, 0xd0, 0xec, 0xa4, 0x0f, 0x0a, 0xe0, 0xc8, 0x35, 0xc4, 0x93, 0xdc, 0xee, 0x19, 0x00, 0x80, 0x07, 0xf5, 0xcf, - 0xe0, 0x7f, 0x75, 0xf8, 0x52, 0x3a, 0xfc, 0x0d, 0x84, 0xa5, 0xc1, 0xb2, 0x1c, 0x25, 0x40, 0xc5, 0x8b, 0xb3, 0xdb, - 0x7a, 0x1b, 0x44, 0xff, 0x79, 0x9a, 0x26, 0xc4, 0xe7, 0x9e, 0x78, 0x4c, 0xa5, 0x94, 0xab, 0x78, 0x34, 0x9d, 0xb5, - 0xb7, 0x24, 0x26, 0xe7, 0x9a, 0xf3, 0xe5, 0x2a, 0x35, 0x4b, 0xbe, 0x74, 0xd7, 0x01, 0xbc, 0x71, 0x72, 0x03, 0x5c, - 0x40, 0x24, 0x17, 0x61, 0x5b, 0x7b, 0x19, 0xc2, 0x7f, 0x4e, 0x5b, 0x24, 0xfb, 0x8b, 0xc3, 0x51, 0x00, 0x3d, 0x09, - 0x04, 0x05, 0x72, 0x64, 0xf6, 0xf0, 0x6b, 0x99, 0x38, 0x93, 0x5b, 0xac, 0x0c, 0xff, 0x40, 0x7b, 0x53, 0xba, 0xab, - 0x61, 0xc9, 0xa2, 0xde, 0xd6, 0x2b, 0x0c, 0xbd, 0x85, 0xac, 0x4c, 0x64, 0x8b, 0xe6, 0x69, 0x2b, 0x56, 0x10, 0x1b, - 0x08, 0x59, 0x6c, 0x55, 0x0a, 0xaa, 0x93, 0x85, 0x1d, 0x45, 0xda, 0xc6, 0x39, 0xe6, 0x6a, 0xab, 0x71, 0x73, 0x46, - 0x0f, 0xf7, 0xab, 0x4e, 0x88, 0xae, 0x8c, 0xe0, 0x91, 0xda, 0x35, 0x8c, 0xd3, 0x18, 0x92, 0x3d, 0xab, 0x2f, 0x0d, - 0xd6, 0xc9, 0x06, 0xdb, 0xc2, 0x62, 0xcb, 0x8a, 0x23, 0x5b, 0x28, 0x2e, 0x9b, 0x96, 0xc4, 0xc1, 0x42, 0xa9, 0x8d, - 0x69, 0xe5, 0x8f, 0x89, 0x12, 0x11, 0x9a, 0x56, 0x3b, 0x3c, 0x2b, 0xb4, 0xb2, 0x7b, 0xfd, 0xdb, 0x80, 0x92, 0xb4, - 0xca, 0x44, 0x37, 0x8c, 0x94, 0x2f, 0x4a, 0xb4, 0xc4, 0x28, 0x83, 0x8a, 0x78, 0xcb, 0xd2, 0x5c, 0x5c, 0x35, 0x29, - 0x95, 0x35, 0x2f, 0x99, 0x28, 0x4f, 0x22, 0x18, 0x70, 0x85, 0xee, 0x2c, 0xb9, 0xef, 0x14, 0x57, 0x73, 0x23, 0x45, - 0xae, 0xdc, 0x54, 0x56, 0x55, 0x78, 0x56, 0xad, 0x48, 0x26, 0x27, 0xbf, 0xcb, 0xd7, 0x54, 0xa9, 0xa8, 0xd7, 0xb5, - 0x71, 0x9c, 0xe7, 0x79, 0x89, 0x5c, 0xa9, 0x6a, 0x53, 0xe8, 0xfa, 0x0d, 0x69, 0x36, 0xed, 0xad, 0x33, 0xc9, 0x75, - 0x17, 0xe9, 0x8f, 0x31, 0x58, 0xa6, 0x27, 0xfc, 0x79, 0xc6, 0xb6, 0xd5, 0x65, 0x90, 0x31, 0xc6, 0x9d, 0x29, 0x95, - 0x83, 0xe5, 0x4e, 0xbb, 0xd7, 0xdc, 0x8e, 0xd0, 0x3a, 0x54, 0x27, 0xce, 0xf5, 0xdb, 0xbd, 0x89, 0x3c, 0x61, 0xb3, - 0x71, 0x23, 0xc7, 0x55, 0x9e, 0xea, 0x50, 0xe4, 0x37, 0xae, 0x72, 0x34, 0x66, 0xb9, 0x6e, 0x2c, 0x0a, 0x69, 0x8d, - 0x94, 0x8b, 0x98, 0x08, 0x05, 0x3c, 0x45, 0x45, 0xe1, 0x6c, 0x22, 0xc5, 0x8f, 0x1f, 0x9f, 0x3f, 0xd2, 0x01, 0x12, - 0xec, 0x86, 0x2f, 0x87, 0x8b, 0x47, 0x30, 0xd0, 0x77, 0x77, 0x1a, 0x13, 0x2d, 0xc6, 0x31, 0x65, 0x77, 0xd8, 0x8c, - 0xe7, 0xe0, 0x16, 0xf9, 0x4b, 0xd4, 0xc5, 0xa8, 0x67, 0x79, 0xe7, 0xc3, 0x07, 0x94, 0x46, 0xa3, 0x8c, 0x67, 0xd3, - 0xff, 0x5f, 0x96, 0xfa, 0xed, 0xa7, 0xd3, 0xdd, 0x4f, 0x27, 0x49, 0x27, 0xcf, 0xa4, 0x02, 0xc3, 0x27, 0x3c, 0x96, - 0x64, 0x24, 0x55, 0xc8, 0x36, 0x45, 0x68, 0x90, 0xea, 0x03, 0x0b, 0x46, 0xa7, 0x8d, 0xb4, 0x26, 0x91, 0x07, 0x4c, - 0x80, 0x7b, 0x93, 0xa8, 0x10, 0xcb, 0x5e, 0x8d, 0x42, 0x86, 0x3e, 0x2a, 0x7c, 0x99, 0x79, 0x8e, 0xcb, 0x43, 0x28}; + 0x1b, 0x14, 0x0b, 0x00, 0xe4, 0x6f, 0xcd, 0xfc, 0x7b, 0x2e, 0x27, 0xd2, 0x21, 0x2b, 0x58, 0xea, 0x16, 0xf8, 0xa5, + 0xb6, 0x47, 0x14, 0xb3, 0x4c, 0x56, 0xcc, 0x20, 0x5b, 0x1d, 0xfe, 0x7d, 0xfb, 0xb5, 0x7a, 0x12, 0x0a, 0xd6, 0x48, + 0x84, 0xa2, 0x21, 0x69, 0x0d, 0x77, 0x33, 0xf3, 0x77, 0xcf, 0x4c, 0x21, 0xf1, 0xde, 0xee, 0x7d, 0x44, 0xbc, 0xd3, + 0xc4, 0x33, 0x89, 0x1a, 0x69, 0x68, 0x48, 0x57, 0xa7, 0x17, 0x0b, 0x4d, 0x91, 0xac, 0x30, 0x48, 0x21, 0x4d, 0x4c, + 0x10, 0x57, 0x46, 0x14, 0x17, 0xd5, 0x21, 0x0e, 0xb4, 0x50, 0x87, 0xad, 0x62, 0xda, 0x11, 0x68, 0xc3, 0x20, 0x7f, + 0x2d, 0xdc, 0x57, 0xeb, 0x2c, 0x36, 0xdb, 0xc4, 0x84, 0x0f, 0xac, 0xec, 0x08, 0x91, 0xa3, 0x92, 0x27, 0x45, 0xc4, + 0x1e, 0xa4, 0x9e, 0x72, 0x3b, 0xc2, 0xe3, 0x20, 0x7d, 0xf8, 0x05, 0x09, 0xea, 0xe3, 0xa6, 0x3f, 0x11, 0x8b, 0x16, + 0x11, 0x6b, 0x26, 0x91, 0x1a, 0x2c, 0x19, 0x24, 0xf7, 0x5d, 0x44, 0x82, 0x49, 0x44, 0x15, 0xce, 0x39, 0xdc, 0xcb, + 0x8f, 0x5b, 0xe1, 0xe2, 0x42, 0x96, 0xa2, 0x10, 0x3c, 0x20, 0xa5, 0x65, 0x85, 0x49, 0x6a, 0x06, 0x08, 0xd1, 0xcb, + 0x41, 0xb8, 0x49, 0x20, 0x73, 0x71, 0xfe, 0x55, 0x61, 0x45, 0xc6, 0x95, 0x72, 0xc8, 0xf0, 0xa5, 0xe9, 0xe6, 0x3a, + 0xb9, 0xc3, 0x8a, 0x9f, 0xb5, 0xc1, 0xc9, 0x15, 0x56, 0x93, 0x38, 0x8a, 0x48, 0xf0, 0x4f, 0x38, 0x22, 0xe1, 0x8d, + 0x55, 0xbb, 0x8c, 0xc3, 0xb0, 0x68, 0xcc, 0x7f, 0x6f, 0xf8, 0xc9, 0x9b, 0x38, 0x41, 0xf1, 0x94, 0x25, 0xf9, 0x6b, + 0x56, 0xa2, 0xec, 0xa7, 0xbd, 0x2e, 0x69, 0x8e, 0xe2, 0xec, 0x36, 0x94, 0x24, 0x2c, 0x12, 0x1d, 0x4e, 0x76, 0x7e, + 0x23, 0xcc, 0xf2, 0x6e, 0x35, 0x1a, 0x9c, 0xed, 0x6f, 0x15, 0x3f, 0xc9, 0x72, 0xdc, 0xfd, 0x13, 0x0f, 0x16, 0x8a, + 0x23, 0x4f, 0xf9, 0x2e, 0x63, 0x44, 0x91, 0x77, 0xe0, 0xb3, 0xd1, 0x78, 0x74, 0xdb, 0x4a, 0x2c, 0xd8, 0xe8, 0xf9, + 0x2c, 0x03, 0xbe, 0xae, 0xac, 0x4e, 0x42, 0x01, 0xc4, 0x4b, 0x40, 0xe7, 0x94, 0x34, 0x85, 0x2c, 0xfe, 0xf5, 0x74, + 0x75, 0xd8, 0xdc, 0xec, 0x6a, 0x00, 0x3f, 0x3f, 0x81, 0x77, 0xa8, 0xcd, 0xde, 0x6d, 0x5a, 0x47, 0xa1, 0x99, 0x36, + 0x87, 0xb6, 0x78, 0x35, 0x3c, 0x9a, 0x64, 0x15, 0x7c, 0x56, 0x76, 0x22, 0xce, 0x46, 0xe5, 0x17, 0x57, 0x05, 0xfc, + 0x09, 0x69, 0xae, 0x39, 0xaa, 0xee, 0xc9, 0x4e, 0x7f, 0x99, 0x2a, 0x65, 0x82, 0x7e, 0xeb, 0x23, 0x4f, 0x42, 0xd5, + 0xca, 0xcb, 0x42, 0x74, 0x2e, 0xd2, 0xa2, 0x62, 0x57, 0xd0, 0xa9, 0x7b, 0x4b, 0xac, 0x7b, 0x65, 0x13, 0x47, 0x0f, + 0x2d, 0x3d, 0xf6, 0xbc, 0x78, 0x5c, 0xa3, 0xc9, 0x57, 0x4b, 0x10, 0x62, 0x68, 0x19, 0x7f, 0xfd, 0x1a, 0xcb, 0x51, + 0x1e, 0x41, 0x39, 0x55, 0xf3, 0x97, 0x30, 0xca, 0x37, 0xb6, 0x42, 0x1d, 0x2d, 0x8c, 0xc6, 0x65, 0x8a, 0xd2, 0x89, + 0x88, 0xa6, 0x28, 0xbd, 0x56, 0x7c, 0x2d, 0x5e, 0x0d, 0x2f, 0x9e, 0xc3, 0xa5, 0x80, 0xaf, 0xcc, 0x00, 0xde, 0xe6, + 0x5a, 0x8b, 0xda, 0xff, 0x1f, 0x16, 0xc8, 0x83, 0x5e, 0xe5, 0xea, 0x25, 0x86, 0x70, 0x55, 0x25, 0x01, 0x14, 0x0c, + 0x77, 0xd8, 0x31, 0x21, 0xcc, 0x79, 0x15, 0x3b, 0x32, 0x3a, 0xd3, 0xc5, 0x30, 0xaf, 0x03, 0xd8, 0x3e, 0x44, 0xb8, + 0x63, 0xb5, 0x74, 0x4f, 0x41, 0x4b, 0xf0, 0x24, 0x74, 0xb2, 0x06, 0xb2, 0x7b, 0x06, 0x60, 0xdc, 0xc1, 0x3e, 0x0e, + 0x6f, 0x1e, 0x3c, 0x42, 0xa0, 0xdb, 0x36, 0x43, 0x30, 0x71, 0xcc, 0xd6, 0x1a, 0xbd, 0x38, 0x61, 0x19, 0x3f, 0xf2, + 0xdf, 0xf4, 0x53, 0x3d, 0xc1, 0x14, 0xbe, 0x50, 0x1c, 0x2c, 0xf3, 0xaa, 0x74, 0x36, 0xcb, 0xbd, 0x7a, 0x4b, 0xa3, + 0x1c, 0x90, 0x40, 0x5b, 0x4a, 0x0f, 0x83, 0x6e, 0x9e, 0x96, 0x28, 0x3d, 0x77, 0x43, 0x05, 0x0e, 0x39, 0x26, 0x15, + 0xb8, 0x6b, 0x4e, 0x3a, 0x62, 0xc2, 0xda, 0xde, 0x8e, 0x29, 0x29, 0x0b, 0x09, 0xa2, 0xb3, 0xa7, 0x1e, 0x9a, 0x0c, + 0x8f, 0xa1, 0x46, 0x6f, 0x92, 0xf3, 0x9e, 0xb5, 0xc5, 0x7e, 0x0e, 0x8d, 0xeb, 0x55, 0x08, 0xfa, 0xc9, 0xd8, 0x4e, + 0xe3, 0xd0, 0xca, 0x2a, 0x96, 0x11, 0x7e, 0xb1, 0xd4, 0x7f, 0x8f, 0x1d, 0xb3, 0xc3, 0xa0, 0x89, 0x6f, 0x93, 0x99, + 0x55, 0x48, 0x97, 0x08, 0x79, 0x66, 0xe9, 0x4a, 0x6b, 0xa0, 0x29, 0xf2, 0x10, 0x1f, 0x22, 0xa2, 0x1b, 0x41, 0xdf, + 0xa3, 0xde, 0x62, 0x60, 0x8e, 0xa1, 0x60, 0xc4, 0xd5, 0xce, 0x81, 0x47, 0x84, 0x3b, 0x66, 0x60, 0x74, 0xa7, 0x74, + 0xcc, 0x48, 0xe0, 0xe1, 0xd5, 0x0c, 0x15, 0x98, 0x3d, 0xa7, 0x9c, 0xb2, 0xec, 0xba, 0x0f, 0x2c, 0x52, 0x14, 0x7b, + 0xe2, 0x49, 0x6e, 0x0f, 0x8c, 0x00, 0xe0, 0x81, 0xf6, 0x57, 0xe4, 0x3f, 0xbf, 0x7c, 0xa9, 0x5e, 0xfe, 0x01, 0xc2, + 0x64, 0xb0, 0x05, 0x60, 0x01, 0xaa, 0x78, 0x65, 0xb2, 0xeb, 0x56, 0x41, 0xf2, 0xbf, 0xa3, 0x45, 0x4e, 0x3c, 0x78, + 0xe2, 0xa1, 0x0d, 0xa9, 0x2a, 0xc0, 0x8a, 0xc0, 0x6f, 0xe4, 0x66, 0xbe, 0x72, 0x35, 0x5e, 0xf7, 0x3b, 0x42, 0x53, + 0xd4, 0xe6, 0x66, 0xb6, 0x78, 0xcd, 0xaa, 0x6f, 0xf4, 0x26, 0x80, 0x3a, 0x4e, 0x74, 0x80, 0x17, 0x88, 0x44, 0x23, + 0xa6, 0x3a, 0x6f, 0x87, 0xb8, 0xd0, 0x4d, 0xd3, 0xfc, 0x7c, 0xd6, 0x38, 0x2a, 0x00, 0x28, 0x01, 0xa2, 0x40, 0x94, + 0x6c, 0x1e, 0x8a, 0xed, 0xe3, 0x92, 0x9d, 0x90, 0xe3, 0x0d, 0x02, 0x4e, 0x15, 0x30, 0xed, 0x8f, 0x5b, 0x99, 0xaa, + 0x7a, 0x4e, 0xb9, 0xec, 0x91, 0xe2, 0x9f, 0xd4, 0xca, 0x46, 0xaf, 0x87, 0x19, 0x4b, 0xad, 0xea, 0xe6, 0x6c, 0x8d, + 0x53, 0x4b, 0x29, 0xee, 0x1e, 0x96, 0xd8, 0x94, 0x30, 0x3a, 0x9c, 0xb0, 0x4c, 0xdb, 0xe2, 0xa1, 0x7f, 0xc7, 0x11, + 0xdd, 0xe3, 0x9d, 0x36, 0x44, 0xd3, 0x93, 0x14, 0x9c, 0x4c, 0x9d, 0xdd, 0x3a, 0x7c, 0x41, 0xb1, 0x8f, 0x14, 0xd9, + 0x4e, 0x61, 0xd9, 0x3a, 0xe3, 0x0d, 0x76, 0xca, 0x6c, 0xac, 0x73, 0xaf, 0xad, 0x94, 0x87, 0x30, 0xf1, 0x30, 0x2f, + 0x8b, 0xed, 0x4a, 0xed, 0xbc, 0xc2, 0xf2, 0x7c, 0x30, 0xa3, 0x0b, 0x28, 0x64, 0x3b, 0x8c, 0xd4, 0xc3, 0x42, 0xb9, + 0xa3, 0x44, 0x51, 0x80, 0x07, 0x5a, 0x3d, 0x14, 0x33, 0x99, 0xbf, 0x2a, 0x6b, 0x2b, 0x19, 0x47, 0x72, 0x9e, 0xd4, + 0xb4, 0x6d, 0x72, 0xdd, 0x8a, 0x4b, 0x33, 0x55, 0xbc, 0xb4, 0xcd, 0xc8, 0x2b, 0x17, 0x2f, 0x74, 0xeb, 0x22, 0x17, + 0x94, 0x08, 0x27, 0x27, 0xc2, 0x5b, 0x17, 0xb4, 0xa9, 0x22, 0x16, 0x9d, 0xd4, 0xfc, 0xc7, 0x15, 0xa3, 0x9b, 0x86, + 0x1f, 0xad, 0x45, 0xd3, 0x87, 0x94, 0x5b, 0x31, 0x36, 0xaa, 0xe4, 0x66, 0x8d, 0xcc, 0x31, 0x05, 0x5b, 0xc4, 0x40, + 0xc0, 0xb8, 0xeb, 0x91, 0x18, 0x22, 0x8c, 0x31, 0x1e, 0xad, 0xd0, 0x3a, 0x98, 0x07, 0xb5, 0x6f, 0x11, 0xba, 0x11, + 0xa6, 0x14, 0x35, 0x5a, 0xe7, 0x55, 0xdf, 0xb7, 0x4c, 0x03, 0x61, 0xa3, 0x74, 0x23, 0xdf, 0x55, 0x1f, 0x02, 0x51, + 0x09, 0xb7, 0xba, 0xd5, 0x0c, 0x67, 0xab, 0x98, 0x70, 0x14, 0x64, 0x8d, 0xf4, 0x8b, 0x54, 0x44, 0x07, 0x6f, 0xe0, + 0x69, 0x32, 0xca, 0x48, 0xe5, 0xd3, 0xa7, 0x17, 0x8f, 0x45, 0x84, 0x04, 0xb7, 0xd1, 0xbb, 0xe1, 0xf6, 0x01, 0x0a, + 0xf6, 0xee, 0x2b, 0x32, 0xd2, 0xc5, 0xf8, 0xa6, 0xec, 0x0f, 0x1b, 0x09, 0x1d, 0xfc, 0xa2, 0xbf, 0x54, 0x5d, 0x2c, + 0x62, 0xf4, 0x77, 0xde, 0xad, 0xa0, 0x50, 0x6a, 0xb4, 0xe3, 0x5f, 0xda, 0xff, 0x6b, 0xb1, 0x78, 0xf7, 0xf9, 0xc1, + 0xa6, 0xa8, 0x93, 0xe8, 0xe4, 0x11, 0x56, 0xa0, 0x5b, 0x85, 0xa7, 0x92, 0x7a, 0x58, 0x45, 0x95, 0xa9, 0x63, 0x83, + 0xb4, 0x1f, 0x18, 0x31, 0x7a, 0x6d, 0xa1, 0x8d, 0x8c, 0xdc, 0x91, 0x02, 0x3c, 0x9c, 0x92, 0x42, 0x8e, 0x03, 0x02, + 0xc5, 0x0c, 0x43, 0x54, 0xf9, 0xb2, 0x85, 0x39, 0x2e, 0x77, 0xad, 0x00}; // Backwards compatibility alias #define INDEX_GZ INDEX_BR diff --git a/esphome/components/captive_portal/captive_portal.cpp b/esphome/components/captive_portal/captive_portal.cpp index 18fb08da8b..f7c08aec4b 100644 --- a/esphome/components/captive_portal/captive_portal.cpp +++ b/esphome/components/captive_portal/captive_portal.cpp @@ -6,6 +6,9 @@ #include "esphome/core/string_ref.h" #include "esphome/components/wifi/scan_list.h" #include "esphome/components/wifi/wifi_component.h" +#ifdef USE_PROVISIONING +#include "esphome/components/provisioning/provisioning.h" +#endif #include "captive_index.h" namespace esphome::captive_portal { @@ -78,6 +81,20 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) { void CaptivePortal::setup() { // Disable loop by default - will be enabled when captive portal starts this->disable_loop(); +#ifdef USE_PROVISIONING + // The captive portal is a provisioning surface: once the provisioning window + // has closed, stop serving it. WiFi's own closed-callback shuts down the + // access point the portal runs on, and the gated fallback in WiFiComponent's + // loop() ensures neither is started again afterwards. + if (provisioning::global_provisioning_manager != nullptr) { + provisioning::global_provisioning_manager->add_on_closed_callback([this]() { + if (this->active_) { + ESP_LOGD(TAG, "Provisioning window closed; stopping captive portal"); + this->end(); + } + }); + } +#endif } void CaptivePortal::start() { this->base_->init(); diff --git a/esphome/components/climate/climate.cpp b/esphome/components/climate/climate.cpp index 6ca9e394f7..34684a87e1 100644 --- a/esphome/components/climate/climate.cpp +++ b/esphome/components/climate/climate.cpp @@ -749,33 +749,39 @@ void Climate::dump_traits_(const char *tag) { } if (!traits.get_supported_modes().empty()) { ESP_LOGCONFIG(tag, " Supported modes:"); - for (ClimateMode m : traits.get_supported_modes()) + for (ClimateMode m : traits.get_supported_modes()) { ESP_LOGCONFIG(tag, " - %s", LOG_STR_ARG(climate_mode_to_string(m))); + } } if (!traits.get_supported_fan_modes().empty()) { ESP_LOGCONFIG(tag, " Supported fan modes:"); - for (ClimateFanMode m : traits.get_supported_fan_modes()) + for (ClimateFanMode m : traits.get_supported_fan_modes()) { ESP_LOGCONFIG(tag, " - %s", LOG_STR_ARG(climate_fan_mode_to_string(m))); + } } if (!traits.get_supported_custom_fan_modes().empty()) { ESP_LOGCONFIG(tag, " Supported custom fan modes:"); - for (const char *s : traits.get_supported_custom_fan_modes()) + for (const char *s : traits.get_supported_custom_fan_modes()) { ESP_LOGCONFIG(tag, " - %s", s); + } } if (!traits.get_supported_presets().empty()) { ESP_LOGCONFIG(tag, " Supported presets:"); - for (ClimatePreset p : traits.get_supported_presets()) + for (ClimatePreset p : traits.get_supported_presets()) { ESP_LOGCONFIG(tag, " - %s", LOG_STR_ARG(climate_preset_to_string(p))); + } } if (!traits.get_supported_custom_presets().empty()) { ESP_LOGCONFIG(tag, " Supported custom presets:"); - for (const char *s : traits.get_supported_custom_presets()) + for (const char *s : traits.get_supported_custom_presets()) { ESP_LOGCONFIG(tag, " - %s", s); + } } if (!traits.get_supported_swing_modes().empty()) { ESP_LOGCONFIG(tag, " Supported swing modes:"); - for (ClimateSwingMode m : traits.get_supported_swing_modes()) + for (ClimateSwingMode m : traits.get_supported_swing_modes()) { ESP_LOGCONFIG(tag, " - %s", LOG_STR_ARG(climate_swing_mode_to_string(m))); + } } } diff --git a/esphome/components/const/__init__.py b/esphome/components/const/__init__.py index 10710c8d29..49a625e3f1 100644 --- a/esphome/components/const/__init__.py +++ b/esphome/components/const/__init__.py @@ -14,8 +14,10 @@ CONF_CHANNEL_COLORS = "channel_colors" CONF_CLIMATE_ID = "climate_id" CONF_CO2_EQUIVALENT = "co2_equivalent" CONF_COLOR_DEPTH = "color_depth" +CONF_COLUMNS = "columns" CONF_CRC_ENABLE = "crc_enable" CONF_DATA_BITS = "data_bits" +CONF_DESCRIPTION = "description" CONF_DRAW_ROUNDING = "draw_rounding" CONF_ENABLE_OTA_DOWNGRADE_PROTECTION = "enable_ota_downgrade_protection" CONF_ENABLED = "enabled" @@ -24,6 +26,7 @@ CONF_GYROSCOPE_RANGE = "gyroscope_range" CONF_IAQ = "iaq" CONF_IGNORE_NOT_FOUND = "ignore_not_found" CONF_IS_WRGB = "is_wrgb" +CONF_KEYS = "keys" CONF_LABEL = "label" CONF_LIBRETINY = "libretiny" CONF_LOOP = "loop" diff --git a/esphome/components/cs5460a/cs5460a.cpp b/esphome/components/cs5460a/cs5460a.cpp index c9e8f3cf47..1f9233841a 100644 --- a/esphome/components/cs5460a/cs5460a.cpp +++ b/esphome/components/cs5460a/cs5460a.cpp @@ -249,7 +249,7 @@ bool CS5460AComponent::check_status_() { bool dir = status & (1 << 21); if (current_gain_ < 0) dir = !dir; - ESP_LOGI(TAG, "Energy counter %s pulse", dir ? "negative" : "positive"); + ESP_LOGI(TAG, "Energy counter %s pulse", dir ? LOG_STR_LITERAL("negative") : LOG_STR_LITERAL("positive")); clear |= 1 << 22; } @@ -319,7 +319,9 @@ void CS5460AComponent::dump_config() { ESP_LOGCONFIG(TAG, "CS5460A:\n" " Init status: %s", - state == COMPONENT_STATE_LOOP ? "OK" : (state == COMPONENT_STATE_FAILED ? "failed" : "other")); + state == COMPONENT_STATE_LOOP + ? LOG_STR_LITERAL("OK") + : (state == COMPONENT_STATE_FAILED ? LOG_STR_LITERAL("failed") : LOG_STR_LITERAL("other"))); LOG_PIN(" CS Pin: ", cs_); ESP_LOGCONFIG(TAG, " Samples / cycle: %" PRIu32 "\n" @@ -330,9 +332,10 @@ void CS5460AComponent::dump_config() { " Current HPF: %s\n" " Voltage HPF: %s\n" " Pulse energy: %.2f Wh", - samples_, phase_offset_, pga_gain_ == CS5460A_PGA_GAIN_50X ? "50x" : "10x", current_gain_, - voltage_gain_, current_hpf_ ? "enabled" : "disabled", voltage_hpf_ ? "enabled" : "disabled", - pulse_energy_wh_); + samples_, phase_offset_, + pga_gain_ == CS5460A_PGA_GAIN_50X ? LOG_STR_LITERAL("50x") : LOG_STR_LITERAL("10x"), current_gain_, + voltage_gain_, current_hpf_ ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled"), + voltage_hpf_ ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled"), pulse_energy_wh_); LOG_SENSOR(" ", "Voltage", voltage_sensor_); LOG_SENSOR(" ", "Current", current_sensor_); LOG_SENSOR(" ", "Power", power_sensor_); diff --git a/esphome/components/d01/__init__.py b/esphome/components/d01/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/esphome/components/d01/d01.cpp b/esphome/components/d01/d01.cpp new file mode 100644 index 0000000000..f7a0c08ec4 --- /dev/null +++ b/esphome/components/d01/d01.cpp @@ -0,0 +1,45 @@ +#include "d01.h" +#include "esphome/core/log.h" + +// uart specification for d01 sensor from https://manuals.plus/ae/1005006417362019: +// +// A frame of serial output data includes 4 bytes, formatted as follows: +// __Characteristic byte: Fixed value 0xA5. +// __Data byte: DATAH is the high 7 bits of the concentration value, and DATAL is the low 7 bits of the concentration +// value. +// __Check byte: The low 7 bits of the sum of all bytes before the check byte. +// +// If the serial output is 4 bytes of data: 0*A5 0*01 0*2C 0*52, then DATAH = 0*01 = 1, DATAL = 0*2C = 44. +// Concentration value = 1*128 + 44 = 172 µg/m³. +// +// The PM2.5 dust concentration value obtained from the dust sensor needs to be calibrated with a K value coefficient +// based on the TSI instrument's photometric method. It is generally recommended to use 0.4. + +namespace esphome::d01 { + +static const char *const TAG = "d01"; + +static const uint8_t D01_FRAME_HEADER = 0xA5; + +void D01SensorComponent::dump_config() { LOG_SENSOR(" ", "D01 PM2.5", this); } + +void D01SensorComponent::loop() { + uint8_t buf[4]; + while (this->available() >= 4) { + if (this->peek() != D01_FRAME_HEADER) { + this->read(); + continue; + } + this->read_array(buf, 4); + uint8_t sum = (buf[0] + buf[1] + buf[2]) & 0x7F; + if (sum != buf[3]) { + ESP_LOGW(TAG, "checksum mismatch"); + continue; + } + uint16_t latest_concentration = (buf[1] & 0x7F) * 128 + (buf[2] & 0x7F); + ESP_LOGV(TAG, "Unadjusted PM2.5 Concentration: %d µg/m³", latest_concentration); + this->publish_state(latest_concentration); + } +} + +} // namespace esphome::d01 diff --git a/esphome/components/d01/d01.h b/esphome/components/d01/d01.h new file mode 100644 index 0000000000..73c7a8711d --- /dev/null +++ b/esphome/components/d01/d01.h @@ -0,0 +1,14 @@ +#pragma once +#include "esphome/core/component.h" +#include "esphome/components/sensor/sensor.h" +#include "esphome/components/uart/uart.h" + +namespace esphome::d01 { + +class D01SensorComponent final : public sensor::Sensor, public Component, public uart::UARTDevice { + public: + void dump_config() override; + void loop() override; +}; + +} // namespace esphome::d01 diff --git a/esphome/components/d01/sensor.py b/esphome/components/d01/sensor.py new file mode 100644 index 0000000000..5bc5a4e424 --- /dev/null +++ b/esphome/components/d01/sensor.py @@ -0,0 +1,45 @@ +import esphome.codegen as cg +from esphome.components import sensor, uart +import esphome.config_validation as cv +from esphome.const import ( + DEVICE_CLASS_PM25, + ICON_BLUR, + STATE_CLASS_MEASUREMENT, + UNIT_MICROGRAMS_PER_CUBIC_METER, +) +from esphome.types import ConfigType + +CODEOWNERS = ["@ch604"] +DEPENDENCIES = ["uart"] + +d01_ns = cg.esphome_ns.namespace("d01") +D01SensorComponent = d01_ns.class_( + "D01SensorComponent", sensor.Sensor, uart.UARTDevice, cg.Component +) + + +CONFIG_SCHEMA = ( + sensor.sensor_schema( + D01SensorComponent, + unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER, + icon=ICON_BLUR, + accuracy_decimals=0, + device_class=DEVICE_CLASS_PM25, + state_class=STATE_CLASS_MEASUREMENT, + ) + .extend(cv.COMPONENT_SCHEMA) + .extend(uart.UART_DEVICE_SCHEMA) +) + +FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema( + "d01", + baud_rate=9600, + require_rx=True, + require_tx=False, +) + + +async def to_code(config: ConfigType) -> None: + var = await sensor.new_sensor(config) + await cg.register_component(var, config) + await uart.register_uart_device(var, config) diff --git a/esphome/components/dht/dht.cpp b/esphome/components/dht/dht.cpp index 5b7b6a268f..2196f3a982 100644 --- a/esphome/components/dht/dht.cpp +++ b/esphome/components/dht/dht.cpp @@ -20,8 +20,8 @@ void DHT::dump_config() { "DHT:\n" " %sModel: %s\n" " Internal pull-up: %s", - this->is_auto_detect_ ? "Auto-detected " : "", - this->model_ == DHT_MODEL_DHT11 ? "DHT11" : "DHT22 or equivalent", + this->is_auto_detect_ ? LOG_STR_LITERAL("Auto-detected ") : "", + this->model_ == DHT_MODEL_DHT11 ? LOG_STR_LITERAL("DHT11") : LOG_STR_LITERAL("DHT22 or equivalent"), ONOFF(this->t_pin_->get_flags() & gpio::FLAG_PULLUP)); LOG_PIN(" Pin: ", this->t_pin_); LOG_UPDATE_INTERVAL(this); @@ -154,8 +154,9 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r } } if (error_code != 0) { - if (report_errors) + if (report_errors) { ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL); + } return false; } diff --git a/esphome/components/ds1603l/__init__.py b/esphome/components/ds1603l/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/esphome/components/ds1603l/ds1603l.cpp b/esphome/components/ds1603l/ds1603l.cpp new file mode 100644 index 0000000000..b0b0ef8175 --- /dev/null +++ b/esphome/components/ds1603l/ds1603l.cpp @@ -0,0 +1,68 @@ +#include "ds1603l.h" + +#include + +#include "esphome/core/helpers.h" +#include "esphome/core/log.h" + +namespace esphome::ds1603l { + +static const char *const TAG = "ds1603l.sensor"; + +void DS1603L::loop() { + // Assemble frames one byte at a time so a stream that starts mid-frame can realign + uint8_t byte; + while (this->available() > 0 && this->read_byte(&byte)) { + if (this->rx_count_ == 0 && byte != HEADER_BYTE) { + ESP_LOGV(TAG, "Skipping byte 0x%02X while looking for header", byte); + continue; + } + + this->rx_buffer_[this->rx_count_++] = byte; + if (this->rx_count_ < FRAME_SIZE) { + continue; + } + + if (this->parse_data_()) { + this->rx_count_ = 0; + } else { + // The header byte was part of the payload of a misaligned frame, so realign instead of dropping everything + this->resync_(); + } + } +} + +void DS1603L::dump_config() { LOG_SENSOR("", "DS1603L", this); } + +bool DS1603L::parse_data_() { + uint8_t header = this->rx_buffer_[0]; + uint8_t data_h = this->rx_buffer_[1]; + uint8_t data_l = this->rx_buffer_[2]; + uint8_t checksum = this->rx_buffer_[3]; + + uint8_t computed_checksum = (header + data_h + data_l) & 0xFF; + + ESP_LOGV(TAG, "Data: Header=0x%02X, Data_H=0x%02X, Data_L=0x%02X, Checksum=0x%02X", header, data_h, data_l, checksum); + + if (checksum != computed_checksum) { + ESP_LOGW(TAG, "Checksum mismatch: received 0x%02X, expected 0x%02X", checksum, computed_checksum); + return false; + } + + this->publish_state(encode_uint16(data_h, data_l)); + return true; +} + +void DS1603L::resync_() { + // Drop the byte that was treated as the header, then look for the next candidate header in what is left + size_t start = 1; + while (start < this->rx_count_ && this->rx_buffer_[start] != HEADER_BYTE) { + start++; + } + this->rx_count_ -= start; + if (this->rx_count_ > 0) { + memmove(this->rx_buffer_, this->rx_buffer_ + start, this->rx_count_); + } +} + +} // namespace esphome::ds1603l diff --git a/esphome/components/ds1603l/ds1603l.h b/esphome/components/ds1603l/ds1603l.h new file mode 100644 index 0000000000..9041681f5e --- /dev/null +++ b/esphome/components/ds1603l/ds1603l.h @@ -0,0 +1,30 @@ +#pragma once + +#include +#include + +#include "esphome/components/sensor/sensor.h" +#include "esphome/components/uart/uart.h" +#include "esphome/core/component.h" + +namespace esphome::ds1603l { + +class DS1603L final : public sensor::Sensor, public Component, public uart::UARTDevice { + public: + void loop() override; + void dump_config() override; + + protected: + static constexpr uint8_t HEADER_BYTE = 0xFF; + static constexpr size_t FRAME_SIZE = 4; + + // Validates the checksum of the frame in rx_buffer_ and publishes it. Returns false if the frame is invalid. + bool parse_data_(); + // Drops the first buffered byte and realigns the buffer on the next possible header byte. + void resync_(); + + uint8_t rx_buffer_[FRAME_SIZE]; // Buffer for the frame being assembled + size_t rx_count_{0}; // Number of bytes currently in rx_buffer_ +}; + +} // namespace esphome::ds1603l diff --git a/esphome/components/ds1603l/sensor.py b/esphome/components/ds1603l/sensor.py new file mode 100644 index 0000000000..c4f117c603 --- /dev/null +++ b/esphome/components/ds1603l/sensor.py @@ -0,0 +1,43 @@ +import esphome.codegen as cg +from esphome.components import sensor, uart +import esphome.config_validation as cv +from esphome.const import ( + DEVICE_CLASS_DISTANCE, + STATE_CLASS_MEASUREMENT, + UNIT_MILLIMETER, +) +from esphome.types import ConfigType + +CODEOWNERS = ["@JakeLC15"] +DEPENDENCIES = ["uart"] + +ds1603l_ns = cg.esphome_ns.namespace("ds1603l") +DS1603L = ds1603l_ns.class_("DS1603L", sensor.Sensor, cg.Component, uart.UARTDevice) + + +CONFIG_SCHEMA = ( + sensor.sensor_schema( + DS1603L, + unit_of_measurement=UNIT_MILLIMETER, + accuracy_decimals=0, + device_class=DEVICE_CLASS_DISTANCE, + state_class=STATE_CLASS_MEASUREMENT, + ) + .extend(uart.UART_DEVICE_SCHEMA) + .extend(cv.COMPONENT_SCHEMA) +) + +FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema( + "ds1603l", + baud_rate=9600, + require_tx=False, + require_rx=True, + data_bits=8, + stop_bits=1, +) + + +async def to_code(config: ConfigType) -> None: + var = await sensor.new_sensor(config) + await cg.register_component(var, config) + await uart.register_uart_device(var, config) diff --git a/esphome/components/emc2101/emc2101.cpp b/esphome/components/emc2101/emc2101.cpp index f46082f5e7..bb041bfd6d 100644 --- a/esphome/components/emc2101/emc2101.cpp +++ b/esphome/components/emc2101/emc2101.cpp @@ -93,7 +93,7 @@ void Emc2101Component::dump_config() { if (this->is_failed()) { ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL); } - ESP_LOGCONFIG(TAG, " Mode: %s", this->dac_mode_ ? "DAC" : "PWM"); + ESP_LOGCONFIG(TAG, " Mode: %s", this->dac_mode_ ? LOG_STR_LITERAL("DAC") : LOG_STR_LITERAL("PWM")); if (this->dac_mode_) { ESP_LOGCONFIG(TAG, " DAC Conversion Rate: %X", this->dac_conversion_rate_); } else { diff --git a/esphome/components/ens210/ens210.cpp b/esphome/components/ens210/ens210.cpp index 468c627d4b..11b73afe37 100644 --- a/esphome/components/ens210/ens210.cpp +++ b/esphome/components/ens210/ens210.cpp @@ -216,7 +216,7 @@ void ENS210Component::extract_measurement_(uint32_t val, int *data, int *status) // Sets ENS210 to low (true) or high (false) power. Returns false on I2C problems. bool ENS210Component::set_low_power_(bool enable) { uint8_t low_power_cmd = enable ? 0x01 : 0x00; - ESP_LOGD(TAG, "Enable low power: %s", enable ? "true" : "false"); + ESP_LOGD(TAG, "Enable low power: %s", enable ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false")); bool result = this->write_byte(ENS210_REGISTER_SYS_CTRL, low_power_cmd); delay(ENS210_BOOTING_MS); return result; diff --git a/esphome/components/epaper_spi/epaper_spi_uc8179.cpp b/esphome/components/epaper_spi/epaper_spi_uc8179.cpp new file mode 100644 index 0000000000..2a4ff2969a --- /dev/null +++ b/esphome/components/epaper_spi/epaper_spi_uc8179.cpp @@ -0,0 +1,139 @@ +#include "epaper_spi_uc8179.h" + +#include + +#include "esphome/core/log.h" + +namespace esphome::epaper_spi { + +static constexpr const char *const TAG = "epaper_spi.uc8179"; + +bool EPaperUC8179::initialise(bool partial) { + EPaperBase::initialise(partial); // send the model init sequence + this->partial_ = partial; + ESP_LOGV(TAG, "Power on"); + // POWER ON must precede the waveform/mode registers and the data transfer + // (the original driver powers on and busy-waits before writing them). + // The state machine busy-waits before entering TRANSFER_DATA. + this->command(0x04); + // Give the busy line time to assert before the state machine polls it + this->next_delay_ = 100; + return true; +} + +// Set up the refresh mode. Must be called after power-on has completed. +void EPaperUC8179::set_refresh_mode_() { + if (!this->is_using_partial_update_()) { + return; // plain full refresh uses the mode set by the init sequence + } + // Fast and partial refresh use flipped data polarity and a floating border + this->cmd_data(0x50, {0xA9, 0x07}); + // Force the waveform via the temperature registers: 0x5A selects the fast + // full-refresh waveform, 0x6E the partial-refresh waveform + this->cmd_data(0xE0, {0x02}); + if (this->partial_) { + this->cmd_data(0xE5, {0x6E}); + this->command(0x91); // enter partial mode + // Set the partial window to the full screen + const uint16_t x_end = this->width_ - 1; + const uint16_t y_end = this->height_ - 1; + this->cmd_data(0x90, {0x00, 0x00, static_cast(x_end >> 8), static_cast(x_end & 0xFF), 0x00, 0x00, + static_cast(y_end >> 8), static_cast(y_end & 0xFF), 0x01}); + } else { + this->cmd_data(0xE5, {0x5A}); + this->command(0x92); // exit partial mode + } +} + +bool HOT EPaperUC8179::transfer_data() { + const uint32_t start_time = millis(); + const size_t buffer_length = this->buffer_length_; + if (this->current_data_index_ == 0) { + this->set_refresh_mode_(); + } + // Fast full refresh sends the previous-image plane as well, so that every pixel transitions + const bool two_pass = this->is_using_partial_update_() && !this->partial_; + // Plain full refresh sends inverted data (buffer is 1=white, the wire wants 0=white); + // in fast/partial mode the data polarity is flipped via the VCOM/data-interval + // register instead, so the new-image plane is sent unmodified + const bool invert_new_data = !this->is_using_partial_update_(); + + uint8_t bytes_to_send[MAX_TRANSFER_SIZE]; + + // Phase 1 (fast full refresh only): previous image via 0x10 (DTM1), inverse of the new image + if (two_pass && this->current_data_index_ < buffer_length) { + if (this->current_data_index_ == 0) { + this->command(0x10); // DATA START TRANSMISSION 1 (previous image) + } + this->start_data_(); + while (this->current_data_index_ < buffer_length) { + const size_t bytes_to_copy = std::min(MAX_TRANSFER_SIZE, buffer_length - this->current_data_index_); + for (size_t i = 0; i < bytes_to_copy; i++) { + bytes_to_send[i] = ~this->buffer_[this->current_data_index_ + i]; + } + this->write_array(bytes_to_send, bytes_to_copy); + this->current_data_index_ += bytes_to_copy; + if (millis() - start_time > MAX_TRANSFER_TIME) { + this->disable(); + return false; + } + } + this->disable(); + } + + // Phase 2: new image via 0x13 (DTM2) + const size_t offset = two_pass ? buffer_length : 0; + const size_t total = offset + buffer_length; + if (this->current_data_index_ < total) { + if (this->current_data_index_ == offset) { + this->command(0x13); // DATA START TRANSMISSION 2 (new image) + } + this->start_data_(); + while (this->current_data_index_ < total) { + const size_t bytes_to_copy = std::min(MAX_TRANSFER_SIZE, total - this->current_data_index_); + const size_t data_idx = this->current_data_index_ - offset; + for (size_t i = 0; i < bytes_to_copy; i++) { + const uint8_t byte = this->buffer_[data_idx + i]; + bytes_to_send[i] = invert_new_data ? ~byte : byte; + } + this->write_array(bytes_to_send, bytes_to_copy); + this->current_data_index_ += bytes_to_copy; + if (millis() - start_time > MAX_TRANSFER_TIME) { + this->disable(); + return false; + } + } + this->disable(); + } + + this->current_data_index_ = 0; + return true; +} + +void EPaperUC8179::power_on() { + // Power-on is sent at the end of initialise() instead, because the + // waveform/mode registers and the data transfer must follow it +} + +void EPaperUC8179::refresh_screen(bool /*partial*/) { + ESP_LOGV(TAG, "Refresh"); + this->command(0x12); // DISPLAY REFRESH + // Delay the next busy poll: the busy line takes a short time to assert after + // the refresh command, and polling too early would read it as already idle + this->next_delay_ = 100; +} + +void EPaperUC8179::power_off() { + ESP_LOGV(TAG, "Power off"); + this->command(0x02); // POWER OFF +} + +void EPaperUC8179::deep_sleep() { + // Deep sleep loses the previous-image RAM that partial refresh compares against + if (!this->is_using_partial_update_()) { + ESP_LOGV(TAG, "Deep sleep"); + this->cmd_data(0x07, {0xA5}); // DEEP SLEEP with check code + } +} + +} // namespace esphome::epaper_spi diff --git a/esphome/components/epaper_spi/epaper_spi_uc8179.h b/esphome/components/epaper_spi/epaper_spi_uc8179.h new file mode 100644 index 0000000000..85c0eb623e --- /dev/null +++ b/esphome/components/epaper_spi/epaper_spi_uc8179.h @@ -0,0 +1,52 @@ +#pragma once + +#include "epaper_spi.h" + +namespace esphome::epaper_spi { + +/** + * Monochrome e-paper displays using the UC8179 controller. + * Supports: 7.5" V2 (EPD_7in5_V2), 800x480 pixels, as used by the + * Waveshare 7.5" V2 HAT and the Seeed reTerminal E1001. + * + * Buffer layout: 1 bit per pixel, 1=white, 0=black (the base class default). + * + * The INITIALISE state sends the panel configuration followed by power-on + * (0x04); the state machine busy-waits for power-on to complete before + * TRANSFER_DATA, which first writes the waveform/mode registers (these are + * only accepted while powered) and then the image data. The state machine + * busy-waits again before triggering REFRESH_SCREEN (0x12). + * + * Three refresh modes are used, following the Waveshare EPD_7in5_V2 examples: + * - full_update_every == 1: plain full refresh. The new image is sent + * inverted to DTM2 (0x13) and the controller uses its normal waveform. + * - full_update_every > 1, full update: fast full refresh. The data polarity + * is flipped via the VCOM/data-interval register, a fast waveform is forced + * via the temperature registers, and the image is sent to both DTM1 (0x10, + * inverted) and DTM2 (0x13) so that every pixel transitions. + * - full_update_every > 1, partial update: partial refresh. A partial-update + * waveform is forced, partial mode is entered with a full-screen window and + * only DTM2 is sent; the controller compares against its previous-image RAM. + */ +class EPaperUC8179 final : public EPaperBase { + public: + EPaperUC8179(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence, + size_t init_sequence_length) + : EPaperBase(name, width, height, init_sequence, init_sequence_length, DISPLAY_TYPE_BINARY) { + this->buffer_length_ = this->row_width_ * height; + } + + protected: + bool initialise(bool partial) override; + bool transfer_data() override; + void refresh_screen(bool partial) override; + void power_on() override; + void power_off() override; + void deep_sleep() override; + void set_refresh_mode_(); + + // Set by initialise() so transfer_data() knows which planes to send + bool partial_{}; +}; + +} // namespace esphome::epaper_spi diff --git a/esphome/components/epaper_spi/models/uc8179.py b/esphome/components/epaper_spi/models/uc8179.py new file mode 100644 index 0000000000..bea133c328 --- /dev/null +++ b/esphome/components/epaper_spi/models/uc8179.py @@ -0,0 +1,93 @@ +"""Monochrome e-paper displays using the UC8179 controller. + +Supported models: +- waveshare-7.5in-v2: 7.5" mono display, 800x480 pixels (EPD_7in5_V2) +- seeed-reterminal-e1001: Seeed reTerminal E1001, which uses the same + 7.5" 800x480 panel on an integrated ESP32-S3 board + +Panel configuration and power-on (0x04) are both sent during the INITIALISE +state; the state machine's built-in busy wait then covers the power-on delay +before the waveform/mode registers and image data are transferred. + +These displays support fast full and partial refresh: set ``full_update_every`` +greater than 1 to enable it. Every ``full_update_every``-th update is a fast +full refresh, with partial refreshes in between. +""" + +from typing import Any + +from esphome.const import CONF_DATA_RATE + +from . import EpaperModel + + +class UC8179(EpaperModel): + """EpaperModel class for monochrome displays using the UC8179 controller.""" + + def __init__( + self, + name: str, + class_name: str = "EPaperUC8179", + data_rate: str = "10MHz", + **defaults: Any, + ) -> None: + defaults.setdefault(CONF_DATA_RATE, data_rate) + super().__init__(name, class_name, **defaults) + + def get_init_sequence(self, config: dict) -> tuple: + """Generate the initialization sequence for UC8179 mono displays. + + Panel configuration only — the driver appends power-on (0x04) at the + end of the INITIALISE state, and the state machine busy-waits for it + to complete before the data transfer starts. + """ + width, height = self.get_dimensions(config) + return ( + # POWER SETTING + (0x01, 0x07, 0x07, 0x3F, 0x3F), + # BOOSTER SOFT START + (0x06, 0x17, 0x17, 0x28, 0x17), + # PANEL SETTING (black/white mode, LUT from OTP) + (0x00, 0x1F), + # RESOLUTION SETTING (width x height) + ( + 0x61, + (width >> 8) & 0xFF, + width & 0xFF, + (height >> 8) & 0xFF, + height & 0xFF, + ), + # DUAL SPI MODE (disabled) + (0x15, 0x00), + # VCOM AND DATA INTERVAL SETTING + (0x50, 0x10, 0x07), + # TCON SETTING + (0x60, 0x22), + ) + + +uc8179 = UC8179("uc8179") + +# Waveshare 7.5" V2 mono (EPD_7in5_V2) — 800x480, UC8179 controller +waveshare_7_5_v2 = uc8179.extend( + "waveshare-7.5in-v2", + width=800, + height=480, +) + +# Seeed reTerminal E1001 — 7.5" mono e-paper (800x480), same panel as the +# Waveshare 7.5" V2, driven by an integrated ESP32-S3 board +waveshare_7_5_v2.extend( + "seeed-reterminal-e1001", + cs_pin=10, + dc_pin=11, + reset_pin=12, + busy_pin={ + "number": 13, + "inverted": True, + "mode": { + "input": True, + "pullup": True, + }, + }, +) diff --git a/esphome/components/esp32/__init__.py b/esphome/components/esp32/__init__.py index bc91f29a42..3f5a34bc73 100644 --- a/esphome/components/esp32/__init__.py +++ b/esphome/components/esp32/__init__.py @@ -182,6 +182,13 @@ SIGNED_OTA_V1_ECDSA_VARIANTS = { VARIANT_ESP32, } +# Variants that support execution from PSRAM +PSRAM_XIP_VARIANTS = { + VARIANT_ESP32S3, + VARIANT_ESP32P4, + VARIANT_ESP32S31, +} + # NVS encryption (HMAC peripheral scheme) is only available on variants that # expose the HMAC peripheral (SOC_HMAC_SUPPORTED in soc_caps.h). The original # ESP32 and ESP32-C2 do not have it. New variants with an HMAC peripheral @@ -214,11 +221,13 @@ COMPILER_OPTIMIZATIONS = { # builds that need them. DEFAULT_EXCLUDED_IDF_COMPONENTS = ( "app_trace", # CPU trace/SystemView support - unused by ESPHome + "bt", # Bluetooth stack - re-included by request_bluetooth(); its REQUIRES pulls the WiFi stack back "cmock", # Unit testing mock framework - ESPHome doesn't use IDF's testing "console", # Console REPL - unused by ESPHome; espressif/mdns pulls it back when configured "driver", # Legacy driver shim - only needed by esp32_touch, esp32_can for legacy headers "esp-tls", # TLS wrapper - re-included by http_request, mqtt, web_server_idf "esp_adc", # ADC driver - only needed by adc component + "esp_coex", # WiFi/BT coexistence - re-included by esp32_ble_tracker, zigbee; esp_wifi/bt pull it back "esp_driver_cam", # Camera driver - the esp32-camera managed component pulls it back "esp_driver_dac", # DAC driver - only needed by esp32_dac component "esp_driver_gptimer", # General purpose timer - re-included by ac_dimmer, opentherm, Arduino BLE libs @@ -236,6 +245,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = ( "esp_driver_twai", # TWAI/CAN driver - only needed by esp32_can component "esp_eth", # Ethernet driver - only needed by ethernet component "esp_gdbstub", # GDB stub panic handler - unused by ESPHome; bt pulls it back + "esp_hal_ieee802154", # 802.15.4 HAL - ieee802154 pulls it back "esp_hid", # HID host/device support - ESPHome doesn't implement HID functionality "esp_http_client", # HTTP client - only needed by http_request component "esp_http_server", # HTTP server - re-included by web_server_idf, esp32_camera_web_server @@ -243,8 +253,11 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = ( "esp_https_server", # HTTPS server - ESPHome has its own web server "esp_lcd", # LCD controller drivers - only needed by display component "esp_local_ctrl", # Local control over HTTPS/BLE - ESPHome has native API + "esp_phy", # RF PHY - re-included by internal_temperature on the original ESP32; esp_wifi/bt/ieee802154 pull it back + "esp_wifi", # WiFi stack - re-included by request_wifi(), espnow; bt pulls it back for BLE builds "espcoredump", # Core dump support - ESPHome has its own debug component "fatfs", # FAT filesystem - ESPHome doesn't use filesystem storage + "ieee802154", # 802.15.4 radio - IDF openthread and the Zigbee libs pull it back "json", # cJSON library - ESPHome uses ArduinoJson instead "mqtt", # ESP-IDF MQTT library - ESPHome has its own MQTT implementation "nvs_sec_provider", # NVS encryption key provider - re-included when CONFIG_NVS_ENCRYPTION is set @@ -260,6 +273,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = ( "unity", # Unit testing framework - ESPHome doesn't use IDF's testing "wear_levelling", # Flash wear levelling for fatfs - unused since fatfs unused "wifi_provisioning", # WiFi provisioning - ESPHome uses its own improv implementation + "wpa_supplicant", # WPA supplicant - re-included by request_wifi() for esp_eap_client.h ) # Additional IDF managed components to exclude for Arduino framework builds @@ -709,6 +723,9 @@ def request_wifi(ap: bool = False) -> None: net.wifi = True if ap: net.wifi_ap = True + include_builtin_idf_component("esp_wifi") + # wifi_component.cpp includes esp_eap_client.h/esp_wpa2.h + include_builtin_idf_component("wpa_supplicant") def request_ethernet() -> None: @@ -720,11 +737,14 @@ def request_bluetooth() -> None: """Request the Bluetooth controller.""" net = _network_sdkconfig() net.bluetooth = True + include_builtin_idf_component("bt") def request_software_coexistence() -> None: """Request WiFi/BT software coexistence (only valid alongside WiFi).""" _network_sdkconfig().software_coexistence = True + # Callers include esp_coexist.h directly. + include_builtin_idf_component("esp_coex") def add_idf_component( @@ -1510,7 +1530,7 @@ def final_validate(config) -> None: ) ) if advanced[CONF_EXECUTE_FROM_PSRAM]: - if config[CONF_VARIANT] not in {VARIANT_ESP32S3, VARIANT_ESP32P4}: + if config[CONF_VARIANT] not in PSRAM_XIP_VARIANTS: errs.append( cv.Invalid( f"'{CONF_EXECUTE_FROM_PSRAM}' is not available on this esp32 variant", @@ -2304,6 +2324,8 @@ async def _reconcile_network_sdkconfig() -> None: # WiFi stack: disable only when Ethernet is present and WiFi is not. WiFi # relies on the IDF default (enabled), so it is never written True here. + # esp_wifi is excluded by default on IDF, so this only matters for Arduino + # or when bt pulls it back. wifi_disabled = net.ethernet and not net.wifi if wifi_disabled: set_idf_sdkconfig_default("CONFIG_ESP_WIFI_ENABLED", False) @@ -2712,13 +2734,7 @@ async def to_code(config): _configure_lwip_max_sockets(conf) if advanced[CONF_EXECUTE_FROM_PSRAM]: - if variant == VARIANT_ESP32S3: - add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True) - add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True) - elif variant == VARIANT_ESP32P4: - add_idf_sdkconfig_option("CONFIG_SPIRAM_XIP_FROM_PSRAM", True) - else: - raise ValueError("Unhandled ESP32 variant") + add_idf_sdkconfig_option("CONFIG_SPIRAM_XIP_FROM_PSRAM", True) # Apply LWIP core locking for better socket performance # This is already enabled by default in Arduino framework, where it provides @@ -3234,7 +3250,13 @@ def _write_sdkconfig(): if write_file_if_changed(internal_path, contents): # internal changed, update real one write_file_if_changed(sdk_path, contents) - clean_build(clear_pio_cache=False) + if not CORE.using_toolchain_esp_idf: + # PIO's dependency tracking under-declares sdkconfig inputs + # (ldgen, linker scripts); without a clean the image can be + # unbootable (esphome#15336). The esp-idf toolchain tracks + # sdkconfig via IDF's cmake and has_outdated_files(), so a + # reconfigure suffices there; everything else fails safe. + clean_build(clear_pio_cache=False) def _write_idf_component_yml(): diff --git a/esphome/components/esp32/gpio_esp32_s31.py b/esphome/components/esp32/gpio_esp32_s31.py index d49240723b..7ccb7cdb90 100644 --- a/esphome/components/esp32/gpio_esp32_s31.py +++ b/esphome/components/esp32/gpio_esp32_s31.py @@ -5,11 +5,14 @@ import esphome.config_validation as cv from esphome.const import CONF_INPUT, CONF_MODE, CONF_NUMBER, CONF_SCL, CONF_SDA from esphome.pins import check_strapping_pin -# Per the ESP32-S31 datasheet (page 96): +# Per the ESP32-S31 IDF DOCS and datasheet: +# https://docs.espressif.com/projects/esp-idf/en/v6.1/esp32s31/api-reference/peripherals/gpio.html # https://documentation.espressif.com/esp32-s31_datasheet_en.pdf -_ESP32S31_SPI_FLASH_PINS: set[int] = {27, 28, 29, 31, 32, 33} -# GPIO60/GPIO61 set the boot mode; GPIO37 selects the JTAG signal source. -_ESP32S31_STRAPPING_PINS: set[int] = {37, 60, 61} +_ESP32S31_SPI_FLASH_PINS: set[int] = {26, 27, 28, 30, 31, 32} +_ESP32S31_INVALID_PINS: set[int] = {29, 41} +# GPIO60/GPIO61 set the boot mode; GPIO37 selects the JTAG signal source; +# GPIO36 sets the VDD_SPI voltage. +_ESP32S31_STRAPPING_PINS: set[int] = {36, 37, 60, 61} # LP I2C is fixed to GPIO6 (SCL) / GPIO7 (SDA) per the datasheet IO MUX table. _ESP32S31_I2C_LP_PINS = {"SDA": 7, "SCL": 6} @@ -19,6 +22,8 @@ _LOGGER = logging.getLogger(__name__) def esp32_s31_validate_gpio_pin(value: int) -> int: if value < 0 or value > 61: raise cv.Invalid(f"Invalid pin number: {value} (must be 0-61)") + if value in _ESP32S31_INVALID_PINS: + raise cv.Invalid(f"GPIO{value} does not exist on ESP32-S31.") if value in _ESP32S31_SPI_FLASH_PINS: raise cv.Invalid( f"GPIO{value} is reserved for the SPI flash interface on ESP32-S31 and cannot be used." @@ -33,6 +38,10 @@ def esp32_s31_validate_supports(value: dict[str, Any]) -> dict[str, Any]: if num < 0 or num > 61: raise cv.Invalid(f"Invalid pin number: {num} (must be 0-61)") + # Checked here as well so ignore_pin_validation_error cannot bypass it; + # these pins are not bonded and can never work + if num in _ESP32S31_INVALID_PINS: + raise cv.Invalid(f"GPIO{num} does not exist on ESP32-S31.") if is_input: # All ESP32 pins support input mode pass diff --git a/esphome/components/esp32_camera_web_server/camera_web_server.cpp b/esphome/components/esp32_camera_web_server/camera_web_server.cpp index 88579e9632..bee231d132 100644 --- a/esphome/components/esp32_camera_web_server/camera_web_server.cpp +++ b/esphome/components/esp32_camera_web_server/camera_web_server.cpp @@ -210,8 +210,9 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) { if (!image) { // A shutdown is not a lost frame: wait_for_image_() returns empty as soon // as running_ clears, and the loop condition below ends the stream anyway. - if (this->running_) + if (this->running_) { ESP_LOGW(TAG, "STREAM: failed to acquire frame"); + } res = ESP_FAIL; } if (res == ESP_OK) { diff --git a/esphome/components/esp32_improv/esp32_improv_component.cpp b/esphome/components/esp32_improv/esp32_improv_component.cpp index 6e3a4ef526..4756fba637 100644 --- a/esphome/components/esp32_improv/esp32_improv_component.cpp +++ b/esphome/components/esp32_improv/esp32_improv_component.cpp @@ -1,5 +1,7 @@ #include "esp32_improv_component.h" +#include + #include "esphome/components/bytebuffer/bytebuffer.h" #include "esphome/components/esp32_ble/ble.h" #include "esphome/components/esp32_ble_server/ble_2902.h" @@ -19,7 +21,13 @@ using namespace bytebuffer; static const char *const TAG = "esp32_improv.component"; static constexpr size_t IMPROV_MAX_LOG_BYTES = 128; -static const char *const ESPHOME_MY_LINK = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome"; +static constexpr char ESPHOME_MY_LINK[] = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome"; +// command + data length + trailing byte +static constexpr size_t RPC_RESPONSE_OVERHEAD = 3; +// Reserves the ESPHOME_MY_LINK entry; a maximal next URL displaces only the +// lower value web server URL +static constexpr size_t MAX_NEXT_URL_LEN = + improv::RPC_RESPONSE_MAX_SIZE - RPC_RESPONSE_OVERHEAD - 1 - sizeof(ESPHOME_MY_LINK); static constexpr uint16_t STOP_ADVERTISING_DELAY = 10000; // Delay (ms) before stopping service to allow BLE clients to read the final state static constexpr uint16_t NAME_ADVERTISING_INTERVAL = 60000; // Advertise name every 60 seconds @@ -285,8 +293,9 @@ void ESP32ImprovComponent::set_error_(improv::Error error) { } } -void ESP32ImprovComponent::send_response_(std::vector &&response) { - this->rpc_response_->set_value(std::move(response)); +void ESP32ImprovComponent::send_response_(std::span response) { + // The BLE characteristic owns its value, so one exact-size copy is required here + this->rpc_response_->set_value(std::vector(response.begin(), response.end())); if (this->state_ != improv::STATE_STOPPED) this->rpc_response_->notify(); } @@ -430,40 +439,35 @@ void ESP32ImprovComponent::check_wifi_connection_() { this->connecting_sta_ = {}; this->cancel_timeout("wifi-connect-timeout"); - // Build URL list with minimal allocations - // Maximum 3 URLs: custom next_url + ESPHOME_MY_LINK + webserver URL - std::string url_strings[3]; - size_t url_count = 0; + // Build the URL list directly into a stack buffer with no heap allocation + std::array buf; + improv::RpcResponseBuilder builder(buf, improv::WIFI_SETTINGS); #ifdef USE_ESP32_IMPROV_NEXT_URL // Add next_url if configured (should be first per Improv BLE spec) - { - char url_buffer[384]; - size_t len = this->get_formatted_next_url_(url_buffer, sizeof(url_buffer)); - if (len > 0) { - url_strings[url_count++] = std::string(url_buffer, len); - } - } + this->add_next_url_(builder, MAX_NEXT_URL_LEN); #endif - // Add default URLs for backward compatibility - url_strings[url_count++] = ESPHOME_MY_LINK; + // Add default URLs for backward compatibility; MAX_NEXT_URL_LEN reserves this + // entry's space, so it always fits + builder.add_string(ESPHOME_MY_LINK, sizeof(ESPHOME_MY_LINK) - 1); #ifdef USE_WEBSERVER for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) { if (ip.is_ip4()) { - // "http://" (7) + IPv4 max (15) + ":" (1) + port max (5) + null = 29 - char url_buffer[32]; - memcpy(url_buffer, "http://", 7); // NOLINT(bugprone-not-null-terminated-result) - str_to null-terminates - ip.str_to(url_buffer + 7); - size_t len = strlen(url_buffer); - snprintf(url_buffer + len, sizeof(url_buffer) - len, ":%d", USE_WEBSERVER_PORT); - url_strings[url_count++] = url_buffer; + char ip_buf[network::IP_ADDRESS_BUFFER_SIZE]; + ip.str_to(ip_buf); + // "http://" (7) + IP (40) + ":" (1) + port (5) + null (1) = 54 + char webserver_url[7 + network::IP_ADDRESS_BUFFER_SIZE + 1 + 5 + 1]; + size_t len = + buf_append_printf(webserver_url, sizeof(webserver_url), 0, "http://%s:%u", ip_buf, USE_WEBSERVER_PORT); + if (!builder.add_string(webserver_url, len)) { + ESP_LOGW(TAG, "Response full; URL dropped"); + } break; } } #endif - this->send_response_(improv::build_rpc_response(improv::WIFI_SETTINGS, - std::vector(url_strings, url_strings + url_count))); + this->send_response_(builder.finish()); } else if (this->is_active() && this->state_ != improv::STATE_PROVISIONED) { ESP_LOGD(TAG, "WiFi provisioned externally"); } diff --git a/esphome/components/esp32_improv/esp32_improv_component.h b/esphome/components/esp32_improv/esp32_improv_component.h index d948dba3b3..414948c977 100644 --- a/esphome/components/esp32_improv/esp32_improv_component.h +++ b/esphome/components/esp32_improv/esp32_improv_component.h @@ -22,6 +22,7 @@ #include "esphome/components/output/binary_output.h" #endif +#include #include #ifdef USE_ESP32 @@ -109,7 +110,7 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB void set_state_(improv::State state, bool update_advertising = true); void set_error_(improv::Error error); improv::State get_initial_state_() const; - void send_response_(std::vector &&response); + void send_response_(std::span response); void process_incoming_data_(); void on_wifi_connect_timeout_(); void check_wifi_connection_(); diff --git a/esphome/components/esphome/ota/__init__.py b/esphome/components/esphome/ota/__init__.py index 3ef4c7ba13..1fec9e5c9b 100644 --- a/esphome/components/esphome/ota/__init__.py +++ b/esphome/components/esphome/ota/__init__.py @@ -1,12 +1,20 @@ import logging import esphome.codegen as cg +from esphome.components.noise import ( + decode_encryption_key, + encryption_schema, + is_reserved_key, +) from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code from esphome.config_helpers import merge_config import esphome.config_validation as cv from esphome.const import ( + CONF_API, + CONF_ENCRYPTION, CONF_ESPHOME, CONF_ID, + CONF_KEY, CONF_NUM_ATTEMPTS, CONF_OTA, CONF_PASSWORD, @@ -15,6 +23,7 @@ from esphome.const import ( CONF_REBOOT_TIMEOUT, CONF_SAFE_MODE, CONF_VERSION, + CONF_WEB_SERVER, ) from esphome.core import CORE, coroutine_with_priority from esphome.coroutine import CoroPriority @@ -22,6 +31,7 @@ import esphome.final_validate as fv from esphome.types import ConfigType CONF_ALLOW_PARTITION_ACCESS = "allow_partition_access" +CONF_CAPTIVE_PORTAL = "captive_portal" _LOGGER = logging.getLogger(__name__) @@ -30,7 +40,15 @@ CODEOWNERS = ["@esphome/core"] DEPENDENCIES = ["network"] -AUTO_LOAD = ["sha256", "socket"] +def AUTO_LOAD(config: ConfigType) -> list[str]: + """Auto-load noise only when encryption is configured.""" + base = ["sha256", "socket"] + # A falsy config is a tooling probe for the maximal set (None from + # dependency resolution, {} from the components-graph platform probe); + # a validated config always carries defaults, never empty + if not config or CONF_ENCRYPTION in config: + return base + ["noise"] + return base esphome = cg.esphome_ns.namespace("esphome") @@ -67,11 +85,24 @@ def ota_esphome_final_validate(config: ConfigType) -> None: CONF_PASSWORD in merged_ota_esphome_configs_by_port[conf_port] and CONF_PASSWORD in ota_conf and merged_ota_esphome_configs_by_port[conf_port][CONF_PASSWORD] - != ota_conf.get(CONF_PASSWORD) + != ota_conf[CONF_PASSWORD] ): raise cv.Invalid( f"Found multiple configurations but {CONF_PASSWORD} is inconsistent" ) + # Encryption blocks conflict only when both pin a key; a bare + # `encryption:` (a package/device split) is compatible with a + # keyed one, and merge_config yields the keyed result + merged_key = ( + merged_ota_esphome_configs_by_port[conf_port] + .get(CONF_ENCRYPTION, {}) + .get(CONF_KEY) + ) + other_key = ota_conf.get(CONF_ENCRYPTION, {}).get(CONF_KEY) + if merged_key and other_key and merged_key != other_key: + raise cv.Invalid( + f"Found multiple configurations but {CONF_ENCRYPTION} is inconsistent" + ) ports_with_merged_configs.append(conf_port) merged_ota_esphome_configs_by_port[conf_port] = merge_config( @@ -94,6 +125,20 @@ def ota_esphome_final_validate(config: ConfigType) -> None: new_ota_conf.extend(merged_ota_esphome_configs_by_port.values()) + api_conf = full_conf.get(CONF_API) or {} + for ota_conf in merged_ota_esphome_configs_by_port.values(): + # Merging same-port blocks can combine a password from one block with + # encryption from another; re-check the exclusion on the merged result. + _validate_no_password_with_encryption(ota_conf) + if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None: + _resolve_encryption_key(encryption_conf, api_conf) + if any( + conf.get(CONF_PLATFORM) == CONF_WEB_SERVER for conf in full_ota_conf + ) and any( + CONF_ENCRYPTION in conf for conf in merged_ota_esphome_configs_by_port.values() + ): + _warn_web_server_ota(full_conf) + full_conf[CONF_OTA] = new_ota_conf fv.full_config.set(full_conf) @@ -107,6 +152,73 @@ def ota_esphome_final_validate(config: ConfigType) -> None: ) +def _warn_web_server_ota(full_conf: ConfigType) -> None: + """The web_server ota platform accepts the same image over plaintext HTTP + with basic auth, bypassing the encryption; warn rather than fail so the + operator keeps the recovery path.""" + if CONF_CAPTIVE_PORTAL in full_conf and CONF_WEB_SERVER not in full_conf: + # The captive_portal auto-load: the endpoint only exists while the + # fallback AP is active + _LOGGER.warning( + "OTA encryption does not cover the %s OTA platform (auto-loaded " + "by captive_portal); the plaintext /update endpoint stays " + "reachable while the fallback AP is active", + CONF_WEB_SERVER, + ) + else: + _LOGGER.warning( + "OTA encryption does not cover the %s OTA platform; its " + "plaintext /update endpoint accepts the same image", + CONF_WEB_SERVER, + ) + + +def _resolve_encryption_key(encryption_conf: ConfigType, api_conf: ConfigType) -> None: + """Resolve the one encryption key per device into the ota block. + + An explicit ota key must match the api key, a bare block inherits it, + a runtime provisioned api key cannot be inherited, and the all-zeros + provisioning sentinel is rejected (the device treats it as no key). + """ + api_key = api_conf.get(CONF_ENCRYPTION, {}).get(CONF_KEY) + if ota_key := encryption_conf.get(CONF_KEY): + if api_key and ota_key != api_key: + raise cv.Invalid( + f"'{CONF_OTA}' {CONF_ENCRYPTION} {CONF_KEY} must match the " + f"'{CONF_API}' {CONF_ENCRYPTION} {CONF_KEY}; omit the " + f"'{CONF_OTA}' {CONF_KEY} to use the '{CONF_API}' one" + ) + elif not api_key: + if CONF_ENCRYPTION in api_conf: + raise cv.Invalid( + f"the '{CONF_API}' {CONF_ENCRYPTION} {CONF_KEY} is provisioned at " + f"runtime and cannot be inherited at build time; set an explicit " + f"'{CONF_OTA}' {CONF_ENCRYPTION} {CONF_KEY}" + ) + raise cv.Invalid( + f"'{CONF_OTA}' {CONF_ENCRYPTION} has no {CONF_KEY} and there is no " + f"'{CONF_API}' {CONF_ENCRYPTION} {CONF_KEY} to inherit; set one of them" + ) + else: + encryption_conf[CONF_KEY] = api_key + if is_reserved_key(encryption_conf[CONF_KEY]): + raise cv.Invalid( + f"The all-zeros {CONF_KEY} is reserved and provides no protection; " + f"generate a real key with: openssl rand -base64 32" + ) + + +# Also called on merged same-port configs in final validate, where schemas +# do not run +def _validate_no_password_with_encryption(config: ConfigType) -> ConfigType: + if CONF_PASSWORD in config and CONF_ENCRYPTION in config: + raise cv.Invalid( + f"'{CONF_PASSWORD}' cannot be combined with '{CONF_ENCRYPTION}'; the " + f"encryption key already authenticates the uploader, remove '{CONF_PASSWORD}'" + ) + return config + + def _consume_ota_sockets(config: ConfigType) -> ConfigType: """Register socket needs for OTA component.""" from esphome.components import socket @@ -134,6 +246,7 @@ CONFIG_SCHEMA = cv.All( ): cv.port, cv.Optional(CONF_ALLOW_PARTITION_ACCESS, default=False): cv.boolean, cv.Optional(CONF_PASSWORD): cv.sensitive(), + cv.Optional(CONF_ENCRYPTION): encryption_schema, cv.Optional(CONF_NUM_ATTEMPTS): cv.invalid( f"'{CONF_SAFE_MODE}' (and its related configuration variables) has moved from 'ota' to its own component. See https://esphome.io/components/safe_mode" ), @@ -147,12 +260,24 @@ CONFIG_SCHEMA = cv.All( ) .extend(BASE_OTA_SCHEMA) .extend(cv.COMPONENT_SCHEMA), + _validate_no_password_with_encryption, _consume_ota_sockets, ) FINAL_VALIDATE_SCHEMA = ota_esphome_final_validate +def FILTER_SOURCE_FILES() -> list[str]: + """Filter out the noise transport when no ota entry configures encryption.""" + for ota_conf in CORE.config.get(CONF_OTA, []): + if ( + ota_conf.get(CONF_PLATFORM) == CONF_ESPHOME + and ota_conf.get(CONF_ENCRYPTION) is not None + ): + return [] + return ["ota_esphome_noise.cpp"] + + @coroutine_with_priority(CoroPriority.OTA_UPDATES) async def to_code(config: ConfigType) -> None: var = cg.new_Pvariable(config[CONF_ID]) @@ -171,6 +296,12 @@ async def to_code(config: ConfigType) -> None: if config.get(CONF_ALLOW_PARTITION_ACCESS): cg.add_define("USE_OTA_PARTITIONS") + if (encryption_conf := config.get(CONF_ENCRYPTION)) is not None: + # A missing key was resolved from the api component in final validate. + key = encryption_conf[CONF_KEY] + cg.add_define("USE_OTA_ENCRYPTION") + cg.add(var.set_noise_psk(list(decode_encryption_key(key)))) + # Build flag so lwip_fast_select.c (a .c file that can't include defines.h) sees it. cg.add_build_flag("-DUSE_OTA_PLATFORM_ESPHOME") diff --git a/esphome/components/esphome/ota/ota_esphome.cpp b/esphome/components/esphome/ota/ota_esphome.cpp index 74f84b71fb..396a47bc52 100644 --- a/esphome/components/esphome/ota/ota_esphome.cpp +++ b/esphome/components/esphome/ota/ota_esphome.cpp @@ -27,7 +27,6 @@ namespace esphome { static const char *const TAG = "esphome.ota"; static constexpr uint16_t OTA_BLOCK_SIZE = 8192; -static constexpr size_t OTA_BUFFER_SIZE = 1024; // buffer size for OTA data transfer static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000; // milliseconds for initial handshake static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000; // milliseconds for data transfer @@ -105,6 +104,11 @@ void ESPHomeOTAComponent::dump_config() { ESP_LOGCONFIG(TAG, " Password configured"); } #endif +#ifdef USE_OTA_ENCRYPTION + if (this->noise_ctx_.has_psk()) { + ESP_LOGCONFIG(TAG, " Encryption configured"); + } +#endif #ifdef USE_OTA_PARTITIONS ESP_LOGCONFIG(TAG, " Partition access allowed\n" @@ -128,7 +132,8 @@ void ESPHomeOTAComponent::dump_config() { esp_partition_iterator_release(it); esp_bootloader_desc_t bootloader_desc; esp_err_t err = esp_ota_get_bootloader_description(nullptr, &bootloader_desc); - ESP_LOGCONFIG(TAG, " Bootloader: ESP-IDF %s", (err == ESP_OK) ? bootloader_desc.idf_ver : "version unknown"); + ESP_LOGCONFIG(TAG, " Bootloader: ESP-IDF %s", + (err == ESP_OK) ? bootloader_desc.idf_ver : LOG_STR_LITERAL("version unknown")); #endif // USE_ESP32 #endif // USE_OTA_PARTITIONS } @@ -148,8 +153,10 @@ void ESPHomeOTAComponent::loop() { static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_COMPRESSION = 0x01; static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02; static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04; +static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_NOISE = 0x08; static constexpr uint8_t SERVER_FEATURE_SUPPORTS_COMPRESSION = 0x01; static constexpr uint8_t SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS = 0x02; +static constexpr uint8_t SERVER_FEATURE_SUPPORTS_NOISE = 0x04; void ESPHomeOTAComponent::handle_handshake_() { /// Handle the OTA handshake and authentication. @@ -201,8 +208,7 @@ void ESPHomeOTAComponent::handle_handshake_() { } // Validate magic bytes - static const uint8_t MAGIC_BYTES[5] = {0x6C, 0x26, 0xF7, 0x5C, 0x45}; - if (memcmp(this->handshake_buf_, MAGIC_BYTES, 5) != 0) { + if (memcmp(this->handshake_buf_, MAGIC_BYTES, sizeof(MAGIC_BYTES)) != 0) { ESP_LOGW(TAG, "Magic bytes mismatch! 0x%02X-0x%02X-0x%02X-0x%02X-0x%02X", this->handshake_buf_[0], this->handshake_buf_[1], this->handshake_buf_[2], this->handshake_buf_[3], this->handshake_buf_[4]); this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_MAGIC); @@ -234,6 +240,19 @@ void ESPHomeOTAComponent::handle_handshake_() { } this->ota_features_ = this->handshake_buf_[0]; ESP_LOGV(TAG, "Features: 0x%02X", this->ota_features_); + +#ifdef USE_OTA_ENCRYPTION + // Fail closed: with a PSK configured the client must negotiate encryption + // (which requires the extended protocol); refuse plaintext uploads. + static constexpr uint8_t NOISE_REQUIRED_FEATURES = + CLIENT_FEATURE_SUPPORTS_NOISE | CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL; + if (this->noise_ctx_.has_psk() && (this->ota_features_ & NOISE_REQUIRED_FEATURES) != NOISE_REQUIRED_FEATURES) { + ESP_LOGW(TAG, "Client does not support encryption"); + this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_ENCRYPTION_REQUIRED); + return; + } +#endif + this->transition_ota_state_(OTAState::FEATURE_ACK); const bool supports_compression = @@ -249,6 +268,11 @@ void ESPHomeOTAComponent::handle_handshake_() { this->handshake_buf_[1] = (supports_compression ? SERVER_FEATURE_SUPPORTS_COMPRESSION : 0); #ifdef USE_OTA_PARTITIONS this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS; +#endif +#ifdef USE_OTA_ENCRYPTION + if (this->noise_ctx_.has_psk()) { + this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_NOISE; + } #endif } else { this->handshake_buf_[0] = @@ -264,6 +288,20 @@ void ESPHomeOTAComponent::handle_handshake_() { if (!this->try_write_(ack_size, LOG_STR("ack feature"))) { return; } +#ifdef USE_OTA_ENCRYPTION + // With a PSK configured the rest of the session runs inside the noise + // transport; the client sends the first handshake frame next, so there + // is nothing to do until data arrives. + if (this->noise_ctx_.has_psk()) { + // handshake_buf_ still holds the feature ack composed above; a + // would-block re-entry lands here without rebuilding it + if (!this->noise_start_session_(this->handshake_buf_[1])) { + return; + } + this->transition_ota_state_(OTAState::NOISE_HANDSHAKE); + return; + } +#endif #ifdef USE_OTA_PASSWORD // If password is set, move to auth phase if (!this->password_.empty()) { @@ -301,6 +339,16 @@ void ESPHomeOTAComponent::handle_handshake_() { this->handle_data_(); return; +#ifdef USE_OTA_ENCRYPTION + case OTAState::NOISE_HANDSHAKE: + if (!this->handle_noise_handshake_()) { + return; + } + this->transition_ota_state_(OTAState::DATA); + this->handle_data_(); + return; +#endif + default: break; } @@ -339,6 +387,8 @@ void ESPHomeOTAComponent::handle_data_() { /// Raw TCP (8266, RP2040): setblocking is no-op; SO_RCVTIMEO uses /// wakeable_delay() in read(); /// write() always returns immediately + // Backend calls overwrite this with OK; reset to UNKNOWN before any + // goto error that follows a successful begin()/write() ota::OTAResponseTypes error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN; size_t total = 0; uint32_t last_progress = 0; @@ -360,11 +410,11 @@ void ESPHomeOTAComponent::handle_data_() { this->client_->setblocking(true); // Acknowledge auth OK - 1 byte - this->write_byte_(ota::OTA_RESPONSE_AUTH_OK); + this->data_write_byte_(ota::OTA_RESPONSE_AUTH_OK); if (this->extended_proto_) { // Read ota type, 1 byte - if (!this->readall_(buf, 1)) { + if (!this->data_readall_(buf, 1)) { this->log_read_error_(LOG_STR("OTA type")); goto error; // NOLINT(cppcoreguidelines-avoid-goto) } @@ -373,7 +423,7 @@ void ESPHomeOTAComponent::handle_data_() { ESP_LOGV(TAG, "OTA type is 0x%02x", ota_type); // Read size, 4 bytes MSB first - if (!this->readall_(buf, 4)) { + if (!this->data_readall_(buf, 4)) { this->log_read_error_(LOG_STR("size")); goto error; // NOLINT(cppcoreguidelines-avoid-goto) } @@ -404,11 +454,12 @@ void ESPHomeOTAComponent::handle_data_() { goto error; // NOLINT(cppcoreguidelines-avoid-goto) // Acknowledge prepare OK - 1 byte - this->write_byte_(ota::OTA_RESPONSE_UPDATE_PREPARE_OK); + this->data_write_byte_(ota::OTA_RESPONSE_UPDATE_PREPARE_OK); // Read binary MD5, 32 bytes - if (!this->readall_(buf, 32)) { + if (!this->data_readall_(buf, 32)) { this->log_read_error_(LOG_STR("MD5 checksum")); + error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN; goto error; // NOLINT(cppcoreguidelines-avoid-goto) } sbuf[32] = '\0'; @@ -416,7 +467,7 @@ void ESPHomeOTAComponent::handle_data_() { this->backend_->set_update_md5(sbuf); // Acknowledge MD5 OK - 1 byte - this->write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK); + this->data_write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK); // Track when we last received data so a silently-vanished peer (no FIN/RST // delivered, e.g. uploader killed mid-transfer or NAT/router dropped state) @@ -432,19 +483,35 @@ void ESPHomeOTAComponent::handle_data_() { } size_t remaining = ota_size - total; size_t requested = remaining < OTA_BUFFER_SIZE ? remaining : OTA_BUFFER_SIZE; - ssize_t read = this->client_->read(buf, requested); - if (read == -1) { - const int err = errno; - if (this->would_block_(err)) { - // read() already waited up to SO_RCVTIMEO for data, just feed WDT - App.feed_wdt(); - continue; + ssize_t read; +#ifdef USE_OTA_ENCRYPTION + if (this->noise_ != nullptr) { + // One frame per call; noise_read_data_ waits internally (readall_), so + // there is no would-block retry here and failures are already logged. + read = this->noise_read_data_(buf, requested); + if (read <= 0) { + error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN; + goto error; // NOLINT(cppcoreguidelines-avoid-goto) + } + } else +#endif + { + read = this->client_->read(buf, requested); + if (read == -1) { + const int err = errno; + if (this->would_block_(err)) { + // read() already waited up to SO_RCVTIMEO for data, just feed WDT + App.feed_wdt(); + continue; + } + ESP_LOGW(TAG, "Read err %d", err); + error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN; + goto error; // NOLINT(cppcoreguidelines-avoid-goto) + } else if (read == 0) { + ESP_LOGW(TAG, "Remote closed"); + error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN; + goto error; // NOLINT(cppcoreguidelines-avoid-goto) } - ESP_LOGW(TAG, "Read err %d", err); - goto error; // NOLINT(cppcoreguidelines-avoid-goto) - } else if (read == 0) { - ESP_LOGW(TAG, "Remote closed"); - goto error; // NOLINT(cppcoreguidelines-avoid-goto) } last_data_ms = millis(); @@ -456,7 +523,7 @@ void ESPHomeOTAComponent::handle_data_() { total += read; #if USE_OTA_VERSION == 2 while (size_acknowledged + OTA_BLOCK_SIZE <= total || (total == ota_size && size_acknowledged < ota_size)) { - this->write_byte_(ota::OTA_RESPONSE_CHUNK_OK); + this->data_write_byte_(ota::OTA_RESPONSE_CHUNK_OK); size_acknowledged += OTA_BLOCK_SIZE; } #endif @@ -475,7 +542,7 @@ void ESPHomeOTAComponent::handle_data_() { } // Acknowledge receive OK - 1 byte - this->write_byte_(ota::OTA_RESPONSE_RECEIVE_OK); + this->data_write_byte_(ota::OTA_RESPONSE_RECEIVE_OK); error_code = this->backend_->end(); if (error_code != ota::OTA_RESPONSE_OK) { @@ -484,10 +551,10 @@ void ESPHomeOTAComponent::handle_data_() { } // Acknowledge Update end OK - 1 byte - this->write_byte_(ota::OTA_RESPONSE_UPDATE_END_OK); + this->data_write_byte_(ota::OTA_RESPONSE_UPDATE_END_OK); // Read ACK - if (!this->readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) { + if (!this->data_readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) { this->log_read_error_(LOG_STR("ack")); // do not go to error, this is not fatal } @@ -510,7 +577,7 @@ void ESPHomeOTAComponent::handle_data_() { App.safe_reboot(); error: - this->write_byte_(static_cast(error_code)); + this->data_write_byte_(static_cast(error_code)); // Abort backend before cleanup - cleanup_connection_() destroys the backend. // Always call abort() unconditionally: backends register external partitions before @@ -677,6 +744,9 @@ void ESPHomeOTAComponent::cleanup_connection_() { this->backend_ = nullptr; #ifdef USE_OTA_PASSWORD this->cleanup_auth_(); +#endif +#ifdef USE_OTA_ENCRYPTION + this->noise_ = nullptr; #endif // Intentionally no disable_loop() — letting loop() run one more iteration catches // any connection that queued on the listener mid-session (otherwise the wake flag, diff --git a/esphome/components/esphome/ota/ota_esphome.h b/esphome/components/esphome/ota/ota_esphome.h index 979e3f2d7d..fd164b8138 100644 --- a/esphome/components/esphome/ota/ota_esphome.h +++ b/esphome/components/esphome/ota/ota_esphome.h @@ -4,6 +4,9 @@ #ifdef USE_OTA #include "esphome/components/ota/ota_backend_factory.h" #include "esphome/components/socket/socket.h" +#ifdef USE_OTA_ENCRYPTION +#include "esphome/components/noise/noise_handshake.h" +#endif #include "esphome/core/helpers.h" #include "esphome/core/log.h" #include "esphome/core/preferences.h" @@ -24,7 +27,10 @@ class ESPHomeOTAComponent final : public ota::OTAComponent { AUTH_SEND, // Sending authentication request AUTH_READ, // Reading authentication data #endif // USE_OTA_PASSWORD - DATA, // BLOCKING! Processing OTA data (update, etc.) +#ifdef USE_OTA_ENCRYPTION + NOISE_HANDSHAKE, // Exchanging Noise handshake frames +#endif + DATA, // BLOCKING! Processing OTA data (update, etc.) }; #ifdef USE_OTA_PASSWORD void set_auth_password(const std::string &password) { password_ = password; } @@ -38,6 +44,10 @@ class ESPHomeOTAComponent final : public ota::OTAComponent { } #endif // USE_OTA_PASSWORD +#ifdef USE_OTA_ENCRYPTION + void set_noise_psk(noise::psk_t psk) { this->noise_ctx_.set_psk(psk); } +#endif + /// Manually set the port OTA should listen on void set_port(uint16_t port) { this->port_ = port; } @@ -63,6 +73,48 @@ class ESPHomeOTAComponent final : public ota::OTAComponent { bool writeall_(const uint8_t *buf, size_t len); inline bool write_byte_(uint8_t byte) { return this->writeall_(&byte, 1); } +#ifdef USE_OTA_ENCRYPTION + // Heap-allocated only while an encrypted OTA session is active. + struct NoiseSession { + ~NoiseSession(); + noise::NoiseResponderHandshake handshake; + NoiseCipherState *send_cipher{nullptr}; + NoiseCipherState *recv_cipher{nullptr}; + uint16_t frame_len{0}; // total frame size once the header is parsed, 0 until then + uint16_t frame_pos{0}; // bytes read or written so far + bool writing{false}; // a produced handshake frame is still being flushed + uint8_t frame_buf[noise::FRAME_HEADER_SIZE + 1 + noise::MAX_HANDSHAKE_SIZE]; + }; + bool noise_start_session_(uint8_t server_feature_flags); + bool handle_noise_handshake_(); + bool noise_try_read_frame_(); + bool noise_try_write_frame_(); + void noise_send_reject_(const LogString *reason); + ssize_t noise_decrypt_(uint8_t *buf, size_t len); + ssize_t noise_read_frame_blocking_(uint8_t *buf, size_t min_ciphertext, size_t max_ciphertext); + bool noise_readall_(uint8_t *buf, size_t len); + ssize_t noise_read_data_(uint8_t *buf, size_t capacity); + bool noise_write_byte_(uint8_t byte); +#endif // USE_OTA_ENCRYPTION + + // Data-phase I/O dispatch: through the noise transport when a session is + // active, straight to the socket otherwise. + inline bool data_write_byte_(uint8_t byte) { +#ifdef USE_OTA_ENCRYPTION + if (this->noise_ != nullptr) + return this->noise_write_byte_(byte); +#endif + return this->write_byte_(byte); + } + // When encrypted, buf must have room for len + noise::MAC_SIZE bytes. + inline bool data_readall_(uint8_t *buf, size_t len) { +#ifdef USE_OTA_ENCRYPTION + if (this->noise_ != nullptr) + return this->noise_readall_(buf, len); +#endif + return this->readall_(buf, len); + } + bool try_read_(size_t to_read, const LogString *desc); bool try_write_(size_t to_write, const LogString *desc); @@ -91,6 +143,10 @@ class ESPHomeOTAComponent final : public ota::OTAComponent { std::string password_; std::unique_ptr auth_buf_; #endif // USE_OTA_PASSWORD +#ifdef USE_OTA_ENCRYPTION + noise::NoiseContext noise_ctx_; + std::unique_ptr noise_; +#endif // USE_OTA_ENCRYPTION socket::ListenSocket *server_{nullptr}; std::unique_ptr client_; @@ -98,6 +154,18 @@ class ESPHomeOTAComponent final : public ota::OTAComponent { uint32_t client_connect_time_{0}; static constexpr size_t HANDSHAKE_BUF_SIZE = 5; + // Buffer size for OTA data transfer. The upload client derives its maximum + // encrypted frame plaintext from this (espota2.NOISE_MAX_PLAINTEXT is this + // minus the 16-byte MAC); both must change together. + static constexpr size_t OTA_BUFFER_SIZE = 1040; +#ifdef USE_OTA_ENCRYPTION + // espota2.NOISE_MAX_PLAINTEXT; shrinking the buffer would reject every + // frame a current CLI sends + static constexpr size_t NOISE_CLIENT_MAX_PLAINTEXT = 1024; + static_assert(OTA_BUFFER_SIZE >= NOISE_CLIENT_MAX_PLAINTEXT + noise::MAC_SIZE, + "OTA_BUFFER_SIZE must fit a full encrypted data frame"); +#endif + static constexpr uint8_t MAGIC_BYTES[5] = {0x6C, 0x26, 0xF7, 0x5C, 0x45}; #ifdef USE_OTA_PARTITIONS uint32_t running_app_offset_{0}; size_t running_app_size_{0}; diff --git a/esphome/components/esphome/ota/ota_esphome_noise.cpp b/esphome/components/esphome/ota/ota_esphome_noise.cpp new file mode 100644 index 0000000000..7f8331cf96 --- /dev/null +++ b/esphome/components/esphome/ota/ota_esphome_noise.cpp @@ -0,0 +1,279 @@ +#include "ota_esphome.h" +#ifdef USE_OTA +#ifdef USE_OTA_ENCRYPTION +#include "esphome/components/noise/noise.h" +#include "esphome/components/ota/ota_backend.h" +#include "esphome/core/log.h" + +#include +#include + +#ifdef USE_ESP8266 +#include +#endif + +namespace esphome { + +static const char *const TAG = "esphome.ota"; + +#ifdef USE_ESP8266 +static constexpr char OTA_NOISE_PROLOGUE_INIT[] PROGMEM = "NoiseOTAInit"; +#else +static constexpr char OTA_NOISE_PROLOGUE_INIT[] = "NoiseOTAInit"; +#endif +static constexpr size_t OTA_NOISE_PROLOGUE_INIT_LEN = sizeof(OTA_NOISE_PROLOGUE_INIT) - 1; + +ESPHomeOTAComponent::NoiseSession::~NoiseSession() { + if (this->send_cipher != nullptr) { + noise_cipherstate_free(this->send_cipher); + } + if (this->recv_cipher != nullptr) { + noise_cipherstate_free(this->recv_cipher); + } +} + +/** Allocate the session and start the responder handshake. + * + * The prologue binds the whole plaintext preamble, so any tampering with the + * negotiation (a stripped feature flag, a changed version) breaks the first + * handshake MAC on either side: + * "NoiseOTAInit" | magic(5) | OK,version | client_features | FEATURE_FLAGS,server_flags + */ +bool ESPHomeOTAComponent::noise_start_session_(uint8_t server_feature_flags) { + // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) + this->noise_ = std::unique_ptr(new (std::nothrow) NoiseSession()); + if (this->noise_ == nullptr) { + ESP_LOGW(TAG, "Session allocation failed"); + this->cleanup_connection_(); + return false; + } + + static constexpr size_t PROLOGUE_ACK_LEN = 2; // OTA_RESPONSE_OK + version + static constexpr size_t PROLOGUE_CLIENT_FEATURES_LEN = 1; + static constexpr size_t PROLOGUE_FEATURE_ACK_LEN = 2; // OTA_RESPONSE_FEATURE_FLAGS + server flags + uint8_t prologue[OTA_NOISE_PROLOGUE_INIT_LEN + sizeof(MAGIC_BYTES) + PROLOGUE_ACK_LEN + PROLOGUE_CLIENT_FEATURES_LEN + + PROLOGUE_FEATURE_ACK_LEN]; +#ifdef USE_ESP8266 + memcpy_P(prologue, OTA_NOISE_PROLOGUE_INIT, OTA_NOISE_PROLOGUE_INIT_LEN); +#else + std::memcpy(prologue, OTA_NOISE_PROLOGUE_INIT, OTA_NOISE_PROLOGUE_INIT_LEN); +#endif + uint8_t *p = prologue + OTA_NOISE_PROLOGUE_INIT_LEN; + // Magic bytes, already validated in MAGIC_READ + std::memcpy(p, MAGIC_BYTES, sizeof(MAGIC_BYTES)); + p += sizeof(MAGIC_BYTES); + // Our magic ack + *p++ = ota::OTA_RESPONSE_OK; + *p++ = USE_OTA_VERSION; + // The feature byte the client sent + *p++ = this->ota_features_; + // The feature ack we sent (noise requires the extended protocol) + *p++ = ota::OTA_RESPONSE_FEATURE_FLAGS; + *p++ = server_feature_flags; + + int err = this->noise_->handshake.init(this->noise_ctx_.get_psk(), prologue, sizeof(prologue)); + if (err != 0) { + ESP_LOGW(TAG, "Handshake init: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err))); + this->cleanup_connection_(); + return false; + } + return true; +} + +/** Drive the non-blocking handshake from loop(); returns true once the + * transport ciphers are ready. A would-block returns false and the next + * loop() resumes from the NoiseSession cursors; on failure the connection + * is cleaned up. + */ +bool ESPHomeOTAComponent::handle_noise_handshake_() { + NoiseSession &s = *this->noise_; + while (true) { + if (s.writing) { + if (!this->noise_try_write_frame_()) { + return false; // would block, or errored and cleaned up + } + s.writing = false; + s.frame_pos = 0; + s.frame_len = 0; + } + switch (s.handshake.action()) { + case noise::NoiseResponderHandshake::Action::ACTION_READ: { + if (!this->noise_try_read_frame_()) { + return false; + } + const uint16_t payload_len = s.frame_len - noise::FRAME_HEADER_SIZE; + s.frame_pos = 0; + s.frame_len = 0; + if (s.frame_buf[noise::FRAME_HEADER_SIZE] != noise::HANDSHAKE_STATUS_OK) { + ESP_LOGW(TAG, "Bad handshake error byte: %u", s.frame_buf[noise::FRAME_HEADER_SIZE]); + this->cleanup_connection_(); + return false; + } + int err = s.handshake.read_message(s.frame_buf + noise::FRAME_HEADER_SIZE + 1, payload_len - 1); + if (err != 0) { + ESP_LOGW(TAG, "Handshake read: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err))); + this->noise_send_reject_(noise::reject_reason_for(err)); + this->cleanup_connection_(); + return false; + } + break; + } + case noise::NoiseResponderHandshake::Action::ACTION_WRITE: { + size_t msg_len = 0; + int err = + s.handshake.write_message(s.frame_buf + noise::FRAME_HEADER_SIZE + 1, noise::MAX_HANDSHAKE_SIZE, msg_len); + if (err != 0) { + ESP_LOGW(TAG, "Handshake write: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err))); + this->cleanup_connection_(); + return false; + } + const uint16_t payload_len = msg_len + 1; + noise::write_frame_header(s.frame_buf, payload_len); + s.frame_buf[noise::FRAME_HEADER_SIZE] = noise::HANDSHAKE_STATUS_OK; + s.frame_len = noise::FRAME_HEADER_SIZE + payload_len; + s.frame_pos = 0; + s.writing = true; + break; + } + case noise::NoiseResponderHandshake::Action::ACTION_SPLIT: { + int err = s.handshake.split(s.send_cipher, s.recv_cipher); + if (err != 0) { + ESP_LOGW(TAG, "Handshake split: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err))); + this->cleanup_connection_(); + return false; + } + ESP_LOGD(TAG, "Noise handshake complete"); + return true; + } + default: { + ESP_LOGW(TAG, "Bad handshake state"); + this->cleanup_connection_(); + return false; + } + } + } +} + +/// Non-blocking read of one handshake frame into the session buffer. +bool ESPHomeOTAComponent::noise_try_read_frame_() { + NoiseSession &s = *this->noise_; + while (s.frame_pos < noise::FRAME_HEADER_SIZE) { + ssize_t read = this->client_->read(s.frame_buf + s.frame_pos, noise::FRAME_HEADER_SIZE - s.frame_pos); + if (!this->handle_read_error_(read, LOG_STR("read noise header"))) { + return false; + } + s.frame_pos += read; + } + if (s.frame_len == 0) { + const uint16_t payload_len = encode_uint16(s.frame_buf[1], s.frame_buf[2]); + if (s.frame_buf[0] != noise::FRAME_INDICATOR || payload_len < 1 || payload_len > 1 + noise::MAX_HANDSHAKE_SIZE) { + ESP_LOGW(TAG, "Bad handshake frame: 0x%02X, %u bytes", s.frame_buf[0], payload_len); + this->cleanup_connection_(); + return false; + } + s.frame_len = noise::FRAME_HEADER_SIZE + payload_len; + } + while (s.frame_pos < s.frame_len) { + ssize_t read = this->client_->read(s.frame_buf + s.frame_pos, s.frame_len - s.frame_pos); + if (!this->handle_read_error_(read, LOG_STR("read noise frame"))) { + return false; + } + s.frame_pos += read; + } + return true; +} + +/// Non-blocking write of the pending session-buffer frame. +bool ESPHomeOTAComponent::noise_try_write_frame_() { + NoiseSession &s = *this->noise_; + while (s.frame_pos < s.frame_len) { + ssize_t written = this->client_->write(s.frame_buf + s.frame_pos, s.frame_len - s.frame_pos); + if (!this->handle_write_error_(written, LOG_STR("write noise frame"))) { + return false; + } + s.frame_pos += written; + } + return true; +} + +/// Best-effort explicit reject frame so the client can log a readable reason. +void ESPHomeOTAComponent::noise_send_reject_(const LogString *reason) { + // Every reason here comes from noise::reject_reason_for(), so the exported + // floor is the exact capacity needed + uint8_t data[noise::FRAME_HEADER_SIZE + noise::MAC_FAILURE_PAYLOAD_SIZE]; + const size_t payload_len = + noise::format_reject_payload(data + noise::FRAME_HEADER_SIZE, sizeof(data) - noise::FRAME_HEADER_SIZE, reason); + noise::write_frame_header(data, payload_len); + this->client_->write(data, noise::FRAME_HEADER_SIZE + payload_len); // Best effort, non-blocking +} + +/// Decrypt a ciphertext in place; returns the plaintext size or -1. +ssize_t ESPHomeOTAComponent::noise_decrypt_(uint8_t *buf, size_t len) { + NoiseBuffer mbuf; + noise_buffer_init(mbuf); + noise_buffer_set_inout(mbuf, buf, len, len); + int err = noise_cipherstate_decrypt(this->noise_->recv_cipher, &mbuf); + if (err != 0) { + ESP_LOGW(TAG, "Decrypt: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err))); + return -1; + } + return mbuf.size; +} + +/** Blocking read of one frame whose ciphertext size must be within the given + * bounds, decrypted in place; returns the plaintext size, or -1 on error. + * buf needs max_ciphertext capacity. + */ +ssize_t ESPHomeOTAComponent::noise_read_frame_blocking_(uint8_t *buf, size_t min_ciphertext, size_t max_ciphertext) { + uint8_t header[noise::FRAME_HEADER_SIZE]; + if (!this->readall_(header, sizeof(header))) { + return -1; + } + const size_t ciphertext_len = encode_uint16(header[1], header[2]); + if (header[0] != noise::FRAME_INDICATOR || ciphertext_len < min_ciphertext || ciphertext_len > max_ciphertext) { + ESP_LOGW(TAG, "Bad frame: 0x%02X, %zu bytes", header[0], ciphertext_len); + return -1; + } + if (!this->readall_(buf, ciphertext_len)) { + return -1; + } + return this->noise_decrypt_(buf, ciphertext_len); +} + +/** Blocking read of one frame whose plaintext must be exactly len bytes + * (control units are one unit per frame). buf needs len + noise::MAC_SIZE + * capacity; the plaintext lands at buf[0..len). + */ +bool ESPHomeOTAComponent::noise_readall_(uint8_t *buf, size_t len) { + return this->noise_read_frame_blocking_(buf, len + noise::MAC_SIZE, len + noise::MAC_SIZE) == (ssize_t) len; +} + +/** Blocking read of one data-phase frame, decrypted in place; returns the + * plaintext size, or -1 on error. buf is the OTA_BUFFER_SIZE data buffer. + * The ciphertext must fit that buffer and its plaintext must fit what the + * caller accepts (the remaining image bytes). + */ +ssize_t ESPHomeOTAComponent::noise_read_data_(uint8_t *buf, size_t capacity) { + const size_t max_ciphertext = std::min(capacity + noise::MAC_SIZE, OTA_BUFFER_SIZE); + return this->noise_read_frame_blocking_(buf, noise::MAC_SIZE + 1, max_ciphertext); +} + +/// Blocking write of one response byte as an encrypted frame. +bool ESPHomeOTAComponent::noise_write_byte_(uint8_t byte) { + uint8_t frame[noise::FRAME_HEADER_SIZE + 1 + noise::MAC_SIZE]; + frame[noise::FRAME_HEADER_SIZE] = byte; + NoiseBuffer mbuf; + noise_buffer_init(mbuf); + noise_buffer_set_inout(mbuf, frame + noise::FRAME_HEADER_SIZE, 1, 1 + noise::MAC_SIZE); + int err = noise_cipherstate_encrypt(this->noise_->send_cipher, &mbuf); + if (err != 0) { + ESP_LOGW(TAG, "Encrypt: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err))); + return false; + } + noise::write_frame_header(frame, mbuf.size); + return this->writeall_(frame, noise::FRAME_HEADER_SIZE + mbuf.size); +} + +} // namespace esphome +#endif // USE_OTA_ENCRYPTION +#endif // USE_OTA diff --git a/esphome/components/espnow/__init__.py b/esphome/components/espnow/__init__.py index ee3732c406..5541a6ee97 100644 --- a/esphome/components/espnow/__init__.py +++ b/esphome/components/espnow/__init__.py @@ -155,6 +155,11 @@ async def to_code(config: ConfigType) -> None: cg.add_define("USE_ESPNOW") cg.add_define("USE_ESPNOW_MAX_PAYLOAD_SIZE", config[CONF_MAX_PAYLOAD_SIZE]) + if CORE.is_esp32: + from esphome.components.esp32 import include_builtin_idf_component + + include_builtin_idf_component("esp_wifi") + if CONF_WIFI in CORE.config: # Track the Wi-Fi channel via connect events instead of polling every loop wifi.request_wifi_connect_state_listener() diff --git a/esphome/components/external_components/__init__.py b/esphome/components/external_components/__init__.py index c892ec1112..504b1ae679 100644 --- a/esphome/components/external_components/__init__.py +++ b/esphome/components/external_components/__init__.py @@ -71,6 +71,33 @@ def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> P return components_dir +def _log_overridden_components( + conf: dict[str, Any], component_names: list[str] +) -> None: + overridden = [ + name + for name in component_names + if (loader.CORE_COMPONENTS_PATH / name / "__init__.py").is_file() + ] + if not overridden: + return + if conf[CONF_TYPE] == TYPE_GIT: + source = conf[CONF_URL] + if ref := conf.get(CONF_REF): + source = f"{source}@{ref}" + if path := conf.get(CONF_PATH): + source = f"{source} ({path})" + else: + source = conf[CONF_PATH] + _LOGGER.info( + "External components are overriding built-in components:\n" + " source: %s\n" + " components: %s", + source, + ", ".join(sorted(overridden)), + ) + + def _process_single_config(config: dict[str, Any]) -> None: conf = config[CONF_SOURCE] if conf[CONF_TYPE] == TYPE_GIT: @@ -84,8 +111,8 @@ def _process_single_config(config: dict[str, Any]) -> None: raise NotImplementedError if config[CONF_COMPONENTS] == "all": - num_components = len(list(components_dir.glob("*/__init__.py"))) - if num_components > 100: + component_names = [p.parent.name for p in components_dir.glob("*/__init__.py")] + if len(component_names) > 100: # Prevent accidentally including all components from an esphome fork/branch # In this case force the user to manually specify which components they want to include raise cv.Invalid( @@ -102,6 +129,9 @@ def _process_single_config(config: dict[str, Any]) -> None: [CONF_COMPONENTS, i], ) allowed_components = config[CONF_COMPONENTS] + component_names = allowed_components + + _log_overridden_components(conf, component_names) loader.install_meta_finder(components_dir, allowed_components=allowed_components) diff --git a/esphome/components/fan/fan.cpp b/esphome/components/fan/fan.cpp index 7dc0b5c6fe..65521e63d5 100644 --- a/esphome/components/fan/fan.cpp +++ b/esphome/components/fan/fan.cpp @@ -334,8 +334,9 @@ void Fan::dump_traits_(const char *tag, const char *prefix) { } if (traits.supports_preset_modes()) { ESP_LOGCONFIG(tag, "%s Supported presets:", prefix); - for (const char *s : traits.supported_preset_modes()) + for (const char *s : traits.supported_preset_modes()) { ESP_LOGCONFIG(tag, "%s - %s", prefix, s); + } } } diff --git a/esphome/components/feedback/feedback_cover.cpp b/esphome/components/feedback/feedback_cover.cpp index 1139e6fa18..4baffc74f8 100644 --- a/esphome/components/feedback/feedback_cover.cpp +++ b/esphome/components/feedback/feedback_cover.cpp @@ -93,7 +93,8 @@ void FeedbackCover::set_open_sensor(binary_sensor::BinarySensor *open_feedback) // setup callbacks to react to sensor changes open_feedback->add_on_state_callback([this](bool state) { - ESP_LOGD(TAG, "'%s' - Open feedback '%s'.", this->name_.c_str(), state ? "STARTED" : "ENDED"); + ESP_LOGD(TAG, "'%s' - Open feedback '%s'.", this->name_.c_str(), + state ? LOG_STR_LITERAL("STARTED") : LOG_STR_LITERAL("ENDED")); this->recompute_position_(); if (!state && this->infer_endstop_ && this->current_trigger_operation_ == COVER_OPERATION_OPENING) { this->endstop_reached_(true); @@ -106,7 +107,8 @@ void FeedbackCover::set_close_sensor(binary_sensor::BinarySensor *close_feedback this->close_feedback_ = close_feedback; close_feedback->add_on_state_callback([this](bool state) { - ESP_LOGD(TAG, "'%s' - Close feedback '%s'.", this->name_.c_str(), state ? "STARTED" : "ENDED"); + ESP_LOGD(TAG, "'%s' - Close feedback '%s'.", this->name_.c_str(), + state ? LOG_STR_LITERAL("STARTED") : LOG_STR_LITERAL("ENDED")); this->recompute_position_(); if (!state && this->infer_endstop_ && this->current_trigger_operation_ == COVER_OPERATION_CLOSING) { this->endstop_reached_(false); @@ -144,7 +146,8 @@ void FeedbackCover::endstop_reached_(bool open_endstop) { // from a position slightly past the endpoint if (this->current_trigger_operation_ == (open_endstop ? COVER_OPERATION_OPENING : COVER_OPERATION_CLOSING)) { float dur = (now - this->start_dir_time_) / 1e3f; - ESP_LOGD(TAG, "'%s' - %s endstop reached. Took %.1fs.", this->name_.c_str(), open_endstop ? "Open" : "Close", dur); + ESP_LOGD(TAG, "'%s' - %s endstop reached. Took %.1fs.", this->name_.c_str(), + open_endstop ? LOG_STR_LITERAL("Open") : LOG_STR_LITERAL("Close"), dur); // if there is no external mechanism, stop the cover if (!this->has_built_in_endstop_) { @@ -366,7 +369,7 @@ void FeedbackCover::start_direction_(CoverOperation dir) { // the case when an obstacle appears while moving is handled in the callback if (obstacle != nullptr && obstacle->state) { ESP_LOGD(TAG, "'%s' - %s obstacle detected. Action not started.", this->name_.c_str(), - dir == COVER_OPERATION_OPENING ? "Open" : "Close"); + dir == COVER_OPERATION_OPENING ? LOG_STR_LITERAL("Open") : LOG_STR_LITERAL("Close")); return; } #endif @@ -383,9 +386,9 @@ void FeedbackCover::start_direction_(CoverOperation dir) { this->set_current_operation_(dir, true); this->prev_command_trigger_ = trig; ESP_LOGD(TAG, "'%s' - Firing '%s' trigger.", this->name_.c_str(), - dir == COVER_OPERATION_OPENING ? "OPEN" - : dir == COVER_OPERATION_CLOSING ? "CLOSE" - : "STOP"); + dir == COVER_OPERATION_OPENING ? LOG_STR_LITERAL("OPEN") + : dir == COVER_OPERATION_CLOSING ? LOG_STR_LITERAL("CLOSE") + : LOG_STR_LITERAL("STOP")); trig->trigger(); } } diff --git a/esphome/components/fingerprint_grow/fingerprint_grow.cpp b/esphome/components/fingerprint_grow/fingerprint_grow.cpp index b38d42191b..07630f121a 100644 --- a/esphome/components/fingerprint_grow/fingerprint_grow.cpp +++ b/esphome/components/fingerprint_grow/fingerprint_grow.cpp @@ -547,8 +547,8 @@ void FingerprintGrowComponent::dump_config() { " System Identifier Code: 0x%.4X\n" " Touch Sensing Pin: %s\n" " Sensor Power Pin: %s", - this->system_identifier_code_, this->has_sensing_pin_ ? sensing_pin_buf : "None", - this->has_power_pin_ ? power_pin_buf : "None"); + this->system_identifier_code_, this->has_sensing_pin_ ? sensing_pin_buf : LOG_STR_LITERAL("None"), + this->has_power_pin_ ? power_pin_buf : LOG_STR_LITERAL("None")); if (this->idle_period_to_sleep_ms_ < UINT32_MAX) { ESP_LOGCONFIG(TAG, " Idle Period to Sleep: %" PRIu32 " ms", this->idle_period_to_sleep_ms_); } else { diff --git a/esphome/components/graphical_display_menu/graphical_display_menu.cpp b/esphome/components/graphical_display_menu/graphical_display_menu.cpp index b3c3b27e06..f0642d2e8c 100644 --- a/esphome/components/graphical_display_menu/graphical_display_menu.cpp +++ b/esphome/components/graphical_display_menu/graphical_display_menu.cpp @@ -35,18 +35,20 @@ void GraphicalDisplayMenu::setup() { } void GraphicalDisplayMenu::dump_config() { - ESP_LOGCONFIG(TAG, - "Graphical Display Menu\n" - " Has Display: %s\n" - " Popup Mode: %s\n" - " Advanced Drawing Mode: %s\n" - " Has Font: %s\n" - " Mode: %s\n" - " Active: %s\n" - " Menu items:", - YESNO(this->display_ != nullptr), YESNO(this->display_ != nullptr), YESNO(this->display_ == nullptr), - YESNO(this->font_ != nullptr), - this->mode_ == display_menu_base::MENU_MODE_ROTARY ? "Rotary" : "Joystick", YESNO(this->active_)); + ESP_LOGCONFIG( + TAG, + "Graphical Display Menu\n" + " Has Display: %s\n" + " Popup Mode: %s\n" + " Advanced Drawing Mode: %s\n" + " Has Font: %s\n" + " Mode: %s\n" + " Active: %s\n" + " Menu items:", + YESNO(this->display_ != nullptr), YESNO(this->display_ != nullptr), YESNO(this->display_ == nullptr), + YESNO(this->font_ != nullptr), + this->mode_ == display_menu_base::MENU_MODE_ROTARY ? LOG_STR_LITERAL("Rotary") : LOG_STR_LITERAL("Joystick"), + YESNO(this->active_)); for (size_t i = 0; i < this->displayed_item_->items_size(); i++) { auto *item = this->displayed_item_->get_item(i); ESP_LOGCONFIG(TAG, " %i: %s (Type: %s, Immediate Edit: %s)", i, item->get_text().c_str(), diff --git a/esphome/components/growatt_solar/growatt_solar.cpp b/esphome/components/growatt_solar/growatt_solar.cpp index d2102496a2..08c3966ed9 100644 --- a/esphome/components/growatt_solar/growatt_solar.cpp +++ b/esphome/components/growatt_solar/growatt_solar.cpp @@ -1,105 +1,68 @@ #include "growatt_solar.h" -#include "esphome/core/application.h" -#include "esphome/core/helpers.h" #include "esphome/core/log.h" namespace esphome::growatt_solar { +namespace helpers = modbus::helpers; + static const char *const TAG = "growatt_solar"; static const uint8_t MODBUS_REGISTER_COUNT[] = {33, 95}; // indexed with enum GrowattProtocolVersion -void GrowattSolar::loop() { - // If update() was unable to send we retry until we can send. - if (!this->waiting_to_update_) - return; - update(); -} +void GrowattSolar::update() { this->read_input_registers(0, MODBUS_REGISTER_COUNT[this->protocol_version_]); } -void GrowattSolar::update() { - // If our last send has had no reply yet, and it wasn't that long ago, do nothing. - const uint32_t now = App.get_loop_component_start_time(); - if (now - this->last_send_ < this->get_update_interval() / 2) { - return; - } - - // The bus might be slow, or there might be other devices, or other components might be talking to our device. - if (!this->ready_for_immediate_send()) { - this->waiting_to_update_ = true; - return; - } - - this->waiting_to_update_ = false; - this->read_input_registers(0, MODBUS_REGISTER_COUNT[this->protocol_version_]); - this->last_send_ = millis(); -} - -void GrowattSolar::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - // Other components might be sending commands to our device. But we don't get called with enough - // context to know what is what. So if we didn't do a send, we ignore the data. - if (!this->last_send_) - return; - this->last_send_ = 0; - - // Also ignore the data if the message is too short. Otherwise we will publish invalid values. - if (data.size() < MODBUS_REGISTER_COUNT[this->protocol_version_] * 2) +void GrowattSolar::on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status)) return; - auto publish_1_reg_sensor_state = [&](sensor::Sensor *sensor, size_t i, float unit) -> void { + // Publish a sensor if its register(s) are in this response; skipping absent registers keeps this + // correct for any read range, so the poll may be split into multiple requests. + auto publish_1_reg_sensor_state = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void { if (sensor == nullptr) return; - float value = encode_uint16(data[i * 2], data[i * 2 + 1]) * unit; - sensor->publish_state(value); + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value * unit); }; - auto publish_2_reg_sensor_state = [&](sensor::Sensor *sensor, size_t reg1, size_t reg2, float unit) -> void { - float value = ((encode_uint16(data[reg1 * 2], data[reg1 * 2 + 1]) << 16) + - encode_uint16(data[reg2 * 2], data[reg2 * 2 + 1])) * - unit; - if (sensor != nullptr) - sensor->publish_state(value); + auto publish_2_reg_sensor_state = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value * unit); }; switch (this->protocol_version_) { case RTU: { publish_1_reg_sensor_state(this->inverter_status_, RTU_INVERTER_STATUS, 1); - publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU_PV_ACTIVE_POWER, RTU_PV_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU_PV_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[0].voltage_sensor_, RTU_PV1_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[0].current_sensor_, RTU_PV1_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU_PV1_ACTIVE_POWER, RTU_PV1_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU_PV1_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[1].voltage_sensor_, RTU_PV2_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[1].current_sensor_, RTU_PV2_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU_PV2_ACTIVE_POWER, RTU_PV2_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU_PV2_ACTIVE_POWER, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU_GRID_ACTIVE_POWER, RTU_GRID_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU_GRID_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->grid_frequency_sensor_, RTU_GRID_FREQUENCY, TWO_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[0].voltage_sensor_, RTU_PHASE1_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[0].current_sensor_, RTU_PHASE1_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU_PHASE1_ACTIVE_POWER, - RTU_PHASE1_ACTIVE_POWER + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU_PHASE1_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[1].voltage_sensor_, RTU_PHASE2_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[1].current_sensor_, RTU_PHASE2_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU_PHASE2_ACTIVE_POWER, - RTU_PHASE2_ACTIVE_POWER + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU_PHASE2_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[2].voltage_sensor_, RTU_PHASE3_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[2].current_sensor_, RTU_PHASE3_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU_PHASE3_ACTIVE_POWER, - RTU_PHASE3_ACTIVE_POWER + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU_PHASE3_ACTIVE_POWER, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->today_production_, RTU_TODAY_PRODUCTION, RTU_TODAY_PRODUCTION + 1, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->total_energy_production_, RTU_TOTAL_ENERGY_PRODUCTION, - RTU_TOTAL_ENERGY_PRODUCTION + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->today_production_, RTU_TODAY_PRODUCTION, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->total_energy_production_, RTU_TOTAL_ENERGY_PRODUCTION, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->inverter_module_temp_, RTU_INVERTER_MODULE_TEMP, ONE_DEC_UNIT); break; @@ -107,42 +70,33 @@ void GrowattSolar::on_response(std::span request_pdu, std::spaninverter_status_, RTU2_INVERTER_STATUS, 1); - publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU2_PV_ACTIVE_POWER, RTU2_PV_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU2_PV_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[0].voltage_sensor_, RTU2_PV1_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[0].current_sensor_, RTU2_PV1_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU2_PV1_ACTIVE_POWER, RTU2_PV1_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU2_PV1_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[1].voltage_sensor_, RTU2_PV2_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->pvs_[1].current_sensor_, RTU2_PV2_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU2_PV2_ACTIVE_POWER, RTU2_PV2_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU2_PV2_ACTIVE_POWER, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU2_GRID_ACTIVE_POWER, RTU2_GRID_ACTIVE_POWER + 1, - ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU2_GRID_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->grid_frequency_sensor_, RTU2_GRID_FREQUENCY, TWO_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[0].voltage_sensor_, RTU2_PHASE1_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[0].current_sensor_, RTU2_PHASE1_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU2_PHASE1_ACTIVE_POWER, - RTU2_PHASE1_ACTIVE_POWER + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU2_PHASE1_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[1].voltage_sensor_, RTU2_PHASE2_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[1].current_sensor_, RTU2_PHASE2_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU2_PHASE2_ACTIVE_POWER, - RTU2_PHASE2_ACTIVE_POWER + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU2_PHASE2_ACTIVE_POWER, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[2].voltage_sensor_, RTU2_PHASE3_VOLTAGE, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->phases_[2].current_sensor_, RTU2_PHASE3_CURRENT, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU2_PHASE3_ACTIVE_POWER, - RTU2_PHASE3_ACTIVE_POWER + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU2_PHASE3_ACTIVE_POWER, ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->today_production_, RTU2_TODAY_PRODUCTION, RTU2_TODAY_PRODUCTION + 1, - ONE_DEC_UNIT); - publish_2_reg_sensor_state(this->total_energy_production_, RTU2_TOTAL_ENERGY_PRODUCTION, - RTU2_TOTAL_ENERGY_PRODUCTION + 1, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->today_production_, RTU2_TODAY_PRODUCTION, ONE_DEC_UNIT); + publish_2_reg_sensor_state(this->total_energy_production_, RTU2_TOTAL_ENERGY_PRODUCTION, ONE_DEC_UNIT); publish_1_reg_sensor_state(this->inverter_module_temp_, RTU2_INVERTER_MODULE_TEMP, ONE_DEC_UNIT); break; diff --git a/esphome/components/growatt_solar/growatt_solar.h b/esphome/components/growatt_solar/growatt_solar.h index a172f49001..5b96521476 100644 --- a/esphome/components/growatt_solar/growatt_solar.h +++ b/esphome/components/growatt_solar/growatt_solar.h @@ -17,59 +17,59 @@ enum GrowattProtocolVersion { }; // Register addresses for the RTU protocol. -constexpr size_t RTU_INVERTER_STATUS = 0; // length = 1 -constexpr size_t RTU_PV_ACTIVE_POWER = 1; // length = 2 -constexpr size_t RTU_PV1_VOLTAGE = 3; // length = 1 -constexpr size_t RTU_PV1_CURRENT = 4; // length = 1 -constexpr size_t RTU_PV1_ACTIVE_POWER = 5; // length = 2 -constexpr size_t RTU_PV2_VOLTAGE = 7; // length = 1 -constexpr size_t RTU_PV2_CURRENT = 8; // length = 1 -constexpr size_t RTU_PV2_ACTIVE_POWER = 9; // length = 2 -constexpr size_t RTU_GRID_ACTIVE_POWER = 11; // length = 2 -constexpr size_t RTU_GRID_FREQUENCY = 13; // length = 1 -constexpr size_t RTU_PHASE1_VOLTAGE = 14; // length = 1 -constexpr size_t RTU_PHASE1_CURRENT = 15; // length = 1 -constexpr size_t RTU_PHASE1_ACTIVE_POWER = 16; // length = 2 -constexpr size_t RTU_PHASE2_VOLTAGE = 18; // length = 1 -constexpr size_t RTU_PHASE2_CURRENT = 19; // length = 1 -constexpr size_t RTU_PHASE2_ACTIVE_POWER = 20; // length = 2 -constexpr size_t RTU_PHASE3_VOLTAGE = 22; // length = 1 -constexpr size_t RTU_PHASE3_CURRENT = 23; // length = 1 -constexpr size_t RTU_PHASE3_ACTIVE_POWER = 24; // length = 2 -constexpr size_t RTU_TODAY_PRODUCTION = 26; // length = 2 -constexpr size_t RTU_TOTAL_ENERGY_PRODUCTION = 28; // length = 2 -constexpr size_t RTU_INVERTER_MODULE_TEMP = 32; // length = 1 +constexpr uint16_t RTU_INVERTER_STATUS = 0; // length = 1 +constexpr uint16_t RTU_PV_ACTIVE_POWER = 1; // length = 2 +constexpr uint16_t RTU_PV1_VOLTAGE = 3; // length = 1 +constexpr uint16_t RTU_PV1_CURRENT = 4; // length = 1 +constexpr uint16_t RTU_PV1_ACTIVE_POWER = 5; // length = 2 +constexpr uint16_t RTU_PV2_VOLTAGE = 7; // length = 1 +constexpr uint16_t RTU_PV2_CURRENT = 8; // length = 1 +constexpr uint16_t RTU_PV2_ACTIVE_POWER = 9; // length = 2 +constexpr uint16_t RTU_GRID_ACTIVE_POWER = 11; // length = 2 +constexpr uint16_t RTU_GRID_FREQUENCY = 13; // length = 1 +constexpr uint16_t RTU_PHASE1_VOLTAGE = 14; // length = 1 +constexpr uint16_t RTU_PHASE1_CURRENT = 15; // length = 1 +constexpr uint16_t RTU_PHASE1_ACTIVE_POWER = 16; // length = 2 +constexpr uint16_t RTU_PHASE2_VOLTAGE = 18; // length = 1 +constexpr uint16_t RTU_PHASE2_CURRENT = 19; // length = 1 +constexpr uint16_t RTU_PHASE2_ACTIVE_POWER = 20; // length = 2 +constexpr uint16_t RTU_PHASE3_VOLTAGE = 22; // length = 1 +constexpr uint16_t RTU_PHASE3_CURRENT = 23; // length = 1 +constexpr uint16_t RTU_PHASE3_ACTIVE_POWER = 24; // length = 2 +constexpr uint16_t RTU_TODAY_PRODUCTION = 26; // length = 2 +constexpr uint16_t RTU_TOTAL_ENERGY_PRODUCTION = 28; // length = 2 +constexpr uint16_t RTU_INVERTER_MODULE_TEMP = 32; // length = 1 // Input register addresses for the RTU2 protocol as described // in the "GROWATT INVERTER MODBUS PROTOCOL_II V1.39" document. -constexpr size_t RTU2_INVERTER_STATUS = 0; // length = 1 -constexpr size_t RTU2_PV_ACTIVE_POWER = 1; // length = 2 -constexpr size_t RTU2_PV1_VOLTAGE = 3; // length = 1 -constexpr size_t RTU2_PV1_CURRENT = 4; // length = 1 -constexpr size_t RTU2_PV1_ACTIVE_POWER = 5; // length = 2 -constexpr size_t RTU2_PV2_VOLTAGE = 7; // length = 1 -constexpr size_t RTU2_PV2_CURRENT = 8; // length = 1 -constexpr size_t RTU2_PV2_ACTIVE_POWER = 9; // length = 2 -constexpr size_t RTU2_GRID_ACTIVE_POWER = 35; // length = 2 -constexpr size_t RTU2_GRID_FREQUENCY = 37; // length = 1 -constexpr size_t RTU2_PHASE1_VOLTAGE = 38; // length = 1 -constexpr size_t RTU2_PHASE1_CURRENT = 39; // length = 1 -constexpr size_t RTU2_PHASE1_ACTIVE_POWER = 40; // length = 2 -constexpr size_t RTU2_PHASE2_VOLTAGE = 42; // length = 1 -constexpr size_t RTU2_PHASE2_CURRENT = 43; // length = 1 -constexpr size_t RTU2_PHASE2_ACTIVE_POWER = 44; // length = 2 -constexpr size_t RTU2_PHASE3_VOLTAGE = 46; // length = 1 -constexpr size_t RTU2_PHASE3_CURRENT = 47; // length = 1 -constexpr size_t RTU2_PHASE3_ACTIVE_POWER = 48; // length = 2 -constexpr size_t RTU2_TODAY_PRODUCTION = 53; // length = 2 -constexpr size_t RTU2_TOTAL_ENERGY_PRODUCTION = 55; // length = 2 -constexpr size_t RTU2_INVERTER_MODULE_TEMP = 93; // length = 1 +constexpr uint16_t RTU2_INVERTER_STATUS = 0; // length = 1 +constexpr uint16_t RTU2_PV_ACTIVE_POWER = 1; // length = 2 +constexpr uint16_t RTU2_PV1_VOLTAGE = 3; // length = 1 +constexpr uint16_t RTU2_PV1_CURRENT = 4; // length = 1 +constexpr uint16_t RTU2_PV1_ACTIVE_POWER = 5; // length = 2 +constexpr uint16_t RTU2_PV2_VOLTAGE = 7; // length = 1 +constexpr uint16_t RTU2_PV2_CURRENT = 8; // length = 1 +constexpr uint16_t RTU2_PV2_ACTIVE_POWER = 9; // length = 2 +constexpr uint16_t RTU2_GRID_ACTIVE_POWER = 35; // length = 2 +constexpr uint16_t RTU2_GRID_FREQUENCY = 37; // length = 1 +constexpr uint16_t RTU2_PHASE1_VOLTAGE = 38; // length = 1 +constexpr uint16_t RTU2_PHASE1_CURRENT = 39; // length = 1 +constexpr uint16_t RTU2_PHASE1_ACTIVE_POWER = 40; // length = 2 +constexpr uint16_t RTU2_PHASE2_VOLTAGE = 42; // length = 1 +constexpr uint16_t RTU2_PHASE2_CURRENT = 43; // length = 1 +constexpr uint16_t RTU2_PHASE2_ACTIVE_POWER = 44; // length = 2 +constexpr uint16_t RTU2_PHASE3_VOLTAGE = 46; // length = 1 +constexpr uint16_t RTU2_PHASE3_CURRENT = 47; // length = 1 +constexpr uint16_t RTU2_PHASE3_ACTIVE_POWER = 48; // length = 2 +constexpr uint16_t RTU2_TODAY_PRODUCTION = 53; // length = 2 +constexpr uint16_t RTU2_TOTAL_ENERGY_PRODUCTION = 55; // length = 2 +constexpr uint16_t RTU2_INVERTER_MODULE_TEMP = 93; // length = 1 class GrowattSolar final : public PollingComponent, public modbus::ModbusClientDevice { public: - void loop() override; void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; void dump_config() override; void set_protocol_version(GrowattProtocolVersion protocol_version) { this->protocol_version_ = protocol_version; } @@ -104,9 +104,6 @@ class GrowattSolar final : public PollingComponent, public modbus::ModbusClientD } protected: - bool waiting_to_update_{false}; - uint32_t last_send_{0}; - struct GrowattPhase { sensor::Sensor *voltage_sensor_{nullptr}; sensor::Sensor *current_sensor_{nullptr}; diff --git a/esphome/components/gt911/touchscreen/gt911_touchscreen.cpp b/esphome/components/gt911/touchscreen/gt911_touchscreen.cpp index 2152ae7b84..8ced267947 100644 --- a/esphome/components/gt911/touchscreen/gt911_touchscreen.cpp +++ b/esphome/components/gt911/touchscreen/gt911_touchscreen.cpp @@ -69,10 +69,12 @@ void GT911Touchscreen::setup_internal_() { // Direct MCU pin: attach a hardware interrupt, no polling needed. this->attach_interrupt_(static_cast(this->interrupt_pin_), active_high ? gpio::INTERRUPT_RISING_EDGE : gpio::INTERRUPT_FALLING_EDGE); - ESP_LOGD(TAG, "Interrupt pin: hardware interrupt, active %s", active_high ? "HIGH" : "LOW"); + ESP_LOGD(TAG, "Interrupt pin: hardware interrupt, active %s", + active_high ? LOG_STR_LITERAL("HIGH") : LOG_STR_LITERAL("LOW")); } else { // IO expander pin: leave as output for configuration only. - ESP_LOGD(TAG, "Interrupt pin: IO expander polling mode, active %s", active_high ? "HIGH" : "LOW"); + ESP_LOGD(TAG, "Interrupt pin: IO expander polling mode, active %s", + active_high ? LOG_STR_LITERAL("HIGH") : LOG_STR_LITERAL("LOW")); } } } diff --git a/esphome/components/haier/haier_base.cpp b/esphome/components/haier/haier_base.cpp index 294aa53b03..48f72dc16b 100644 --- a/esphome/components/haier/haier_base.cpp +++ b/esphome/components/haier/haier_base.cpp @@ -248,7 +248,8 @@ void HaierClimateBase::setup() { void HaierClimateBase::dump_config() { LOG_CLIMATE("", "Haier Climate", this); - ESP_LOGCONFIG(TAG, " Device communication status: %s", this->valid_connection() ? "established" : "none"); + ESP_LOGCONFIG(TAG, " Device communication status: %s", + this->valid_connection() ? LOG_STR_LITERAL("established") : LOG_STR_LITERAL("none")); } void HaierClimateBase::loop() { diff --git a/esphome/components/haier/hon_climate.cpp b/esphome/components/haier/hon_climate.cpp index 881a2328cb..0ce4142fd4 100644 --- a/esphome/components/haier/hon_climate.cpp +++ b/esphome/components/haier/hon_climate.cpp @@ -343,11 +343,11 @@ void HonClimate::dump_config() { this->hvac_hardware_info_.value().software_version_, this->hvac_hardware_info_.value().hardware_version_, this->hvac_hardware_info_.value().device_name_); ESP_LOGCONFIG(TAG, " Device features:%s%s%s%s%s", - (this->hvac_hardware_info_.value().functions_[0] ? " interactive" : ""), - (this->hvac_hardware_info_.value().functions_[1] ? " controller-device" : ""), - (this->hvac_hardware_info_.value().functions_[2] ? " crc" : ""), - (this->hvac_hardware_info_.value().functions_[3] ? " multinode" : ""), - (this->hvac_hardware_info_.value().functions_[4] ? " role" : "")); + (this->hvac_hardware_info_.value().functions_[0] ? LOG_STR_LITERAL(" interactive") : ""), + (this->hvac_hardware_info_.value().functions_[1] ? LOG_STR_LITERAL(" controller-device") : ""), + (this->hvac_hardware_info_.value().functions_[2] ? LOG_STR_LITERAL(" crc") : ""), + (this->hvac_hardware_info_.value().functions_[3] ? LOG_STR_LITERAL(" multinode") : ""), + (this->hvac_hardware_info_.value().functions_[4] ? LOG_STR_LITERAL(" role") : "")); ESP_LOGCONFIG(TAG, " Active alarms: %s", buf_to_hex(this->active_alarms_, sizeof(this->active_alarms_)).c_str()); } } diff --git a/esphome/components/havells_solar/havells_solar.cpp b/esphome/components/havells_solar/havells_solar.cpp index 6af72c352b..d43dfbb89a 100644 --- a/esphome/components/havells_solar/havells_solar.cpp +++ b/esphome/components/havells_solar/havells_solar.cpp @@ -1,124 +1,71 @@ #include "havells_solar.h" #include "havells_solar_registers.h" -#include "esphome/core/helpers.h" #include "esphome/core/log.h" namespace esphome::havells_solar { +namespace helpers = modbus::helpers; + static const char *const TAG = "havells_solar"; static const uint8_t MODBUS_REGISTER_COUNT = 48; // 48 x 16-bit registers -void HavellsSolar::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - if (data.size() < MODBUS_REGISTER_COUNT * 2) { - ESP_LOGW(TAG, "Invalid size for HavellsSolar!"); - return; - } +void HavellsSolar::on_read_holding_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status)) + return; // the hub already logs exception responses - /* Usage: returns the float value of 1 register read by modbus - Arg1: Register address * number of bytes per register - Arg2: Multiplier for final register value - */ - auto havells_solar_get_2_registers = [&](size_t i, float unit) -> float { - uint32_t temp = encode_uint32(data[i], data[i + 1], data[i + 2], data[i + 3]); - return temp * unit; + // Publish a sensor if its register(s) are in this response; skipping absent registers keeps this + // correct for any read range, so the poll may be split into multiple requests. + auto publish_1_register = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value * unit); }; - /* Usage: returns the float value of 2 registers read by modbus - Arg1: Register address * number of bytes per register - Arg2: Multiplier for final register value - */ - auto havells_solar_get_1_register = [&](size_t i, float unit) -> float { - uint16_t temp = encode_uint16(data[i], data[i + 1]); - return temp * unit; + auto publish_2_registers = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value * unit); }; for (uint8_t i = 0; i < 3; i++) { - auto phase = this->phases_[i]; + auto &phase = this->phases_[i]; if (!phase.setup) continue; - - float voltage = havells_solar_get_1_register(HAVELLS_PHASE_1_VOLTAGE * 2 + (i * 4), ONE_DEC_UNIT); - float current = havells_solar_get_1_register(HAVELLS_PHASE_1_CURRENT * 2 + (i * 4), TWO_DEC_UNIT); - - if (phase.voltage_sensor_ != nullptr) - phase.voltage_sensor_->publish_state(voltage); - if (phase.current_sensor_ != nullptr) - phase.current_sensor_->publish_state(current); + publish_1_register(phase.voltage_sensor_, HAVELLS_PHASE_1_VOLTAGE + i * 2, ONE_DEC_UNIT); + publish_1_register(phase.current_sensor_, HAVELLS_PHASE_1_CURRENT + i * 2, TWO_DEC_UNIT); } for (uint8_t i = 0; i < 2; i++) { - auto pv = this->pvs_[i]; + auto &pv = this->pvs_[i]; if (!pv.setup) continue; - - float voltage = havells_solar_get_1_register(HAVELLS_PV_1_VOLTAGE * 2 + (i * 4), ONE_DEC_UNIT); - float current = havells_solar_get_1_register(HAVELLS_PV_1_CURRENT * 2 + (i * 4), TWO_DEC_UNIT); - float active_power = havells_solar_get_1_register(HAVELLS_PV_1_POWER * 2 + (i * 2), MULTIPLY_TEN_UNIT); - float voltage_sampled_by_secondary_cpu = - havells_solar_get_1_register(HAVELLS_PV1_VOLTAGE_SAMPLED_BY_SECONDARY_CPU * 2 + (i * 2), ONE_DEC_UNIT); - float insulation_of_p_to_ground = - havells_solar_get_1_register(HAVELLS_PV1_INSULATION_OF_P_TO_GROUND * 2 + (i * 2), NO_DEC_UNIT); - - if (pv.voltage_sensor_ != nullptr) - pv.voltage_sensor_->publish_state(voltage); - if (pv.current_sensor_ != nullptr) - pv.current_sensor_->publish_state(current); - if (pv.active_power_sensor_ != nullptr) - pv.active_power_sensor_->publish_state(active_power); - if (pv.voltage_sampled_by_secondary_cpu_sensor_ != nullptr) - pv.voltage_sampled_by_secondary_cpu_sensor_->publish_state(voltage_sampled_by_secondary_cpu); - if (pv.insulation_of_p_to_ground_sensor_ != nullptr) - pv.insulation_of_p_to_ground_sensor_->publish_state(insulation_of_p_to_ground); + publish_1_register(pv.voltage_sensor_, HAVELLS_PV_1_VOLTAGE + i * 2, ONE_DEC_UNIT); + publish_1_register(pv.current_sensor_, HAVELLS_PV_1_CURRENT + i * 2, TWO_DEC_UNIT); + publish_1_register(pv.active_power_sensor_, HAVELLS_PV_1_POWER + i, MULTIPLY_TEN_UNIT); + publish_1_register(pv.voltage_sampled_by_secondary_cpu_sensor_, HAVELLS_PV1_VOLTAGE_SAMPLED_BY_SECONDARY_CPU + i, + ONE_DEC_UNIT); + publish_1_register(pv.insulation_of_p_to_ground_sensor_, HAVELLS_PV1_INSULATION_OF_P_TO_GROUND + i, NO_DEC_UNIT); } - float frequency = havells_solar_get_1_register(HAVELLS_GRID_FREQUENCY * 2, TWO_DEC_UNIT); - float active_power = havells_solar_get_1_register(HAVELLS_SYSTEM_ACTIVE_POWER * 2, MULTIPLY_TEN_UNIT); - float reactive_power = havells_solar_get_1_register(HAVELLS_SYSTEM_REACTIVE_POWER * 2, TWO_DEC_UNIT); - float today_production = havells_solar_get_1_register(HAVELLS_TODAY_PRODUCTION * 2, TWO_DEC_UNIT); - float total_energy_production = havells_solar_get_2_registers(HAVELLS_TOTAL_ENERGY_PRODUCTION * 2, NO_DEC_UNIT); - float total_generation_time = havells_solar_get_2_registers(HAVELLS_TOTAL_GENERATION_TIME * 2, NO_DEC_UNIT); - float today_generation_time = havells_solar_get_1_register(HAVELLS_TODAY_GENERATION_TIME * 2, NO_DEC_UNIT); - float inverter_module_temp = havells_solar_get_1_register(HAVELLS_INVERTER_MODULE_TEMP * 2, NO_DEC_UNIT); - float inverter_inner_temp = havells_solar_get_1_register(HAVELLS_INVERTER_INNER_TEMP * 2, NO_DEC_UNIT); - float inverter_bus_voltage = havells_solar_get_1_register(HAVELLS_INVERTER_BUS_VOLTAGE * 2, NO_DEC_UNIT); - float insulation_pv_n_to_ground = havells_solar_get_1_register(HAVELLS_INSULATION_OF_PV_N_TO_GROUND * 2, NO_DEC_UNIT); - float gfci_value = havells_solar_get_1_register(HAVELLS_GFCI_VALUE * 2, NO_DEC_UNIT); - float dci_of_r = havells_solar_get_1_register(HAVELLS_DCI_OF_R * 2, NO_DEC_UNIT); - float dci_of_s = havells_solar_get_1_register(HAVELLS_DCI_OF_S * 2, NO_DEC_UNIT); - float dci_of_t = havells_solar_get_1_register(HAVELLS_DCI_OF_T * 2, NO_DEC_UNIT); - - if (this->frequency_sensor_ != nullptr) - this->frequency_sensor_->publish_state(frequency); - if (this->active_power_sensor_ != nullptr) - this->active_power_sensor_->publish_state(active_power); - if (this->reactive_power_sensor_ != nullptr) - this->reactive_power_sensor_->publish_state(reactive_power); - if (this->today_production_sensor_ != nullptr) - this->today_production_sensor_->publish_state(today_production); - if (this->total_energy_production_sensor_ != nullptr) - this->total_energy_production_sensor_->publish_state(total_energy_production); - if (this->total_generation_time_sensor_ != nullptr) - this->total_generation_time_sensor_->publish_state(total_generation_time); - if (this->today_generation_time_sensor_ != nullptr) - this->today_generation_time_sensor_->publish_state(today_generation_time); - if (this->inverter_module_temp_sensor_ != nullptr) - this->inverter_module_temp_sensor_->publish_state(inverter_module_temp); - if (this->inverter_inner_temp_sensor_ != nullptr) - this->inverter_inner_temp_sensor_->publish_state(inverter_inner_temp); - if (this->inverter_bus_voltage_sensor_ != nullptr) - this->inverter_bus_voltage_sensor_->publish_state(inverter_bus_voltage); - if (this->insulation_pv_n_to_ground_sensor_ != nullptr) - this->insulation_pv_n_to_ground_sensor_->publish_state(insulation_pv_n_to_ground); - if (this->gfci_value_sensor_ != nullptr) - this->gfci_value_sensor_->publish_state(gfci_value); - if (this->dci_of_r_sensor_ != nullptr) - this->dci_of_r_sensor_->publish_state(dci_of_r); - if (this->dci_of_s_sensor_ != nullptr) - this->dci_of_s_sensor_->publish_state(dci_of_s); - if (this->dci_of_t_sensor_ != nullptr) - this->dci_of_t_sensor_->publish_state(dci_of_t); + publish_1_register(this->frequency_sensor_, HAVELLS_GRID_FREQUENCY, TWO_DEC_UNIT); + publish_1_register(this->active_power_sensor_, HAVELLS_SYSTEM_ACTIVE_POWER, MULTIPLY_TEN_UNIT); + publish_1_register(this->reactive_power_sensor_, HAVELLS_SYSTEM_REACTIVE_POWER, TWO_DEC_UNIT); + publish_1_register(this->today_production_sensor_, HAVELLS_TODAY_PRODUCTION, TWO_DEC_UNIT); + publish_2_registers(this->total_energy_production_sensor_, HAVELLS_TOTAL_ENERGY_PRODUCTION, NO_DEC_UNIT); + publish_2_registers(this->total_generation_time_sensor_, HAVELLS_TOTAL_GENERATION_TIME, NO_DEC_UNIT); + publish_1_register(this->today_generation_time_sensor_, HAVELLS_TODAY_GENERATION_TIME, NO_DEC_UNIT); + publish_1_register(this->inverter_module_temp_sensor_, HAVELLS_INVERTER_MODULE_TEMP, NO_DEC_UNIT); + publish_1_register(this->inverter_inner_temp_sensor_, HAVELLS_INVERTER_INNER_TEMP, NO_DEC_UNIT); + publish_1_register(this->inverter_bus_voltage_sensor_, HAVELLS_INVERTER_BUS_VOLTAGE, NO_DEC_UNIT); + publish_1_register(this->insulation_pv_n_to_ground_sensor_, HAVELLS_INSULATION_OF_PV_N_TO_GROUND, NO_DEC_UNIT); + publish_1_register(this->gfci_value_sensor_, HAVELLS_GFCI_VALUE, NO_DEC_UNIT); + publish_1_register(this->dci_of_r_sensor_, HAVELLS_DCI_OF_R, NO_DEC_UNIT); + publish_1_register(this->dci_of_s_sensor_, HAVELLS_DCI_OF_S, NO_DEC_UNIT); + publish_1_register(this->dci_of_t_sensor_, HAVELLS_DCI_OF_T, NO_DEC_UNIT); } void HavellsSolar::update() { this->read_holding_registers(0, MODBUS_REGISTER_COUNT); } diff --git a/esphome/components/havells_solar/havells_solar.h b/esphome/components/havells_solar/havells_solar.h index ed5d13b8b6..a77b8bf977 100644 --- a/esphome/components/havells_solar/havells_solar.h +++ b/esphome/components/havells_solar/havells_solar.h @@ -77,7 +77,8 @@ class HavellsSolar final : public PollingComponent, public modbus::ModbusClientD void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_holding_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; void dump_config() override; diff --git a/esphome/components/hbridge/switch/hbridge_switch.cpp b/esphome/components/hbridge/switch/hbridge_switch.cpp index 1012a264f2..c8e472d7aa 100644 --- a/esphome/components/hbridge/switch/hbridge_switch.cpp +++ b/esphome/components/hbridge/switch/hbridge_switch.cpp @@ -29,8 +29,9 @@ void HBridgeSwitch::dump_config() { LOG_PIN(" On Pin: ", this->on_pin_); LOG_PIN(" Off Pin: ", this->off_pin_); ESP_LOGCONFIG(TAG, " Pulse length: %" PRId32 " ms", this->pulse_length_); - if (this->wait_time_) + if (this->wait_time_) { ESP_LOGCONFIG(TAG, " Wait time %" PRId32 " ms", this->wait_time_); + } } void HBridgeSwitch::write_state(bool state) { diff --git a/esphome/components/hdc302x/hdc302x.cpp b/esphome/components/hdc302x/hdc302x.cpp index b50d34169a..53d4c7f016 100644 --- a/esphome/components/hdc302x/hdc302x.cpp +++ b/esphome/components/hdc302x/hdc302x.cpp @@ -38,7 +38,7 @@ void HDC302XComponent::dump_config() { ESP_LOGCONFIG(TAG, "HDC302x:\n" " Heater: %s", - this->heater_active_ ? "active" : "inactive"); + this->heater_active_ ? LOG_STR_LITERAL("active") : LOG_STR_LITERAL("inactive")); LOG_I2C_DEVICE(this); LOG_UPDATE_INTERVAL(this); LOG_SENSOR(" ", "Temperature", this->temp_sensor_); diff --git a/esphome/components/he60r/he60r.cpp b/esphome/components/he60r/he60r.cpp index 84edbb2866..f49224f17c 100644 --- a/esphome/components/he60r/he60r.cpp +++ b/esphome/components/he60r/he60r.cpp @@ -44,8 +44,9 @@ void HE60rCover::dump_config() { " Close Duration: %.1fs", this->open_duration_ / 1e3f, this->close_duration_ / 1e3f); auto restore = this->restore_state_(); - if (restore.has_value()) + if (restore.has_value()) { ESP_LOGCONFIG(TAG, " Saved position %d%%", (int) (restore->position * 100.f)); + } } void HE60rCover::endstop_reached_(CoverOperation operation) { @@ -59,7 +60,7 @@ void HE60rCover::endstop_reached_(CoverOperation operation) { if (this->last_command_ == operation) { float dur = (float) (now - this->start_dir_time_) / 1e3f; ESP_LOGD(TAG, "'%s' - %s endstop reached. Took %.1fs.", this->name_.c_str(), - operation == COVER_OPERATION_OPENING ? "Open" : "Close", dur); + operation == COVER_OPERATION_OPENING ? LOG_STR_LITERAL("Open") : LOG_STR_LITERAL("Close"), dur); } this->publish_state(); } @@ -77,8 +78,9 @@ void HE60rCover::process_rx_(uint8_t data) { ESP_LOGV(TAG, "Process RX data %X", data); if (!this->query_seen_) { this->query_seen_ = data == QUERY_BYTE; - if (!this->query_seen_) + if (!this->query_seen_) { ESP_LOGD(TAG, "RX Byte %02X", data); + } return; } switch (data) { @@ -213,9 +215,9 @@ void HE60rCover::start_direction_(CoverOperation dir) { if (this->current_operation == dir) return; ESP_LOGD(TAG, "'%s' - Direction '%s' requested.", this->name_.c_str(), - dir == COVER_OPERATION_OPENING ? "OPEN" - : dir == COVER_OPERATION_CLOSING ? "CLOSE" - : "STOP"); + dir == COVER_OPERATION_OPENING ? LOG_STR_LITERAL("OPEN") + : dir == COVER_OPERATION_CLOSING ? LOG_STR_LITERAL("CLOSE") + : LOG_STR_LITERAL("STOP")); if (dir == this->next_direction_) { // either moving and needs to stop, or stopped and will move correctly on one trigger diff --git a/esphome/components/hlk_fm22x/hlk_fm22x.cpp b/esphome/components/hlk_fm22x/hlk_fm22x.cpp index 964d26dfbc..a924259802 100644 --- a/esphome/components/hlk_fm22x/hlk_fm22x.cpp +++ b/esphome/components/hlk_fm22x/hlk_fm22x.cpp @@ -336,7 +336,8 @@ void HlkFm22xComponent::dump_config() { } if (this->enrolling_binary_sensor_) { LOG_BINARY_SENSOR(" ", "Enrolling", this->enrolling_binary_sensor_); - ESP_LOGCONFIG(TAG, " Current Value: %s", this->enrolling_binary_sensor_->state ? "ON" : "OFF"); + ESP_LOGCONFIG(TAG, " Current Value: %s", + this->enrolling_binary_sensor_->state ? LOG_STR_LITERAL("ON") : LOG_STR_LITERAL("OFF")); } if (this->face_count_sensor_) { LOG_SENSOR(" ", "Face Count", this->face_count_sensor_); diff --git a/esphome/components/hlw8012/hlw8012.cpp b/esphome/components/hlw8012/hlw8012.cpp index c92c76a20a..9ef81f075d 100644 --- a/esphome/components/hlw8012/hlw8012.cpp +++ b/esphome/components/hlw8012/hlw8012.cpp @@ -97,7 +97,8 @@ void HLW8012Component::update() { if (this->change_mode_every_ != 0 && this->change_mode_at_++ == this->change_mode_every_) { this->current_mode_ = !this->current_mode_; - ESP_LOGV(TAG, "Changing mode to %s mode", this->current_mode_ ? "CURRENT" : "VOLTAGE"); + ESP_LOGV(TAG, "Changing mode to %s mode", + this->current_mode_ ? LOG_STR_LITERAL("CURRENT") : LOG_STR_LITERAL("VOLTAGE")); this->change_mode_at_ = 0; this->sel_pin_->digital_write(this->current_mode_); } diff --git a/esphome/components/hoermann_hcp/hoermann_hcp.cpp b/esphome/components/hoermann_hcp/hoermann_hcp.cpp index 17df927eb7..4aa2c79bb1 100644 --- a/esphome/components/hoermann_hcp/hoermann_hcp.cpp +++ b/esphome/components/hoermann_hcp/hoermann_hcp.cpp @@ -257,8 +257,9 @@ void HoermannHcp::on_state_reg_(uint16_t value) { } } // The low byte can change on its own, so only report a state we cannot decode once. - if (state != (previous >> 8)) + if (state != (previous >> 8)) { ESP_LOGW(TAG, "Unknown door state 0x%02X", state); + } } // Low byte of register 6: bit 0x10 is the lamp, bit 0x04 the relay. The reference implementation records diff --git a/esphome/components/host/__init__.py b/esphome/components/host/__init__.py index 401bba5118..bd074ab6b5 100644 --- a/esphome/components/host/__init__.py +++ b/esphome/components/host/__init__.py @@ -50,6 +50,7 @@ async def to_code(config: ConfigType) -> None: cg.add_define("USE_ESPHOME_HOST_MAC_ADDRESS", config[CONF_MAC_ADDRESS].parts) cg.add_build_flag("-std=gnu++20") cg.add_define("ESPHOME_BOARD", "host") + cg.add_define("ESPHOME_VARIANT", "HOST") cg.add_define(ThreadModel.MULTI_ATOMICS) cg.add_platformio_option("platform", "platformio/native") cg.add_platformio_option("lib_ldf_mode", "off") diff --git a/esphome/components/ili9xxx/ili9xxx_display.cpp b/esphome/components/ili9xxx/ili9xxx_display.cpp index e8840c0cf1..0ed18c45da 100644 --- a/esphome/components/ili9xxx/ili9xxx_display.cpp +++ b/esphome/components/ili9xxx/ili9xxx_display.cpp @@ -116,8 +116,8 @@ void ILI9XXXDisplay::dump_config() { " Mirror_x: %s\n" " Mirror_y: %s\n" " Invert colors: %s", - this->color_order_ == display::COLOR_ORDER_BGR ? "BGR" : "RGB", YESNO(this->swap_xy_), - YESNO(this->mirror_x_), YESNO(this->mirror_y_), YESNO(this->pre_invertcolors_)); + this->color_order_ == display::COLOR_ORDER_BGR ? LOG_STR_LITERAL("BGR") : LOG_STR_LITERAL("RGB"), + YESNO(this->swap_xy_), YESNO(this->mirror_x_), YESNO(this->mirror_y_), YESNO(this->pre_invertcolors_)); if (this->is_failed()) { ESP_LOGCONFIG(TAG, " => Failed to init Memory: YES!"); diff --git a/esphome/components/improv_base/__init__.py b/esphome/components/improv_base/__init__.py index f132dbacb0..412d143a48 100644 --- a/esphome/components/improv_base/__init__.py +++ b/esphome/components/improv_base/__init__.py @@ -43,4 +43,4 @@ async def setup_improv_core(var: MockObj, config: ConfigType, component: str) -> cg.add(var.set_next_url(_process_next_url(next_url))) cg.add_define(f"USE_{component.upper()}_NEXT_URL") - cg.add_library("improv/Improv", "1.2.6") + cg.add_library("improv/Improv", "1.2.7") diff --git a/esphome/components/improv_base/improv_base.cpp b/esphome/components/improv_base/improv_base.cpp index fa1b855d6c..1babeb5b5a 100644 --- a/esphome/components/improv_base/improv_base.cpp +++ b/esphome/components/improv_base/improv_base.cpp @@ -4,10 +4,13 @@ #include "esphome/components/network/util.h" #include "esphome/core/application.h" #include "esphome/core/defines.h" +#include "esphome/core/log.h" namespace esphome::improv_base { #if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL) +static const char *const TAG = "improv_base"; + static constexpr const char DEVICE_NAME_PLACEHOLDER[] = "{{device_name}}"; static constexpr size_t DEVICE_NAME_PLACEHOLDER_LEN = sizeof(DEVICE_NAME_PLACEHOLDER) - 1; static constexpr const char IP_ADDRESS_PLACEHOLDER[] = "{{ip_address}}"; @@ -62,6 +65,21 @@ size_t ImprovBase::get_formatted_next_url_(char *buffer, size_t buffer_size) { *out = '\0'; return out - buffer; } + +void ImprovBase::add_next_url_(improv::RpcResponseBuilder &builder, size_t max_len) { + // The builder rejects strings above 254 bytes, so anything longer than this + // buffer could never be sent anyway + char url_buffer[256]; + size_t len = this->get_formatted_next_url_(url_buffer, sizeof(url_buffer)); + if (len == 0) { + return; + } + // max_len is the transport's budget for this entry; skipping an over-long URL + // here keeps the rest of the response sendable instead of oversizing the frame + if (len > max_len || !builder.add_string(url_buffer, len)) { + ESP_LOGW(TAG, "Next URL too long; skipping"); + } +} #endif } // namespace esphome::improv_base diff --git a/esphome/components/improv_base/improv_base.h b/esphome/components/improv_base/improv_base.h index 9dded85a46..352bb75d5f 100644 --- a/esphome/components/improv_base/improv_base.h +++ b/esphome/components/improv_base/improv_base.h @@ -3,6 +3,10 @@ #include #include "esphome/core/defines.h" +#if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL) +#include +#endif + namespace esphome::improv_base { class ImprovBase { @@ -15,6 +19,8 @@ class ImprovBase { #if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL) /// Format next_url_ into buffer, replacing placeholders. Returns length written. size_t get_formatted_next_url_(char *buffer, size_t buffer_size); + /// Append the formatted next_url to the RPC response, warning if it does not fit. + void add_next_url_(improv::RpcResponseBuilder &builder, size_t max_len); const char *next_url_{nullptr}; #endif }; diff --git a/esphome/components/improv_serial/__init__.py b/esphome/components/improv_serial/__init__.py index 40ef14c6bc..a34e2ab793 100644 --- a/esphome/components/improv_serial/__init__.py +++ b/esphome/components/improv_serial/__init__.py @@ -1,29 +1,57 @@ import esphome.codegen as cg -from esphome.components import improv_base +from esphome.components import improv_base, uart from esphome.components.esp32 import VARIANT_ESP32S3, get_esp32_variant from esphome.components.logger import USB_CDC import esphome.config_validation as cv -from esphome.const import CONF_BAUD_RATE, CONF_HARDWARE_UART, CONF_ID, CONF_LOGGER +from esphome.const import ( + CONF_BAUD_RATE, + CONF_HARDWARE_UART, + CONF_ID, + CONF_LOGGER, + CONF_UART_ID, +) from esphome.core import CORE import esphome.final_validate as fv from esphome.types import ConfigType AUTO_LOAD = ["improv_base"] CODEOWNERS = ["@esphome/core"] -DEPENDENCIES = ["logger", "wifi"] +DEPENDENCIES = ["logger", "network"] improv_serial_ns = cg.esphome_ns.namespace("improv_serial") ImprovSerialComponent = improv_serial_ns.class_("ImprovSerialComponent", cg.Component) CONFIG_SCHEMA = ( - cv.Schema({cv.GenerateID(): cv.declare_id(ImprovSerialComponent)}) + cv.Schema( + { + cv.GenerateID(): cv.declare_id(ImprovSerialComponent), + # YAML only: rewiring Improv onto another UART is not a knob for a + # visual editor and the device builder must not expose it + cv.Optional(CONF_UART_ID, visibility=cv.Visibility.YAML_ONLY): cv.use_id( + uart.UARTComponent + ), + } + ) .extend(improv_base.IMPROV_SCHEMA) .extend(cv.COMPONENT_SCHEMA) ) -def validate_logger(config: ConfigType) -> None: +_UART_FINAL_VALIDATE = uart.final_validate_device_schema( + "improv_serial", require_tx=True, require_rx=True +) + + +def validate_transport(config: ConfigType) -> None: + if CONF_UART_ID in config: + # A dedicated UART bus is used; the logger's serial settings are irrelevant, + # but the bus itself must be bidirectional and not claimed by another device + _UART_FINAL_VALIDATE(config) + return + # The host logger has no serial port for Improv to share + if CORE.is_host: + raise cv.Invalid("improv_serial on the host platform requires uart_id") logger_conf = fv.full_config.get()[CONF_LOGGER] if logger_conf[CONF_BAUD_RATE] == 0: raise cv.Invalid("improv_serial requires the logger baud_rate to be not 0") @@ -36,7 +64,7 @@ def validate_logger(config: ConfigType) -> None: ) -FINAL_VALIDATE_SCHEMA = validate_logger +FINAL_VALIDATE_SCHEMA = validate_transport async def to_code(config: ConfigType) -> None: @@ -44,3 +72,6 @@ async def to_code(config: ConfigType) -> None: await cg.register_component(var, config) await improv_base.setup_improv_core(var, config, "improv_serial") cg.add_define("USE_IMPROV_SERIAL") + if (uart_id := config.get(CONF_UART_ID)) is not None: + cg.add(var.set_uart(await cg.get_variable(uart_id))) + cg.add_define("USE_IMPROV_SERIAL_UART") diff --git a/esphome/components/improv_serial/improv_serial_component.cpp b/esphome/components/improv_serial/improv_serial_component.cpp index de9c7899cd..ffa7b79d9b 100644 --- a/esphome/components/improv_serial/improv_serial_component.cpp +++ b/esphome/components/improv_serial/improv_serial_component.cpp @@ -1,5 +1,5 @@ #include "improv_serial_component.h" -#ifdef USE_WIFI +#ifdef USE_IMPROV_SERIAL #include "esphome/core/application.h" #include "esphome/core/defines.h" #include "esphome/core/hal.h" @@ -7,7 +7,12 @@ #include "esphome/core/version.h" #include "esphome/components/logger/logger.h" +#include "esphome/components/network/util.h" +#ifdef USE_WIFI #include "esphome/components/wifi/scan_list.h" +#endif + +#include namespace esphome::improv_serial { @@ -15,20 +20,26 @@ static const char *const TAG = "improv_serial"; void ImprovSerialComponent::setup() { global_improv_serial_component = this; -#ifdef USE_ESP32 +#ifdef USE_IMPROV_SERIAL_UART + // Transport is a dedicated UART bus set via set_uart() in generated code +#elif defined(USE_ESP32) this->uart_num_ = logger::global_logger->get_uart_num(); this->uart_selection_ = logger::global_logger->get_uart(); #elif defined(USE_ARDUINO) this->hw_serial_ = logger::global_logger->get_hw_serial(); #endif - if (wifi::global_wifi_component->has_sta()) { + // The Improv state machine tracks Wi-Fi provisioning only. General device + // connectivity (e.g. Ethernet) is reported separately via GET_NETWORK_STATE. +#ifdef USE_WIFI + if (wifi::global_wifi_component != nullptr && wifi::global_wifi_component->has_sta()) { this->state_ = improv::STATE_PROVISIONED; - } else if (!wifi::global_wifi_component->is_disabled()) { + } else if (wifi::global_wifi_component != nullptr && !wifi::global_wifi_component->is_disabled()) { // Respect Wi-Fi's disabled state; forcing a scan while disabled throws // the wifi component into an invalid state from which it cannot recover. wifi::global_wifi_component->start_scanning(); } +#endif } void ImprovSerialComponent::loop() { @@ -51,18 +62,24 @@ void ImprovSerialComponent::loop() { } } - if (this->state_ == improv::STATE_PROVISIONING) { - if (wifi::global_wifi_component->is_connected()) { +#ifdef USE_WIFI + if (this->state_ == improv::STATE_PROVISIONING && wifi::global_wifi_component != nullptr && + wifi::global_wifi_component->is_connected()) { + // Being connected is not enough: re-provisioning a device that is already online leaves the + // prior network up until it drops, so check that the joined network is the requested one + // before reporting success. Same test as the wifi.connect action. + char ssid_buf[wifi::SSID_BUFFER_SIZE]; + if (strcmp(wifi::global_wifi_component->wifi_ssid_to(ssid_buf), this->connecting_sta_.get_ssid().c_str()) == 0) { wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(), this->connecting_sta_.get_password()); this->connecting_sta_ = {}; this->cancel_timeout("wifi-connect-timeout"); this->set_state_(improv::STATE_PROVISIONED); - std::vector url = this->build_rpc_settings_response_(improv::WIFI_SETTINGS); - this->send_response_(url); + this->send_settings_response_(improv::WIFI_SETTINGS); } } +#endif } void ImprovSerialComponent::dump_config() { ESP_LOGCONFIG(TAG, "Improv Serial:"); } @@ -89,7 +106,13 @@ void ImprovSerialComponent::write_data_(const uint8_t *data, const size_t size) } this->tx_header_[TX_CHECKSUM_IDX] = checksum; -#ifdef USE_ESP32 +#ifdef USE_IMPROV_SERIAL_UART + this->uart_->write_array(this->tx_header_, header_tx_len); + if (there_is_data) { + this->uart_->write_array(data, size); + this->uart_->write_array(&this->tx_header_[TX_CHECKSUM_IDX], 2); // Footer: checksum and newline + } +#elif defined(USE_ESP32) switch (this->uart_selection_) { case logger::UART_SELECTION_UART0: case logger::UART_SELECTION_UART1: @@ -134,43 +157,112 @@ void ImprovSerialComponent::write_data_(const uint8_t *data, const size_t size) #endif } -std::vector ImprovSerialComponent::build_rpc_settings_response_(improv::Command command) { - std::vector urls; -#ifdef USE_IMPROV_SERIAL_NEXT_URL - { - char url_buffer[384]; - size_t len = this->get_formatted_next_url_(url_buffer, sizeof(url_buffer)); - if (len > 0) { - urls.emplace_back(url_buffer, len); - } - } -#endif #ifdef USE_WEBSERVER - for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) { - if (ip.is_ip4()) { +void ImprovSerialComponent::add_webserver_urls_(improv::RpcResponseBuilder &builder, [[maybe_unused]] bool wifi_first) { + // The webserver listens on every interface, so advertise each one that has a usable IPv4. + // network::get_ip_addresses() can't be used here: it returns only the highest-priority + // interface's addresses, which are all-unset (0.0.0.0) when e.g. Ethernet has no link while + // the device is online via Wi-Fi, and 0.0.0.0 must not become the advertised URL. OpenThread + // is omitted: it only ever has IPv6 addresses, which cannot form an IPv4 http:// URL. + const auto append_urls = [&builder](const network::IPAddresses &addresses) { + for (const auto &ip : addresses) { + if (!ip.is_ip4() || !ip.is_set()) + continue; char ip_buf[network::IP_ADDRESS_BUFFER_SIZE]; ip.str_to(ip_buf); // "http://" (7) + IP (40) + ":" (1) + port (5) + null (1) = 54 char webserver_url[7 + network::IP_ADDRESS_BUFFER_SIZE + 1 + 5 + 1]; - snprintf(webserver_url, sizeof(webserver_url), "http://%s:%u", ip_buf, USE_WEBSERVER_PORT); - urls.emplace_back(webserver_url); - break; + // buf_append_printf keeps the format string in flash on ESP8266 + size_t len = + buf_append_printf(webserver_url, sizeof(webserver_url), 0, "http://%s:%u", ip_buf, USE_WEBSERVER_PORT); + if (!builder.add_string(webserver_url, len)) { + ESP_LOGW(TAG, "Response full; URL dropped"); + } } - } + }; +#ifdef USE_WIFI + // Clients redirect to the first URL, so the interface the client just configured has to lead: + // another interface's address can be on a subnet that client cannot reach. + const auto append_wifi_urls = [&append_urls]() { + if (wifi::global_wifi_component != nullptr) + append_urls(wifi::global_wifi_component->get_ip_addresses()); + }; + if (wifi_first) + append_wifi_urls(); #endif - std::vector data = improv::build_rpc_response(command, urls, false); - return data; +#ifdef USE_ETHERNET + if (ethernet::global_eth_component != nullptr) + append_urls(ethernet::global_eth_component->get_ip_addresses()); +#endif +#ifdef USE_MODEM + if (modem::global_modem_component != nullptr) + append_urls(modem::global_modem_component->get_ip_addresses()); +#endif +#ifdef USE_WIFI + if (!wifi_first) + append_wifi_urls(); +#endif +} +#endif // USE_WEBSERVER + +void ImprovSerialComponent::send_settings_response_(improv::Command command) { + std::array buf; + improv::RpcResponseBuilder builder(buf, command); +#ifdef USE_IMPROV_SERIAL_NEXT_URL + this->add_next_url_(builder, MAX_NEXT_URL_LEN); +#endif +#ifdef USE_WEBSERVER + // This response only ever answers Wi-Fi provisioning, so lead with the Wi-Fi URL as it did + // before other interfaces were reported. + this->add_webserver_urls_(builder, /*wifi_first=*/true); +#endif + this->send_response_(builder.finish(false)); } -std::vector ImprovSerialComponent::build_version_info_() { +void ImprovSerialComponent::send_version_info_() { +// Entry cost per field is sizeof(lit): a length byte plus the string #ifdef ESPHOME_PROJECT_NAME - std::vector infos = {ESPHOME_PROJECT_NAME, ESPHOME_PROJECT_VERSION, ESPHOME_VARIANT, App.get_name()}; + static constexpr size_t INFO_ENTRIES_LEN = + sizeof(ESPHOME_PROJECT_NAME) + sizeof(ESPHOME_PROJECT_VERSION) + sizeof(ESPHOME_VARIANT); #else - std::vector infos = {"ESPHome", ESPHOME_VERSION, ESPHOME_VARIANT, App.get_name()}; + static constexpr size_t INFO_ENTRIES_LEN = sizeof("ESPHome") + sizeof(ESPHOME_VERSION) + sizeof(ESPHOME_VARIANT); #endif - std::vector data = improv::build_rpc_response(improv::GET_DEVICE_INFO, infos, false); - return data; -}; + static_assert(INFO_ENTRIES_LEN < MAX_SERIAL_PAYLOAD, + "esphome project name and version too long for the improv_serial device info frame"); + std::array buf; + improv::RpcResponseBuilder builder(buf, improv::GET_DEVICE_INFO); +#ifdef USE_ESP8266 + // Keep each literal in flash and copy it through an exact size stack buffer, + // so a long project name or version can never be truncated +#define IMPROV_ADD_INFO(lit) \ + do { \ + static const char progmem_str[] PROGMEM = lit; \ + char tmp[sizeof(lit)]; \ + progmem_memcpy(tmp, progmem_str, sizeof(lit)); \ + builder.add_string(tmp, sizeof(lit) - 1); \ + } while (0) +#else + // Literals are directly flash mapped on all other platforms +#define IMPROV_ADD_INFO(lit) builder.add_string(lit, sizeof(lit) - 1) +#endif +#ifdef ESPHOME_PROJECT_NAME + IMPROV_ADD_INFO(ESPHOME_PROJECT_NAME); + IMPROV_ADD_INFO(ESPHOME_PROJECT_VERSION); +#else + IMPROV_ADD_INFO("ESPHome"); + IMPROV_ADD_INFO(ESPHOME_VERSION); +#endif + IMPROV_ADD_INFO(ESPHOME_VARIANT); +#undef IMPROV_ADD_INFO + // Only the device name length is unknown at compile time + const auto &name = App.get_name(); + if (INFO_ENTRIES_LEN + 1 + name.size() <= MAX_SERIAL_PAYLOAD) { + builder.add_string(name.c_str(), name.size()); + } else { + ESP_LOGW(TAG, "Response full; device name dropped"); + } + this->send_response_(builder.finish(false)); +} bool ImprovSerialComponent::parse_improv_serial_byte_(uint8_t byte) { size_t at = this->rx_buffer_.size(); @@ -189,7 +281,8 @@ bool ImprovSerialComponent::parse_improv_serial_byte_(uint8_t byte) { bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command) { switch (command.command) { case improv::WIFI_SETTINGS: { - if (wifi::global_wifi_component->is_disabled()) { +#ifdef USE_WIFI + if (wifi::global_wifi_component == nullptr || wifi::global_wifi_component->is_disabled()) { // Wi-Fi is disabled, so we can't provision. Respond immediately // instead of letting the client wait out its provisioning timeout. ESP_LOGW(TAG, "Wi-Fi is disabled; cannot provision"); @@ -201,36 +294,52 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command sta.set_password(command.password.c_str()); this->connecting_sta_ = sta; + // Sampled before start_connecting(): the old connection drops asynchronously after it. + const bool switching = wifi::global_wifi_component->is_connected(); wifi::global_wifi_component->set_sta(sta); wifi::global_wifi_component->start_connecting(sta); this->set_state_(improv::STATE_PROVISIONING); ESP_LOGD(TAG, "Received settings: SSID=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(), command.password.c_str()); - this->set_timeout("wifi-connect-timeout", 30000, [this]() { this->on_wifi_connect_timeout_(); }); + this->set_timeout("wifi-connect-timeout", switching ? WIFI_SWITCH_TIMEOUT_MS : WIFI_CONNECT_TIMEOUT_MS, + [this]() { this->on_wifi_connect_timeout_(); }); +#else + // No Wi-Fi support compiled in; there is nothing to provision. + ESP_LOGW(TAG, "Wi-Fi not supported; cannot provision"); + this->set_error_(improv::ERROR_UNABLE_TO_CONNECT); +#endif return true; } - case improv::GET_CURRENT_STATE: - if (wifi::global_wifi_component->is_disabled()) { - // Wi-Fi is disabled; report the Improv "stopped" state so a client can tell - // the user that provisioning is unavailable. Reported transiently without - // disturbing our internal provisioning state machine, so a later `wifi.enable` - // still reports the correct state. + case improv::GET_CURRENT_STATE: { + // This state machine tracks Wi-Fi provisioning only. When Wi-Fi is disabled or not + // compiled in, provisioning is unavailable -> report STOPPED so the client doesn't + // offer a Wi-Fi form. General connectivity (e.g. Ethernet) is reported separately + // via GET_NETWORK_STATE. +#ifdef USE_WIFI + if (wifi::global_wifi_component == nullptr || wifi::global_wifi_component->is_disabled()) { + // Reported transiently without disturbing our internal provisioning state machine, + // so a later `wifi.enable` still reports the correct state. this->send_current_state_(improv::STATE_STOPPED); return true; } this->set_state_(this->state_); if (this->state_ == improv::STATE_PROVISIONED) { - std::vector url = this->build_rpc_settings_response_(improv::GET_CURRENT_STATE); - this->send_response_(url); + this->send_settings_response_(improv::GET_CURRENT_STATE); } +#else + this->send_current_state_(improv::STATE_STOPPED); +#endif return true; + } case improv::GET_DEVICE_INFO: { - std::vector info = this->build_version_info_(); - this->send_response_(info); + this->send_version_info_(); return true; } case improv::GET_WIFI_NETWORKS: { + // Declared out here because the terminating empty response is sent with or without Wi-Fi + std::array buf; +#ifdef USE_WIFI const auto &results = wifi::global_wifi_component->get_scan_result(); for (const auto &scan : results) { bool with_auth = false; @@ -238,15 +347,60 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command continue; // Send each ssid separately to avoid overflowing the buffer char rssi_buf[5]; // int8_t: -128 to 127, max 4 chars + null - *int8_to_str(rssi_buf, scan.get_rssi()) = '\0'; - std::vector data = improv::build_rpc_response( - improv::GET_WIFI_NETWORKS, {scan.get_ssid().str(), rssi_buf, YESNO(with_auth)}, false); - this->send_response_(data); + char *rssi_end = int8_to_str(rssi_buf, scan.get_rssi()); + *rssi_end = '\0'; + improv::RpcResponseBuilder builder(buf, improv::GET_WIFI_NETWORKS); + // SSID(32) + RSSI(4) + YESNO(3) entries always fit the payload + const auto &ssid = scan.get_ssid(); + builder.add_string(ssid.c_str(), ssid.size()); + builder.add_string(rssi_buf, rssi_end - rssi_buf); + builder.add_string(YESNO(with_auth)); + this->send_response_(builder.finish(false)); } +#endif // USE_WIFI // Send empty response to signify the end of the list. - std::vector data = - improv::build_rpc_response(improv::GET_WIFI_NETWORKS, std::vector{}, false); - this->send_response_(data); + improv::RpcResponseBuilder builder(buf, improv::GET_WIFI_NETWORKS); + this->send_response_(builder.finish(false)); + return true; + } + case improv::GET_NETWORK_STATE: { + // Reports general device connectivity and which network interfaces are present, decoupled + // from the Wi-Fi-only provisioning state machine. data[0] is a decimal flags byte; + // when online, the reachable device URL(s) follow. + uint8_t flags = 0; + if (network::is_connected()) + flags |= improv::NETWORK_IS_ONLINE; +#ifdef USE_WIFI + flags |= improv::NETWORK_SUPPORTS_WIFI; +#endif +#ifdef USE_ETHERNET + flags |= improv::NETWORK_SUPPORTS_ETHERNET; +#endif +#ifdef USE_OPENTHREAD + flags |= improv::NETWORK_SUPPORTS_THREAD; +#endif +#ifdef USE_MODEM + flags |= improv::NETWORK_SUPPORTS_MODEM; +#endif + std::array buf; + improv::RpcResponseBuilder builder(buf, improv::GET_NETWORK_STATE); + // Every flag bit fits int8_t's positive range, so int8_to_str renders the byte + static_assert(improv::NETWORK_SUPPORTS_MODEM <= 0x7F, "network flags no longer fit int8_to_str"); + char flags_buf[4]; // uint8_t: max "255" + null + char *flags_end = int8_to_str(flags_buf, static_cast(flags)); + builder.add_string(flags_buf, flags_end - flags_buf); +#ifdef USE_WEBSERVER + // Not tied to one interface, so follow the configured priority the way + // network::get_ip_addresses() does: a wifi-first network priority list leads with Wi-Fi. + if (flags & improv::NETWORK_IS_ONLINE) { +#if defined(USE_NETWORK_PRIMARY_INTERFACE_WIFI) && defined(USE_WIFI) + this->add_webserver_urls_(builder, /*wifi_first=*/true); +#else + this->add_webserver_urls_(builder, /*wifi_first=*/false); +#endif + } +#endif + this->send_response_(builder.finish(false)); return true; } default: { @@ -274,17 +428,26 @@ void ImprovSerialComponent::set_error_(improv::Error error) { this->write_data_(); } -void ImprovSerialComponent::send_response_(std::vector &response) { +void ImprovSerialComponent::send_response_(std::span response) { + // The serial frame length field is a single byte + if (response.size() > MAX_SERIAL_RESPONSE) { + ESP_LOGE(TAG, "Response too long"); + // Fail fast instead of leaving the client to wait out its timeout + this->set_error_(improv::ERROR_UNKNOWN); + return; + } this->tx_header_[TX_TYPE_IDX] = TYPE_RPC_RESPONSE; this->write_data_(response.data(), response.size()); } +#ifdef USE_WIFI void ImprovSerialComponent::on_wifi_connect_timeout_() { this->set_error_(improv::ERROR_UNABLE_TO_CONNECT); this->set_state_(improv::STATE_AUTHORIZED); ESP_LOGW(TAG, "Timed out while connecting to Wi-Fi network"); wifi::global_wifi_component->clear_sta(); } +#endif ImprovSerialComponent *global_improv_serial_component = // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) diff --git a/esphome/components/improv_serial/improv_serial_component.h b/esphome/components/improv_serial/improv_serial_component.h index 00c40c4c7e..68cdd75214 100644 --- a/esphome/components/improv_serial/improv_serial_component.h +++ b/esphome/components/improv_serial/improv_serial_component.h @@ -2,15 +2,22 @@ #include "esphome/components/improv_base/improv_base.h" #include "esphome/components/logger/logger.h" -#include "esphome/components/wifi/wifi_component.h" +#include "esphome/components/network/util.h" #include "esphome/core/component.h" #include "esphome/core/defines.h" #include "esphome/core/helpers.h" -#ifdef USE_WIFI +#ifdef USE_IMPROV_SERIAL #include +#include #include -#ifdef USE_ESP32 +#ifdef USE_WIFI +#include "esphome/components/wifi/wifi_component.h" +#endif + +#ifdef USE_IMPROV_SERIAL_UART +#include "esphome/components/uart/uart_component.h" +#elif defined(USE_ESP32) #include #ifdef USE_LOGGER_USB_SERIAL_JTAG #include @@ -45,6 +52,31 @@ enum ImprovSerialType : uint8_t { static const uint16_t IMPROV_SERIAL_TIMEOUT = 100; static const uint8_t IMPROV_SERIAL_VERSION = 1; +#ifdef USE_WIFI +// Wi-Fi connect failure timers: a fresh provision reports at 30 s (stock behavior), while +// switching networks on an already-connected device (disconnect + reconnect) can legitimately +// take longer; 90 s matches esp32_improv's default wifi_timeout. +static const uint32_t WIFI_CONNECT_TIMEOUT_MS = 30000; +static const uint32_t WIFI_SWITCH_TIMEOUT_MS = 90000; +#endif + +// The serial frame length field is one byte +static constexpr size_t MAX_SERIAL_RESPONSE = 255; +// command + data length + trailing byte +static constexpr size_t RPC_RESPONSE_OVERHEAD = 3; +static constexpr size_t MAX_SERIAL_PAYLOAD = MAX_SERIAL_RESPONSE - RPC_RESPONSE_OVERHEAD; +#ifdef USE_WEBSERVER +// length byte + "http://" + IPv4 + ":" + port. Reserves the first URL only; a device with +// several interfaces online adds the rest best-effort and warns if one no longer fits. +static constexpr size_t WEBSERVER_URL_RESERVE = 1 + 7 + 15 + 1 + 5; +#else +static constexpr size_t WEBSERVER_URL_RESERVE = 0; +#endif +// Entry budget minus its own length byte +static constexpr size_t MAX_NEXT_URL_LEN = MAX_SERIAL_PAYLOAD - WEBSERVER_URL_RESERVE - 1; + +static_assert(MAX_SERIAL_RESPONSE <= improv::RPC_RESPONSE_MAX_SIZE, "builder buffer too small for the frame"); + class ImprovSerialComponent final : public Component, public improv_base::ImprovBase { public: void setup() override; @@ -53,6 +85,10 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } +#ifdef USE_IMPROV_SERIAL_UART + void set_uart(uart::UARTComponent *uart) { this->uart_ = uart; } +#endif + protected: bool parse_improv_serial_byte_(uint8_t byte); bool parse_improv_payload_(improv::ImprovCommand &command); @@ -60,16 +96,27 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv void set_state_(improv::State state); void send_current_state_(improv::State state); void set_error_(improv::Error error); - void send_response_(std::vector &response); + void send_response_(std::span response); +#ifdef USE_WIFI void on_wifi_connect_timeout_(); +#endif - std::vector build_rpc_settings_response_(improv::Command command); - std::vector build_version_info_(); +#ifdef USE_WEBSERVER + /// Append one web server URL per interface that has a usable IPv4. With wifi_first the Wi-Fi + /// URL leads, for responses to Wi-Fi provisioning; otherwise interfaces go in priority order. + void add_webserver_urls_(improv::RpcResponseBuilder &builder, [[maybe_unused]] bool wifi_first); +#endif + void send_settings_response_(improv::Command command); + void send_version_info_(); ESPHOME_ALWAYS_INLINE optional read_byte_() { optional byte; uint8_t data = 0; -#ifdef USE_ESP32 +#ifdef USE_IMPROV_SERIAL_UART + if (this->uart_->available() && this->uart_->read_byte(&data)) { + byte = data; + } +#elif defined(USE_ESP32) switch (this->uart_selection_) { case logger::UART_SELECTION_UART0: case logger::UART_SELECTION_UART1: @@ -129,7 +176,9 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv '\n', }; -#ifdef USE_ESP32 +#ifdef USE_IMPROV_SERIAL_UART + uart::UARTComponent *uart_{nullptr}; +#elif defined(USE_ESP32) uart_port_t uart_num_; logger::UARTSelection uart_selection_{logger::UART_SELECTION_UART0}; #elif defined(USE_ARDUINO) @@ -138,7 +187,9 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv std::vector rx_buffer_; uint32_t last_read_byte_{0}; +#ifdef USE_WIFI wifi::WiFiAP connecting_sta_; +#endif improv::State state_{improv::STATE_AUTHORIZED}; }; diff --git a/esphome/components/ina2xx_base/ina2xx_base.cpp b/esphome/components/ina2xx_base/ina2xx_base.cpp index d3acf00eef..fec5cd2f13 100644 --- a/esphome/components/ina2xx_base/ina2xx_base.cpp +++ b/esphome/components/ina2xx_base/ina2xx_base.cpp @@ -209,7 +209,8 @@ void INA2XX::dump_config() { " CURRENT_LSB = %f\n" " SHUNT_CAL = %d", this->shunt_resistance_ohm_, this->max_current_a_, this->shunt_tempco_ppm_c_, - (uint8_t) this->adc_range_, this->adc_range_ ? "±40.96 mV" : "±163.84 mV", this->current_lsb_, + (uint8_t) this->adc_range_, + this->adc_range_ ? LOG_STR_LITERAL("±40.96 mV") : LOG_STR_LITERAL("±163.84 mV"), this->current_lsb_, this->shunt_cal_); ESP_LOGCONFIG(TAG, " ADC Samples = %d; ADC times: Bus = %d μs, Shunt = %d μs, Temp = %d μs", diff --git a/esphome/components/internal_temperature/sensor.py b/esphome/components/internal_temperature/sensor.py index d3101f4a7c..40ac216f0c 100644 --- a/esphome/components/internal_temperature/sensor.py +++ b/esphome/components/internal_temperature/sensor.py @@ -1,5 +1,7 @@ import esphome.codegen as cg from esphome.components import sensor +from esphome.components.esp32 import get_esp32_variant, include_builtin_idf_component +from esphome.components.esp32.const import VARIANT_ESP32 from esphome.components.zephyr import zephyr_add_prj_conf from esphome.config_helpers import filter_source_files_from_platform import esphome.config_validation as cv @@ -48,6 +50,10 @@ async def to_code(config: ConfigType) -> None: var = await sensor.new_sensor(config) await cg.register_component(var, config) + if CORE.is_esp32 and get_esp32_variant() == VARIANT_ESP32: + # temprature_sens_read() lives in the esp_phy blob, which is excluded by default + include_builtin_idf_component("esp_phy") + if CORE.using_zephyr and CORE.is_nrf52: zephyr_add_prj_conf("SENSOR", True) zephyr_add_prj_conf("TEMP_NRF5", True) diff --git a/esphome/components/it8951/it8951.cpp b/esphome/components/it8951/it8951.cpp index cc2bddeda7..179c2e5f63 100644 --- a/esphome/components/it8951/it8951.cpp +++ b/esphome/components/it8951/it8951.cpp @@ -740,7 +740,7 @@ bool IT8951Display::prepare_update_region_(UpdateMode &mode) { this->reset_dirty_region_(); ESP_LOGV(TAG, "Update: %ux%u@%u,%u mode=%u (%s)", width, height, x, y, static_cast(mode), - this->grayscale_ ? "grayscale" : "mono"); + this->grayscale_ ? LOG_STR_LITERAL("grayscale") : LOG_STR_LITERAL("mono")); return true; } @@ -1063,25 +1063,27 @@ void IT8951Display::dump_config() { strncpy(force_temperature, "(controller default)", sizeof(force_temperature)); force_temperature[sizeof(force_temperature) - 1] = '\0'; } - ESP_LOGCONFIG(TAG, - " Model preset: %s" - "\n Dimensions: %dx%d" - "\n Buffer: %u bytes" - "\n Image buffer addr: 0x%04X%04X" - "\n VCOM: %.02fV (set selector 0x%04X)" - "\n Force temperature: %s" - "\n Display command: %s" - "\n Sleep when done: %s" - "\n Full update every: %u" - "\n Inverted colors: %s" - "\n Pixel format: %s" - "\n Reset duration: %" PRIu32 "ms", - this->name_ != nullptr ? this->name_ : "(unknown)", this->get_width_internal(), - this->get_height_internal(), static_cast(this->buffer_length_), this->img_buf_addr_h_, - this->img_buf_addr_l_, static_cast(this->vcom_) / 1000.0f, this->vcom_register_, - force_temperature, this->use_legacy_dpy_area_ ? "DPY_AREA (0x0034, legacy)" : "DPY_BUF_AREA (0x0037)", - YESNO(this->sleep_when_done_), this->full_update_every_, YESNO(this->invert_colors_), - this->grayscale_ ? "4bpp grayscale" : "1bpp monochrome", this->reset_duration_); + ESP_LOGCONFIG( + TAG, + " Model preset: %s" + "\n Dimensions: %dx%d" + "\n Buffer: %u bytes" + "\n Image buffer addr: 0x%04X%04X" + "\n VCOM: %.02fV (set selector 0x%04X)" + "\n Force temperature: %s" + "\n Display command: %s" + "\n Sleep when done: %s" + "\n Full update every: %u" + "\n Inverted colors: %s" + "\n Pixel format: %s" + "\n Reset duration: %" PRIu32 "ms", + this->name_ != nullptr ? this->name_ : LOG_STR_LITERAL("(unknown)"), this->get_width_internal(), + this->get_height_internal(), static_cast(this->buffer_length_), this->img_buf_addr_h_, + this->img_buf_addr_l_, static_cast(this->vcom_) / 1000.0f, this->vcom_register_, force_temperature, + this->use_legacy_dpy_area_ ? LOG_STR_LITERAL("DPY_AREA (0x0034, legacy)") + : LOG_STR_LITERAL("DPY_BUF_AREA (0x0037)"), + YESNO(this->sleep_when_done_), this->full_update_every_, YESNO(this->invert_colors_), + this->grayscale_ ? LOG_STR_LITERAL("4bpp grayscale") : LOG_STR_LITERAL("1bpp monochrome"), this->reset_duration_); LOG_PIN(" Reset Pin: ", this->reset_pin_); LOG_PIN(" Busy Pin: ", this->busy_pin_); LOG_PIN(" CS Pin: ", this->cs_); diff --git a/esphome/components/key_collector/key_collector.cpp b/esphome/components/key_collector/key_collector.cpp index 69b7a6a7c6..42f02d39d4 100644 --- a/esphome/components/key_collector/key_collector.cpp +++ b/esphome/components/key_collector/key_collector.cpp @@ -16,26 +16,33 @@ void KeyCollector::loop() { void KeyCollector::dump_config() { #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_CONFIG ESP_LOGCONFIG(TAG, "Key Collector:"); - if (this->min_length_ > 0) + if (this->min_length_ > 0) { ESP_LOGCONFIG(TAG, " min length: %d", this->min_length_); - if (this->max_length_ > 0) + } + if (this->max_length_ > 0) { ESP_LOGCONFIG(TAG, " max length: %d", this->max_length_); - if (!this->back_keys_.empty()) + } + if (!this->back_keys_.empty()) { ESP_LOGCONFIG(TAG, " erase keys '%s'", this->back_keys_.c_str()); - if (!this->clear_keys_.empty()) + } + if (!this->clear_keys_.empty()) { ESP_LOGCONFIG(TAG, " clear keys '%s'", this->clear_keys_.c_str()); - if (!this->start_keys_.empty()) + } + if (!this->start_keys_.empty()) { ESP_LOGCONFIG(TAG, " start keys '%s'", this->start_keys_.c_str()); + } if (!this->end_keys_.empty()) { ESP_LOGCONFIG(TAG, " end keys '%s'\n" " end key is required: %s", this->end_keys_.c_str(), ONOFF(this->end_key_required_)); } - if (!this->allowed_keys_.empty()) + if (!this->allowed_keys_.empty()) { ESP_LOGCONFIG(TAG, " allowed keys '%s'", this->allowed_keys_.c_str()); - if (this->timeout_ > 0) + } + if (this->timeout_ > 0) { ESP_LOGCONFIG(TAG, " entry timeout: %0.1f", this->timeout_ / 1000.0); + } #endif } diff --git a/esphome/components/kuntze/kuntze.cpp b/esphome/components/kuntze/kuntze.cpp index c47a80777c..cb04afe437 100644 --- a/esphome/components/kuntze/kuntze.cpp +++ b/esphome/components/kuntze/kuntze.cpp @@ -1,87 +1,74 @@ #include "kuntze.h" -#include "esphome/core/helpers.h" #include "esphome/core/log.h" -#include "esphome/core/application.h" namespace esphome::kuntze { static const char *const TAG = "kuntze"; -static const uint16_t REGISTER[] = {4136, 4160, 4680, 6000, 4688, 4728, 5832}; +static constexpr uint16_t REGISTER_PH = 4136; +static constexpr uint16_t REGISTER_TEMPERATURE = 4160; +static constexpr uint16_t REGISTER_DIS1 = 4680; +static constexpr uint16_t REGISTER_DIS2 = 6000; +static constexpr uint16_t REGISTER_REDOX = 4688; +static constexpr uint16_t REGISTER_EC = 4728; +static constexpr uint16_t REGISTER_OCI = 5832; +static constexpr uint16_t REGISTER[] = {REGISTER_PH, REGISTER_TEMPERATURE, REGISTER_DIS1, REGISTER_DIS2, + REGISTER_REDOX, REGISTER_EC, REGISTER_OCI}; -// Maximum bytes to log for Modbus responses (2 registers = 4, plus count = 5) -static constexpr size_t KUNTZE_MAX_LOG_BYTES = 8; +void Kuntze::on_read_holding_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status) || registers.size() < 2) + return; -void Kuntze::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - auto get_16bit = [&](int i) -> uint16_t { return (uint16_t(data[i * 2]) << 8) | uint16_t(data[i * 2 + 1]); }; + // Each value is a register pair: the reading, then the number of decimal places in its low byte. + float value = registers[0]; + for (uint16_t i = 0; i < (registers[1] & 0xFF); i++) + value /= 10.0f; - this->waiting_ = false; -#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE - char hex_buf[format_hex_pretty_size(KUNTZE_MAX_LOG_BYTES)]; -#endif - ESP_LOGV(TAG, "Data: %s", format_hex_pretty_to(hex_buf, data.data(), data.size())); - - float value = (float) get_16bit(0); - for (int i = 0; i < data[3]; i++) - value /= 10.0; - switch (this->state_) { - case 1: + switch (start_address) { + case REGISTER_PH: ESP_LOGD(TAG, "pH=%.1f", value); if (this->ph_sensor_ != nullptr) this->ph_sensor_->publish_state(value); break; - case 2: + case REGISTER_TEMPERATURE: ESP_LOGD(TAG, "temperature=%.1f", value); if (this->temperature_sensor_ != nullptr) this->temperature_sensor_->publish_state(value); break; - case 3: + case REGISTER_DIS1: ESP_LOGD(TAG, "DIS1=%.1f", value); if (this->dis1_sensor_ != nullptr) this->dis1_sensor_->publish_state(value); break; - case 4: + case REGISTER_DIS2: ESP_LOGD(TAG, "DIS2=%.1f", value); if (this->dis2_sensor_ != nullptr) this->dis2_sensor_->publish_state(value); break; - case 5: + case REGISTER_REDOX: ESP_LOGD(TAG, "REDOX=%.1f", value); if (this->redox_sensor_ != nullptr) this->redox_sensor_->publish_state(value); break; - case 6: + case REGISTER_EC: ESP_LOGD(TAG, "EC=%.1f", value); if (this->ec_sensor_ != nullptr) this->ec_sensor_->publish_state(value); break; - case 7: + case REGISTER_OCI: ESP_LOGD(TAG, "OCI=%.1f", value); if (this->oci_sensor_ != nullptr) this->oci_sensor_->publish_state(value); break; } - if (++this->state_ > 7) - this->state_ = 0; } -void Kuntze::loop() { - uint32_t now = App.get_loop_component_start_time(); - // timeout after 15 seconds - if (this->waiting_ && (now - this->last_send_ > 15000)) { - ESP_LOGW(TAG, "timed out waiting for response"); - this->waiting_ = false; - } - if (this->waiting_ || (this->state_ == 0)) - return; - this->last_send_ = now; - this->read_holding_registers(REGISTER[this->state_ - 1], 2); - this->waiting_ = true; +void Kuntze::update() { + for (uint16_t reg : REGISTER) + this->read_holding_registers(reg, 2); } -void Kuntze::update() { this->state_ = 1; } - void Kuntze::dump_config() { ESP_LOGCONFIG(TAG, "Kuntze:\n" diff --git a/esphome/components/kuntze/kuntze.h b/esphome/components/kuntze/kuntze.h index 28c8089748..84197b379d 100644 --- a/esphome/components/kuntze/kuntze.h +++ b/esphome/components/kuntze/kuntze.h @@ -18,18 +18,14 @@ class Kuntze final : public PollingComponent, public modbus::ModbusClientDevice void set_ec_sensor(sensor::Sensor *ec_sensor) { ec_sensor_ = ec_sensor; } void set_oci_sensor(sensor::Sensor *oci_sensor) { oci_sensor_ = oci_sensor; } - void loop() override; void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_holding_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; void dump_config() override; protected: - int state_{0}; - bool waiting_{false}; - uint32_t last_send_{0}; - sensor::Sensor *ph_sensor_{nullptr}; sensor::Sensor *temperature_sensor_{nullptr}; sensor::Sensor *dis1_sensor_{nullptr}; diff --git a/esphome/components/lc709203f/lc709203f.cpp b/esphome/components/lc709203f/lc709203f.cpp index cbd733b611..a5dda6ca43 100644 --- a/esphome/components/lc709203f/lc709203f.cpp +++ b/esphome/components/lc709203f/lc709203f.cpp @@ -150,7 +150,8 @@ void Lc709203f::dump_config() { " Pack Size: %d mAH\n" " Pack APA: 0x%02X\n" " Pack Rated Voltage: 3.%sV", - this->pack_size_, this->apa_, this->pack_voltage_ == 0x0000 ? "8" : "7"); + this->pack_size_, this->apa_, + this->pack_voltage_ == 0x0000 ? LOG_STR_LITERAL("8") : LOG_STR_LITERAL("7")); LOG_I2C_DEVICE(this); LOG_UPDATE_INTERVAL(this); LOG_SENSOR(" ", "Voltage", this->voltage_sensor_); diff --git a/esphome/components/ld2420/ld2420.cpp b/esphome/components/ld2420/ld2420.cpp index 4aa00f8fd4..e342ead414 100644 --- a/esphome/components/ld2420/ld2420.cpp +++ b/esphome/components/ld2420/ld2420.cpp @@ -701,7 +701,8 @@ uint8_t LD2420Component::set_config_mode(bool enable) { cmd_frame.data_length += sizeof(CMD_PROTOCOL_VER); } cmd_frame.footer = CMD_FRAME_FOOTER; - ESP_LOGV(TAG, "Sending set config %s command: %2X", enable ? "enable" : "disable", cmd_frame.command); + ESP_LOGV(TAG, "Sending set config %s command: %2X", enable ? LOG_STR_LITERAL("enable") : LOG_STR_LITERAL("disable"), + cmd_frame.command); return this->send_cmd_from_array(cmd_frame); } diff --git a/esphome/components/ld6002b/ld6002b.cpp b/esphome/components/ld6002b/ld6002b.cpp index ca6b9b9552..73fc7df331 100644 --- a/esphome/components/ld6002b/ld6002b.cpp +++ b/esphome/components/ld6002b/ld6002b.cpp @@ -437,7 +437,8 @@ void LD6002BComponent::dump_config() { "HLK-LD6002B:\n" " Auto wake: %s\n" " Max data length: %u", - this->auto_wake_ ? "true" : "false", static_cast(this->max_data_len_)); + this->auto_wake_ ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false"), + static_cast(this->max_data_len_)); if (this->wakeup_pin_ != nullptr) { LOG_PIN(" Wake-up Pin: ", this->wakeup_pin_); ESP_LOGCONFIG(TAG, " Wake Pulse: %" PRIu32 "ms", this->wakeup_pulse_ms_); diff --git a/esphome/components/light/esp_color_correction.cpp b/esphome/components/light/esp_color_correction.cpp index e793226bb1..12eb6a3008 100644 --- a/esphome/components/light/esp_color_correction.cpp +++ b/esphome/components/light/esp_color_correction.cpp @@ -5,7 +5,11 @@ namespace esphome::light { uint8_t ESPColorCorrection::gamma_correct_(uint8_t value) const { if (this->gamma_table_ == nullptr) return value; - return static_cast((progmem_read_uint16(&this->gamma_table_[value]) + 128) / 257); + uint16_t table_value = progmem_read_uint16(&this->gamma_table_[value]); + uint8_t result = (table_value + 128) / 257; + if (result == 0 && table_value != 0) + return 1; + return result; } uint8_t ESPColorCorrection::gamma_uncorrect_(uint8_t value) const { diff --git a/esphome/components/ln882h_ble/ln882h_ble.cpp b/esphome/components/ln882h_ble/ln882h_ble.cpp index 021e138f08..0b15bf434c 100644 --- a/esphome/components/ln882h_ble/ln882h_ble.cpp +++ b/esphome/components/ln882h_ble/ln882h_ble.cpp @@ -333,8 +333,9 @@ void LN882HBLE::loop() { // the queue empty — from the very first report on. Checking here keeps that // failure visible instead of producing a scanner that is silently dead. uint16_t dropped = this->report_queue_.get_and_reset_dropped_count(); - if (dropped > 0) + if (dropped > 0) { ESP_LOGW(TAG, "Dropped %u scan reports (queue full or out of memory for a report slot)", dropped); + } // Drain the lock-free ring filled by the rw task; all per-report work runs // here on the main task, then the report returns to the pool. BLEScanReport *report = this->report_queue_.pop(); diff --git a/esphome/components/lvgl/defines.py b/esphome/components/lvgl/defines.py index 81a4d2b4ab..1eee8041f9 100644 --- a/esphome/components/lvgl/defines.py +++ b/esphome/components/lvgl/defines.py @@ -483,6 +483,7 @@ LV_ANIM = LvConstant( LV_GRAD_DIR = LvConstant("LV_GRAD_DIR_", "NONE", "HOR", "VER") LV_DITHER = LvConstant("LV_DITHER_", "NONE", "ORDERED", "ERR_DIFF") +LV_GRAD_EXTEND = LvConstant("LV_GRAD_EXTEND_", "PAD", "REPEAT", "REFLECT") LV_LOG_LEVELS = { "VERBOSE": "TRACE", @@ -627,10 +628,6 @@ OBJ_FLAGS = ( "send_draw_task_events", "widget_1", "widget_2", - "user_1", - "user_2", - "user_3", - "user_4", ) LV_OBJ_FLAG = LvConstant("LV_OBJ_FLAG_", *OBJ_FLAGS) @@ -904,7 +901,7 @@ LV_COLOR_FORMATS = ( LV_DEFINES = ( "LV_USE_FREERTOS_TASK_NOTIFY", "LV_DRAW_BUF_STRIDE_ALIGN", "LV_USE_DRAW_SW", "LV_DRAW_SW_DRAW_UNIT_CNT", - "LV_DRAW_SW_COMPLEX", "LV_USE_DRAW_PXP", "LV_USE_PXP_DRAW_THREAD", "LV_USE_DRAW_G2D", + "LV_DRAW_SW_COMPLEX", "LV_USE_DRAW_SW_COMPLEX_GRADIENTS", "LV_USE_DRAW_PXP", "LV_USE_PXP_DRAW_THREAD", "LV_USE_DRAW_G2D", "LV_USE_G2D_DRAW_THREAD", "LV_VG_LITE_USE_BOX_SHADOW", "LV_VG_LITE_THORVG_16PIXELS_ALIGN", "LV_LOG_USE_TIMESTAMP", "LV_LOG_USE_FILE_LINE", "LV_USE_OBJ_ID_BUILTIN", "LV_USE_OBJ_PROPERTY_NAME", "LV_ATTRIBUTE_MEM_ALIGN_SIZE", "LV_FONT_MONTSERRAT_14", "LV_USE_FONT_PLACEHOLDER", "LV_WIDGETS_HAS_DEFAULT_VALUE", "LV_USE_ARCLABEL", diff --git a/esphome/components/lvgl/gradient.py b/esphome/components/lvgl/gradient.py index 2f1be20772..8db183fabe 100644 --- a/esphome/components/lvgl/gradient.py +++ b/esphome/components/lvgl/gradient.py @@ -13,18 +13,40 @@ from esphome.core import ID from esphome.cpp_generator import MockObj from .defines import ( + CONF_END_ANGLE, CONF_GRADIENTS, CONF_OPA, + CONF_START_ANGLE, LV_DITHER, + LV_GRAD_EXTEND, add_define, add_lv_use, add_warning, ) -from .lv_validation import lv_color, lv_percentage, opacity +from .lv_validation import ( + lv_angle_degrees, + lv_color, + lv_percentage, + opacity, + pixels_or_percent, +) from .lvcode import lv from .types import lv_color_t, lv_gradient_t, lv_opa_t CONF_STOPS = "stops" +CONF_LINEAR = "linear" +CONF_RADIAL = "radial" +CONF_CONICAL = "conical" +CONF_EXTEND = "extend" +CONF_FROM_X = "from_x" +CONF_FROM_Y = "from_y" +CONF_TO_X = "to_x" +CONF_TO_Y = "to_y" +CONF_CENTER_X = "center_x" +CONF_CENTER_Y = "center_y" +CONF_FOCAL_X = "focal_x" +CONF_FOCAL_Y = "focal_y" +CONF_FOCAL_RADIUS = "focal_radius" def min_stops(value): @@ -33,27 +55,109 @@ def min_stops(value): return value +STOPS_SCHEMA = cv.All( + [ + cv.Schema( + { + cv.Required(CONF_COLOR): lv_color, + cv.Optional(CONF_OPA, default=1.0): opacity, + cv.Required(CONF_POSITION): lv_percentage, + } + ) + ], + min_stops, +) + +LINEAR_SCHEMA = cv.Schema( + { + cv.Required(CONF_FROM_X): pixels_or_percent, + cv.Required(CONF_FROM_Y): pixels_or_percent, + cv.Required(CONF_TO_X): pixels_or_percent, + cv.Required(CONF_TO_Y): pixels_or_percent, + cv.Optional(CONF_EXTEND, default="PAD"): LV_GRAD_EXTEND.one_of, + } +) + +RADIAL_SCHEMA = cv.Schema( + { + cv.Required(CONF_CENTER_X): pixels_or_percent, + cv.Required(CONF_CENTER_Y): pixels_or_percent, + cv.Required(CONF_TO_X): pixels_or_percent, + cv.Required(CONF_TO_Y): pixels_or_percent, + cv.Optional(CONF_FOCAL_X): pixels_or_percent, + cv.Optional(CONF_FOCAL_Y): pixels_or_percent, + # No default: gradient_validator() must be able to tell whether this was actually + # given, to require it alongside focal_x/focal_y rather than silently drop it. + # LVGL's lv_grad_radial_set_focal() takes this as a scalar, not lv_pct() - + # unlike every other coordinate here, a percentage is not accepted. + cv.Optional(CONF_FOCAL_RADIUS): cv.positive_int, + cv.Optional(CONF_EXTEND, default="PAD"): LV_GRAD_EXTEND.one_of, + } +) + +CONICAL_SCHEMA = cv.Schema( + { + cv.Required(CONF_CENTER_X): pixels_or_percent, + cv.Required(CONF_CENTER_Y): pixels_or_percent, + cv.Optional(CONF_START_ANGLE, default=0): lv_angle_degrees, + cv.Optional(CONF_END_ANGLE, default=360): lv_angle_degrees, + cv.Optional(CONF_EXTEND, default="PAD"): LV_GRAD_EXTEND.one_of, + } +) + + +def gradient_validator(config): + direction = config[CONF_DIRECTION] + for gradient_direction, key in ( + ("LINEAR", CONF_LINEAR), + ("RADIAL", CONF_RADIAL), + ("CONICAL", CONF_CONICAL), + ): + if direction == gradient_direction: + if key not in config: + raise cv.Invalid( + f"'{key}' is required for {gradient_direction} gradient direction" + ) + elif key in config: + raise cv.Invalid( + f"'{key}' is only valid with 'direction: {gradient_direction}'" + ) + if CONF_RADIAL in config: + radial = config[CONF_RADIAL] + has_focal_x = CONF_FOCAL_X in radial + has_focal_y = CONF_FOCAL_Y in radial + has_focal_radius = CONF_FOCAL_RADIUS in radial + if has_focal_x != has_focal_y or (has_focal_radius and not has_focal_x): + raise cv.Invalid( + "'focal_x', 'focal_y' and 'focal_radius' must be specified together " + "in 'radial'" + ) + return config + + GRADIENT_SCHEMA = cv.ensure_list( - cv.Schema( - { - cv.GenerateID(CONF_ID): cv.declare_id(lv_gradient_t), - cv.Required(CONF_DIRECTION): cv.one_of( - "HOR", "HORIZONTAL", "VER", "VERTICAL", upper=True - ), - cv.Optional(CONF_DITHER): LV_DITHER.one_of, - cv.Required(CONF_STOPS): cv.All( - [ - cv.Schema( - { - cv.Required(CONF_COLOR): lv_color, - cv.Optional(CONF_OPA, default=1.0): opacity, - cv.Required(CONF_POSITION): lv_percentage, - } - ) - ], - min_stops, - ), - } + cv.All( + cv.Schema( + { + cv.GenerateID(CONF_ID): cv.declare_id(lv_gradient_t), + cv.Required(CONF_DIRECTION): cv.one_of( + "HOR", + "HORIZONTAL", + "VER", + "VERTICAL", + "LINEAR", + "RADIAL", + "CONICAL", + upper=True, + ), + cv.Optional(CONF_DITHER): LV_DITHER.one_of, + cv.Optional(CONF_LINEAR): LINEAR_SCHEMA, + cv.Optional(CONF_RADIAL): RADIAL_SCHEMA, + cv.Optional(CONF_CONICAL): CONICAL_SCHEMA, + cv.Required(CONF_STOPS): STOPS_SCHEMA, + } + ), + gradient_validator, ) ) @@ -65,15 +169,60 @@ async def gradients_to_code(config): add_warning( "The 'dither' option for gradients is not supported by LVGL 9.x and will be ignored" ) + if any( + x[CONF_DIRECTION] in ("LINEAR", "RADIAL", "CONICAL") + for x in config.get(CONF_GRADIENTS, ()) + ): + # LVGL's software renderer only draws these gradient types when this is enabled; without + # it they silently fall back to a plain horizontal gradient. + add_define("LV_USE_DRAW_SW_COMPLEX_GRADIENTS") for gradient in config.get(CONF_GRADIENTS, ()): var = MockObj(cg.new_Pvariable(gradient[CONF_ID]), "->") idbase = gradient[CONF_ID].id stops = sorted(gradient[CONF_STOPS], key=itemgetter(CONF_POSITION)) max_stops = max(max_stops, len(stops)) - if gradient[CONF_DIRECTION].startswith("VER"): + direction = gradient[CONF_DIRECTION] + if direction.startswith("VER"): lv.grad_vertical_init(var) - else: + elif direction.startswith("HOR"): lv.grad_horizontal_init(var) + elif direction == "LINEAR": + linear = gradient[CONF_LINEAR] + lv.grad_linear_init( + var, + await pixels_or_percent.process(linear[CONF_FROM_X]), + await pixels_or_percent.process(linear[CONF_FROM_Y]), + await pixels_or_percent.process(linear[CONF_TO_X]), + await pixels_or_percent.process(linear[CONF_TO_Y]), + await LV_GRAD_EXTEND.process(linear[CONF_EXTEND]), + ) + elif direction == "RADIAL": + radial = gradient[CONF_RADIAL] + lv.grad_radial_init( + var, + await pixels_or_percent.process(radial[CONF_CENTER_X]), + await pixels_or_percent.process(radial[CONF_CENTER_Y]), + await pixels_or_percent.process(radial[CONF_TO_X]), + await pixels_or_percent.process(radial[CONF_TO_Y]), + await LV_GRAD_EXTEND.process(radial[CONF_EXTEND]), + ) + if CONF_FOCAL_X in radial: + lv.grad_radial_set_focal( + var, + await pixels_or_percent.process(radial[CONF_FOCAL_X]), + await pixels_or_percent.process(radial[CONF_FOCAL_Y]), + radial.get(CONF_FOCAL_RADIUS, 0), + ) + elif direction == "CONICAL": + conical = gradient[CONF_CONICAL] + lv.grad_conical_init( + var, + await pixels_or_percent.process(conical[CONF_CENTER_X]), + await pixels_or_percent.process(conical[CONF_CENTER_Y]), + await lv_angle_degrees.process(conical[CONF_START_ANGLE]), + await lv_angle_degrees.process(conical[CONF_END_ANGLE]), + await LV_GRAD_EXTEND.process(conical[CONF_EXTEND]), + ) stop_colors = cg.static_const_array( ID(idbase + "_colors_", type=lv_color_t), [await lv_color.process(x[CONF_COLOR]) for x in stops], diff --git a/esphome/components/lvgl/lvgl_esphome.cpp b/esphome/components/lvgl/lvgl_esphome.cpp index a10fdb0582..2c988473a9 100644 --- a/esphome/components/lvgl/lvgl_esphome.cpp +++ b/esphome/components/lvgl/lvgl_esphome.cpp @@ -1059,8 +1059,9 @@ static void *lv_alloc_draw_buf(size_t size, bool internal) { void *buffer; size = LV_ROUND_UP(size, LV_DRAW_BUF_ALIGN); buffer = heap_caps_aligned_alloc(LV_DRAW_BUF_ALIGN, size, internal ? MALLOC_CAP_8BIT : cap_bits); // NOLINT - if (buffer == nullptr) + if (buffer == nullptr) { ESP_LOGW(esphome::lvgl::TAG, "Failed to allocate %zu bytes for %sdraw buffer", size, internal ? "internal " : ""); + } return buffer; } diff --git a/esphome/components/lvgl/widgets/table.py b/esphome/components/lvgl/widgets/table.py index efae2be2be..f000ea1846 100644 --- a/esphome/components/lvgl/widgets/table.py +++ b/esphome/components/lvgl/widgets/table.py @@ -2,7 +2,7 @@ from contextlib import ExitStack from esphome import automation import esphome.codegen as cg -from esphome.components.const import CONF_ROWS +from esphome.components.const import CONF_COLUMNS, CONF_ROWS import esphome.config_validation as cv from esphome.const import CONF_ID, CONF_ITEMS, CONF_ROW, CONF_TEXT, CONF_WIDTH from esphome.core import ID @@ -20,7 +20,6 @@ from .label import CONF_LABEL CONF_TABLE = "table" CONF_CELLS = "cells" -CONF_COLUMNS = "columns" CONF_ROW_COUNT = "row_count" CONF_COLUMN_COUNT = "column_count" CONF_MERGE_RIGHT = "merge_right" diff --git a/esphome/components/matrix_keypad/__init__.py b/esphome/components/matrix_keypad/__init__.py index 47cf4793b1..2e43eaf7e2 100644 --- a/esphome/components/matrix_keypad/__init__.py +++ b/esphome/components/matrix_keypad/__init__.py @@ -1,7 +1,7 @@ from esphome import automation, pins import esphome.codegen as cg from esphome.components import key_provider -from esphome.components.const import CONF_ROWS +from esphome.components.const import CONF_COLUMNS, CONF_KEYS, CONF_ROWS import esphome.config_validation as cv from esphome.const import CONF_ID, CONF_ON_KEY, CONF_PIN, CONF_TRIGGER_ID from esphome.types import ConfigType @@ -21,8 +21,6 @@ MatrixKeyTrigger = matrix_keypad_ns.class_( ) CONF_KEYPAD_ID = "keypad_id" -CONF_COLUMNS = "columns" -CONF_KEYS = "keys" CONF_DEBOUNCE_TIME = "debounce_time" CONF_HAS_DIODES = "has_diodes" CONF_HAS_PULLDOWNS = "has_pulldowns" diff --git a/esphome/components/max31856/max31856.cpp b/esphome/components/max31856/max31856.cpp index 4062d21bee..b5bad8ef74 100644 --- a/esphome/components/max31856/max31856.cpp +++ b/esphome/components/max31856/max31856.cpp @@ -23,8 +23,10 @@ void MAX31856Sensor::setup() { void MAX31856Sensor::dump_config() { LOG_SENSOR("", "MAX31856", this); LOG_PIN(" CS Pin: ", this->cs_); - ESP_LOGCONFIG(TAG, " Mains Filter: %s", - (filter_ == FILTER_60HZ ? "60 Hz" : (filter_ == FILTER_50HZ ? "50 Hz" : "Unknown!"))); + ESP_LOGCONFIG( + TAG, " Mains Filter: %s", + (filter_ == FILTER_60HZ ? LOG_STR_LITERAL("60 Hz") + : (filter_ == FILTER_50HZ ? LOG_STR_LITERAL("50 Hz") : LOG_STR_LITERAL("Unknown!")))); if (this->thermocouple_type_ < 0 || this->thermocouple_type_ > 7) { ESP_LOGCONFIG(TAG, " Thermocouple Type: Unknown"); } else { diff --git a/esphome/components/max31865/max31865.cpp b/esphome/components/max31865/max31865.cpp index 220fb4e704..e5a6fca8fb 100644 --- a/esphome/components/max31865/max31865.cpp +++ b/esphome/components/max31865/max31865.cpp @@ -80,12 +80,14 @@ void MAX31865Sensor::dump_config() { LOG_SENSOR("", "MAX31865", this); LOG_PIN(" CS Pin: ", this->cs_); LOG_UPDATE_INTERVAL(this); - ESP_LOGCONFIG(TAG, - " Reference Resistance: %.2fΩ\n" - " RTD: %u-wire %.2fΩ\n" - " Mains Filter: %s", - reference_resistance_, rtd_wires_, rtd_nominal_resistance_, - (filter_ == FILTER_60HZ ? "60 Hz" : (filter_ == FILTER_50HZ ? "50 Hz" : "Unknown!"))); + ESP_LOGCONFIG( + TAG, + " Reference Resistance: %.2fΩ\n" + " RTD: %u-wire %.2fΩ\n" + " Mains Filter: %s", + reference_resistance_, rtd_wires_, rtd_nominal_resistance_, + (filter_ == FILTER_60HZ ? LOG_STR_LITERAL("60 Hz") + : (filter_ == FILTER_50HZ ? LOG_STR_LITERAL("50 Hz") : LOG_STR_LITERAL("Unknown!")))); } void MAX31865Sensor::read_data_() { diff --git a/esphome/components/mcp4461/mcp4461.cpp b/esphome/components/mcp4461/mcp4461.cpp index abc74b9e6d..cc53f9de7f 100644 --- a/esphome/components/mcp4461/mcp4461.cpp +++ b/esphome/components/mcp4461/mcp4461.cpp @@ -319,7 +319,7 @@ uint16_t Mcp4461Component::read_wiper_level_(uint8_t wiper_idx, bool *ok) { if (!(this->read_16_(reg, &buf))) { this->error_code_ = MCP4461_STATUS_I2C_ERROR; this->status_set_warning(); - ESP_LOGW(TAG, "Error fetching %swiper %u value", (wiper_idx > 3) ? "nonvolatile " : "", wiper_idx); + ESP_LOGW(TAG, "Error fetching %swiper %u value", (wiper_idx > 3) ? LOG_STR_LITERAL("nonvolatile ") : "", wiper_idx); return 0; } if (ok != nullptr) { @@ -377,7 +377,8 @@ void Mcp4461Component::write_wiper_level_(uint8_t wiper, uint16_t value) { if (!(this->mcp4461_write_(this->get_wiper_address_(wiper), value, nonvolatile))) { this->error_code_ = MCP4461_STATUS_I2C_ERROR; this->status_set_warning(); - ESP_LOGW(TAG, "Error writing %swiper %u level %u", (wiper > 3) ? "nonvolatile " : "", wiper, value); + ESP_LOGW(TAG, "Error writing %swiper %u level %u", (wiper > 3) ? LOG_STR_LITERAL("nonvolatile ") : "", wiper, + value); } } diff --git a/esphome/components/mdns/__init__.py b/esphome/components/mdns/__init__.py index c9334ea97a..f039bb69f0 100644 --- a/esphome/components/mdns/__init__.py +++ b/esphome/components/mdns/__init__.py @@ -1,5 +1,5 @@ import esphome.codegen as cg -from esphome.components.esp32 import add_idf_component +from esphome.components.esp32 import add_idf_component, add_idf_sdkconfig_option from esphome.config_helpers import filter_source_files_from_platform, get_logger_level import esphome.config_validation as cv from esphome.const import ( @@ -9,6 +9,7 @@ from esphome.const import ( CONF_PROTOCOL, CONF_SERVICE, CONF_SERVICES, + CONF_WIFI, PlatformFramework, ) from esphome.core import CORE, Lambda, coroutine_with_priority @@ -208,7 +209,16 @@ async def to_code(config: ConfigType) -> None: ethernet.request_ethernet_ip_state_listener() if CORE.is_esp32: - add_idf_component(name="espressif/mdns", ref="1.11.3") + add_idf_component(name="espressif/mdns", ref="1.12.0") + # ESPHome only advertises; the browse APIs are unused + add_idf_sdkconfig_option("CONFIG_MDNS_ENABLE_BROWSE", False) + # The mdns console CLI is never used by ESPHome + add_idf_sdkconfig_option("CONFIG_MDNS_ENABLE_CONSOLE_CLI", False) + if CONF_WIFI not in CORE.config: + # Without WiFi the predefined STA/AP interface handlers are dead + # code; disabling them lets mdns build without the WiFi stack. + add_idf_sdkconfig_option("CONFIG_MDNS_PREDEF_NETIF_STA", False) + add_idf_sdkconfig_option("CONFIG_MDNS_PREDEF_NETIF_AP", False) cg.add_define("USE_MDNS") diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp index 7dce74117a..6c3eef912e 100644 --- a/esphome/components/media_player/media_player.cpp +++ b/esphome/components/media_player/media_player.cpp @@ -122,7 +122,7 @@ void MediaPlayerCall::perform() { ESP_LOGV(TAG, " Volume: %.2f", this->volume_.value()); } if (this->announcement_.has_value()) { - ESP_LOGV(TAG, " Announcement: %s", this->announcement_.value() ? "yes" : "no"); + ESP_LOGV(TAG, " Announcement: %s", this->announcement_.value() ? LOG_STR_LITERAL("yes") : LOG_STR_LITERAL("no")); } this->parent_->control(*this); } diff --git a/esphome/components/mipi_dsi/mipi_dsi.cpp b/esphome/components/mipi_dsi/mipi_dsi.cpp index 0ff934ae94..0850b50c85 100644 --- a/esphome/components/mipi_dsi/mipi_dsi.cpp +++ b/esphome/components/mipi_dsi/mipi_dsi.cpp @@ -237,8 +237,9 @@ void MipiDsi::write_to_display_(int x_start, int y_start, int w, int h, const ui xSemaphoreTake(this->io_lock_, portMAX_DELAY); } } - if (err != ESP_OK) + if (err != ESP_OK) { ESP_LOGE(TAG, "lcd_lcd_panel_draw_bitmap failed: %s", esp_err_to_name(err)); + } } bool MipiDsi::check_buffer_() { diff --git a/esphome/components/mipi_rgb/display.py b/esphome/components/mipi_rgb/display.py index e23e19a000..b91528160e 100644 --- a/esphome/components/mipi_rgb/display.py +++ b/esphome/components/mipi_rgb/display.py @@ -12,7 +12,12 @@ from esphome.components.const import ( CONF_DRAW_ROUNDING, ) from esphome.components.display import CONF_SHOW_TEST_CARD -from esphome.components.esp32 import VARIANT_ESP32P4, VARIANT_ESP32S3, only_on_variant +from esphome.components.esp32 import ( + VARIANT_ESP32P4, + VARIANT_ESP32S3, + VARIANT_ESP32S31, + only_on_variant, +) from esphome.components.mipi import ( COLOR_ORDERS, CONF_DE_PIN, @@ -226,7 +231,7 @@ def _config_schema(config: ConfigType) -> ConfigType: config = cv.All( schema, cv.only_on_esp32, - only_on_variant(supported=[VARIANT_ESP32S3, VARIANT_ESP32P4]), + only_on_variant(supported=[VARIANT_ESP32S3, VARIANT_ESP32P4, VARIANT_ESP32S31]), )(config) model = MODELS[config[CONF_MODEL].upper()] model.check_requirements() diff --git a/esphome/components/mipi_rgb/mipi_rgb.cpp b/esphome/components/mipi_rgb/mipi_rgb.cpp index 7421d8ad83..c11044c288 100644 --- a/esphome/components/mipi_rgb/mipi_rgb.cpp +++ b/esphome/components/mipi_rgb/mipi_rgb.cpp @@ -1,11 +1,11 @@ -#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) +#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S31) #include "mipi_rgb.h" #include "esphome/core/gpio.h" #include "esphome/core/hal.h" #include "esphome/core/helpers.h" #include "esphome/core/log.h" #include -#include +#include #include namespace esphome::mipi_rgb { @@ -177,11 +177,6 @@ void MipiRgb::common_setup_() { ESP_LOGCONFIG(TAG, "MipiRgb setup complete"); } -void MipiRgb::loop() { - if (this->handle_ != nullptr) - esp_lcd_rgb_panel_restart(this->handle_); -} - void MipiRgb::update() { if (this->is_failed()) return; @@ -243,8 +238,9 @@ void MipiRgb::write_to_display_(int x_start, int y_start, int w, int h, const ui ptr += stride; // next line } } - if (err != ESP_OK) + if (err != ESP_OK) { ESP_LOGE(TAG, "lcd_lcd_panel_draw_bitmap failed: %s", esp_err_to_name(err)); + } } bool MipiRgb::check_buffer_() { @@ -400,4 +396,5 @@ void MipiRgb::dump_config() { } } // namespace esphome::mipi_rgb -#endif // defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) +#endif // defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) || + // defined(USE_ESP32_VARIANT_ESP32S31) diff --git a/esphome/components/mipi_rgb/mipi_rgb.h b/esphome/components/mipi_rgb/mipi_rgb.h index 1480004833..f528943c1b 100644 --- a/esphome/components/mipi_rgb/mipi_rgb.h +++ b/esphome/components/mipi_rgb/mipi_rgb.h @@ -1,9 +1,9 @@ #pragma once -#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) +#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S31) #include "esphome/core/gpio.h" #include "esphome/components/display/display.h" -#include "esp_lcd_panel_ops.h" +#include #ifdef USE_SPI #include "esphome/components/spi/spi.h" #endif @@ -25,7 +25,12 @@ class MipiRgb : public display::Display { public: MipiRgb(int width, int height) : width_(width), height_(height) {} void setup() override; - void loop() override; +#ifdef USE_ESP32_VARIANT_ESP32S3 + void loop() override { + if (this->handle_ != nullptr) + esp_lcd_rgb_panel_restart(this->handle_); + } +#endif void update() override; void fill(Color color) override; void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order, diff --git a/esphome/components/mipi_rgb/models/elecrow.py b/esphome/components/mipi_rgb/models/elecrow.py new file mode 100644 index 0000000000..acc36beb74 --- /dev/null +++ b/esphome/components/mipi_rgb/models/elecrow.py @@ -0,0 +1,28 @@ +from . import RgbDriverChip + +# fmt: off +RgbDriverChip( + "CROWPANEL-ADVANCE-7", + requires={"psram"}, + initsequence=(), + pclk_frequency="20MHz", + hsync_pulse_width=4, + hsync_front_porch=8, + hsync_back_porch=8, + vsync_pulse_width=4, + vsync_front_porch=8, + vsync_back_porch=8, + pclk_inverted=True, + color_order="RGB", + width=800, + height=480, + de_pin=42, + hsync_pin=40, + vsync_pin=41, + pclk_pin=39, + data_pins={ + "red": [7, 17, 18, 3, 46], + "green": [9, 10, 11, 12, 13, 14], + "blue": [21, 47, 48, 45, 38], + }, +) diff --git a/esphome/components/mipi_spi/mipi_spi.cpp b/esphome/components/mipi_spi/mipi_spi.cpp index 2eec3b12d1..b2658de6e8 100644 --- a/esphome/components/mipi_spi/mipi_spi.cpp +++ b/esphome/components/mipi_spi/mipi_spi.cpp @@ -25,17 +25,21 @@ void internal_dump_config(const char *model, int width, int height, int offset_w " SPI Bus width: %d", model, width, height, YESNO(madctl & MADCTL_MV), YESNO(madctl & (MADCTL_MX | MADCTL_XFLIP)), YESNO(madctl & (MADCTL_MY | MADCTL_YFLIP)), YESNO(has_hardware_rotation), YESNO(invert_colors), - (madctl & MADCTL_BGR) ? "BGR" : "RGB", display_bits, is_big_endian ? "Big" : "Little", spi_mode, + (madctl & MADCTL_BGR) ? LOG_STR_LITERAL("BGR") : LOG_STR_LITERAL("RGB"), display_bits, + is_big_endian ? LOG_STR_LITERAL("Big") : LOG_STR_LITERAL("Little"), spi_mode, static_cast(data_rate / 1000000), bus_width); LOG_PIN(" CS Pin: ", cs); LOG_PIN(" Reset Pin: ", reset); LOG_PIN(" DC Pin: ", dc); - if (offset_width != 0) + if (offset_width != 0) { ESP_LOGCONFIG(TAG, " Offset width: %d", offset_width); - if (offset_height != 0) + } + if (offset_height != 0) { ESP_LOGCONFIG(TAG, " Offset height: %d", offset_height); - if (brightness.has_value()) + } + if (brightness.has_value()) { ESP_LOGCONFIG(TAG, " Brightness: %u", brightness.value()); + } } } // namespace esphome::mipi_spi diff --git a/esphome/components/mk2pvrouter/__init__.py b/esphome/components/mk2pvrouter/__init__.py new file mode 100644 index 0000000000..d00b4ce8d0 --- /dev/null +++ b/esphome/components/mk2pvrouter/__init__.py @@ -0,0 +1,69 @@ +import esphome.codegen as cg +from esphome.components import uart +import esphome.config_validation as cv +from esphome.const import CONF_ID, CONF_TAG +from esphome.cpp_generator import MockObj +from esphome.types import ConfigType + +CODEOWNERS = ["@FredM67"] +DEPENDENCIES = ["uart"] + +mk2pvrouter_ns = cg.esphome_ns.namespace("mk2pvrouter") +Mk2PVRouter = mk2pvrouter_ns.class_("Mk2PVRouter", cg.Component, uart.UARTDevice) + +CONF_MK2PVROUTER_ID = "mk2pvrouter_id" + +# Tags are copied into a fixed-size buffer (MAX_TAG_SIZE = 8 in mk2pvrouter.h), +# which needs room for a trailing null terminator. +MAX_TAG_LEN = 7 + +MK2PVROUTER_LISTENER_SCHEMA = cv.Schema( + { + cv.GenerateID(CONF_MK2PVROUTER_ID): cv.use_id(Mk2PVRouter), + cv.Required(CONF_TAG): cv.All( + cv.string_strict, cv.Length(min=1, max=MAX_TAG_LEN), lambda x: x.upper() + ), + } +) + +CONFIG_SCHEMA = ( + cv.Schema( + { + cv.GenerateID(): cv.declare_id(Mk2PVRouter), + } + ) + .extend(cv.COMPONENT_SCHEMA) + .extend(uart.UART_DEVICE_SCHEMA) +) + + +def final_validate(config: ConfigType) -> None: + # Validate UART settings + schema = uart.final_validate_device_schema( + "mk2pvrouter", + baud_rate=9600, + parity="EVEN", + data_bits=7, + stop_bits=1, + require_rx=True, + require_tx=False, + ) + schema(config) + + +FINAL_VALIDATE_SCHEMA = final_validate + + +_request_listener_slot = cg.slot_counter("MK2PVROUTER_LISTENER_COUNT") + + +async def register_mk2pvrouter_listener(mk2pvrouter: MockObj, var: MockObj) -> None: + """Register a listener with its hub and count it for the compile-time buffer size.""" + _request_listener_slot() + cg.add(mk2pvrouter.register_mk2pvrouter_listener(var)) + + +async def to_code(config: ConfigType) -> None: + var = cg.new_Pvariable(config[CONF_ID]) + await cg.register_component(var, config) + await uart.register_uart_device(var, config) diff --git a/esphome/components/mk2pvrouter/mk2pvrouter.cpp b/esphome/components/mk2pvrouter/mk2pvrouter.cpp new file mode 100644 index 0000000000..a9c922602b --- /dev/null +++ b/esphome/components/mk2pvrouter/mk2pvrouter.cpp @@ -0,0 +1,177 @@ +#include "mk2pvrouter.h" +#include "esphome/core/log.h" +#include + +namespace esphome::mk2pvrouter { + +static const char *const TAG = "mk2pvrouter"; + +constexpr uint8_t START_FRAME = 0x2; +constexpr uint8_t END_FRAME = 0x3; +constexpr uint8_t LINE_FEED = 0xa; +constexpr uint8_t CARRIAGE_RETURN = 0xd; +constexpr uint8_t TAB = 0x9; +constexpr uint8_t MAX_ITERATIONS = 128; +constexpr uint8_t CRC_MASK = 0x3F; +constexpr uint8_t CRC_OFFSET = 0x20; + +// Extracts a TAB-delimited field from [buf_start, buf_end) into dest. +// Returns the field length, or 0 if no TAB was found, or the (uncopied) field +// length if it's >= max_len. +static size_t get_field(char *dest, const char *buf_start, const char *buf_end, size_t max_len) { + const auto *const field_end = static_cast(memchr(buf_start, TAB, buf_end - buf_start)); + if (!field_end) + return 0; + const size_t len = field_end - buf_start; + if (len >= max_len) { + ESP_LOGE(TAG, "Field too long: %zu bytes (max %zu)", len, max_len); + return len; + } + + memcpy(dest, buf_start, len); + dest[len] = '\0'; // Null-terminate + return len; +} + +// Calculates the CRC (checksum) for a given group of characters. +uint8_t Mk2PVRouter::calculate_crc_(const char *grp, size_t grp_len) { + uint8_t crc_tmp{0}; + const auto effective_len = grp_len - CRC_SUFFIX_LEN; + for (size_t i = 0; i < effective_len; i++) { + crc_tmp += grp[i]; + } + crc_tmp &= CRC_MASK; + crc_tmp += CRC_OFFSET; + return crc_tmp; +} + +// Verifies the CRC of a group against its trailing CRC byte. +bool Mk2PVRouter::check_crc_(const char *grp, const char *grp_end) { + const auto grp_len = grp_end - grp; + if (grp_len < static_cast(CRC_SUFFIX_LEN)) { + ESP_LOGE(TAG, "Empty or too short group"); + return false; + } + const auto raw_crc = grp[grp_len - 1]; + + const auto calculated_crc = this->calculate_crc_(grp, grp_len); + + if (raw_crc != calculated_crc) { + ESP_LOGE(TAG, "CRC mismatch: expected %d, got %d", calculated_crc, raw_crc); + return false; + } + return true; +} + +// Validates, parses, and publishes a single tag/value group. +void Mk2PVRouter::process_group_(const char *grp, const char *grp_end) { + if (!this->check_crc_(grp, grp_end)) + return; + + size_t field_len = get_field(this->tag_, grp, grp_end, MAX_TAG_SIZE); + if (!field_len || field_len >= MAX_TAG_SIZE) { + ESP_LOGE(TAG, "Invalid tag"); + return; + } + const auto *val_start = grp + field_len + 1; // Skip tag + TAB. + + field_len = get_field(this->val_, val_start, grp_end, MAX_VAL_SIZE); + if (!field_len || field_len >= MAX_VAL_SIZE) { + ESP_LOGE(TAG, "Invalid value for tag %s", this->tag_); + return; + } + + this->publish_value_(this->tag_, this->val_); +} + +// Reads characters until `c` is found or the internal buffer is full. +bool Mk2PVRouter::read_chars_until_(bool drop, uint8_t c) { + size_t j{0}; + + while (this->available() > 0 && j++ < MAX_ITERATIONS) { + const auto received = this->read(); + if (received < 0) + continue; + if (received == c) + return true; + if (drop) + continue; + if (this->buf_index_ >= (sizeof(this->buf_) - 1)) { + ESP_LOGW(TAG, "Internal buffer full"); + this->buf_index_ = 0; + this->state_ = State::WAITING_FOR_START; + return false; + } + this->buf_[this->buf_index_++] = received; + } + + return false; +} + +void Mk2PVRouter::loop() { + switch (this->state_) { + case State::WAITING_FOR_START: + ESP_LOGVV(TAG, "State: WAITING_FOR_START"); + if (this->read_chars_until_(true, START_FRAME)) + this->state_ = State::START_FRAME_RECEIVED; + break; + case State::START_FRAME_RECEIVED: + ESP_LOGVV(TAG, "State: START_FRAME_RECEIVED"); + if (this->read_chars_until_(false, END_FRAME)) + this->state_ = State::END_FRAME_RECEIVED; + break; + case State::END_FRAME_RECEIVED: { + ESP_LOGVV(TAG, "State: END_FRAME_RECEIVED -> processing"); + + if (this->buf_index_ == 0) { + this->state_ = State::WAITING_FOR_START; + break; + } + + auto *buf_finger = this->buf_; + auto *buf_end = this->buf_ + this->buf_index_; + + // Each group: 0xa(LF) | Tag | 0x9(TAB) | Data | 0x9(TAB) | CRC | 0xd(CR) + // CRC is computed over "Tag | TAB | Data | TAB". + while ((buf_finger = static_cast(memchr(buf_finger, LINE_FEED, buf_end - buf_finger))) != nullptr) { + ++buf_finger; // Skip LF to the start of the group. + + auto *const grp_end = static_cast(memchr(buf_finger, CARRIAGE_RETURN, buf_end - buf_finger)); + if (!grp_end) { + ESP_LOGE(TAG, "No group found"); + break; + } + + this->process_group_(buf_finger, grp_end); + + buf_finger = grp_end; // grp_end is always < buf_end, so this stays in bounds. + } + this->buf_index_ = 0; + this->state_ = State::WAITING_FOR_START; + break; + } + } +} + +void Mk2PVRouter::publish_value_(const char *tag, const char *val) { +#ifdef MK2PVROUTER_LISTENER_COUNT + for (auto *element : this->mk2pvrouter_listeners_) { + if (strcmp(tag, element->get_tag()) != 0) + continue; + element->publish_val(val); + } +#endif +} + +void Mk2PVRouter::dump_config() { + ESP_LOGCONFIG(TAG, "Mk2PVRouter:"); + this->check_uart_settings(BAUD_RATE, 1, uart::UART_CONFIG_PARITY_EVEN, 7); +} + +#ifdef MK2PVROUTER_LISTENER_COUNT +void Mk2PVRouter::register_mk2pvrouter_listener(Mk2PVRouterListener *listener) { + this->mk2pvrouter_listeners_.push_back(listener); +} +#endif + +} // namespace esphome::mk2pvrouter diff --git a/esphome/components/mk2pvrouter/mk2pvrouter.h b/esphome/components/mk2pvrouter/mk2pvrouter.h new file mode 100644 index 0000000000..f542436f1d --- /dev/null +++ b/esphome/components/mk2pvrouter/mk2pvrouter.h @@ -0,0 +1,69 @@ +#pragma once + +#include "esphome/components/uart/uart.h" +#include "esphome/core/component.h" +#include "esphome/core/defines.h" +#include "esphome/core/helpers.h" + +namespace esphome::mk2pvrouter { +/* + * Buffer sizes based on the mk2pvrouter telemetry protocol, as implemented by the + * firmware's teleinfo.h (see github.com/FredM67/PVRouter-{1,3}-phase): + * - Tags: max 4 chars (S_MC is longest), most are 1-2 chars (P, V1, R2, etc.) + * - Values: max 6 digits signed (-10000), typical 1-5 digits. Energy (E) is a daily + * counter reset at midnight, so it stays well within 6 digits. + * - Frame: STX + multiple lines (LF+tag+TAB+value+TAB+crc+CR) + ETX + * - Line format: \n\t\t\r (8-15 bytes per line) + * - Multi-phase with all features: ~150-200 bytes + */ +static constexpr uint8_t MAX_TAG_SIZE = 8; // S_MC (4) + digit (1) + null (1) + margin (2) +static constexpr uint8_t MAX_VAL_SIZE = 8; // -10000 (6) + null (1) + margin (1) +static constexpr uint16_t MAX_BUF_SIZE = 256; // Full frame with all features enabled + +// Listener interface for entities that want updates for a specific tag. +class Mk2PVRouterListener { + public: + explicit Mk2PVRouterListener(const char *tag) : tag_(tag) {} + virtual ~Mk2PVRouterListener() = default; + const char *get_tag() const { return this->tag_; } + virtual void publish_val(const char *val) = 0; + + protected: + const char *tag_; +}; + +// Reads frames via UART, validates their CRC, and publishes tag/value pairs to listeners. +class Mk2PVRouter final : public Component, public uart::UARTDevice { + public: +#ifdef MK2PVROUTER_LISTENER_COUNT + void register_mk2pvrouter_listener(Mk2PVRouterListener *listener); +#endif + void loop() override; + void dump_config() override; + + protected: + static constexpr size_t CRC_SUFFIX_LEN = 1; + static constexpr uint32_t BAUD_RATE = 9600; + + enum class State : uint8_t { + WAITING_FOR_START, + START_FRAME_RECEIVED, + END_FRAME_RECEIVED, + }; + +#ifdef MK2PVROUTER_LISTENER_COUNT + StaticVector mk2pvrouter_listeners_; +#endif + uint16_t buf_index_{0}; + State state_{State::WAITING_FOR_START}; + char tag_[MAX_TAG_SIZE]; + char val_[MAX_VAL_SIZE]; + char buf_[MAX_BUF_SIZE]; // Large buffer last to reduce padding + + bool read_chars_until_(bool drop, uint8_t c); + uint8_t calculate_crc_(const char *grp, size_t grp_len); + bool check_crc_(const char *grp, const char *grp_end); + void process_group_(const char *grp, const char *grp_end); + void publish_value_(const char *tag, const char *val); +}; +} // namespace esphome::mk2pvrouter diff --git a/esphome/components/mk2pvrouter/sensor/__init__.py b/esphome/components/mk2pvrouter/sensor/__init__.py new file mode 100644 index 0000000000..14fc48a626 --- /dev/null +++ b/esphome/components/mk2pvrouter/sensor/__init__.py @@ -0,0 +1,27 @@ +import esphome.codegen as cg +from esphome.components import sensor +from esphome.const import CONF_ID, CONF_TAG +from esphome.types import ConfigType + +from .. import ( + CONF_MK2PVROUTER_ID, + MK2PVROUTER_LISTENER_SCHEMA, + mk2pvrouter_ns, + register_mk2pvrouter_listener, +) + +Mk2PVRouterSensor = mk2pvrouter_ns.class_( + "Mk2PVRouterSensor", sensor.Sensor, cg.Component +) + +CONFIG_SCHEMA = sensor.sensor_schema(Mk2PVRouterSensor).extend( + MK2PVROUTER_LISTENER_SCHEMA +) + + +async def to_code(config: ConfigType) -> None: + var = cg.new_Pvariable(config[CONF_ID], config[CONF_TAG]) + await cg.register_component(var, config) + await sensor.register_sensor(var, config) + mk2pvrouter = await cg.get_variable(config[CONF_MK2PVROUTER_ID]) + await register_mk2pvrouter_listener(mk2pvrouter, var) diff --git a/esphome/components/mk2pvrouter/sensor/mk2pvrouter_sensor.cpp b/esphome/components/mk2pvrouter/sensor/mk2pvrouter_sensor.cpp new file mode 100644 index 0000000000..96f1ff5954 --- /dev/null +++ b/esphome/components/mk2pvrouter/sensor/mk2pvrouter_sensor.cpp @@ -0,0 +1,24 @@ +#include "mk2pvrouter_sensor.h" +#include "esphome/core/log.h" + +namespace esphome::mk2pvrouter { + +static const char *const TAG = "mk2pvrouter_sensor"; + +Mk2PVRouterSensor::Mk2PVRouterSensor(const char *tag) : Mk2PVRouterListener(tag) {} + +void Mk2PVRouterSensor::publish_val(const char *val) { + auto result = parse_number(val); + if (!result.has_value()) { + ESP_LOGW(TAG, "Failed to parse value '%s' for tag '%s'", val, this->get_tag()); + return; + } + this->publish_state(result.value()); +} + +void Mk2PVRouterSensor::dump_config() { + LOG_SENSOR(" ", "Mk2PVRouter Sensor", this); + ESP_LOGCONFIG(TAG, " Tag: %s", this->get_tag()); +} + +} // namespace esphome::mk2pvrouter diff --git a/esphome/components/mk2pvrouter/sensor/mk2pvrouter_sensor.h b/esphome/components/mk2pvrouter/sensor/mk2pvrouter_sensor.h new file mode 100644 index 0000000000..e4da41e384 --- /dev/null +++ b/esphome/components/mk2pvrouter/sensor/mk2pvrouter_sensor.h @@ -0,0 +1,15 @@ +#pragma once + +#include "esphome/components/mk2pvrouter/mk2pvrouter.h" +#include "esphome/components/sensor/sensor.h" + +namespace esphome::mk2pvrouter { + +class Mk2PVRouterSensor final : public Mk2PVRouterListener, public sensor::Sensor, public Component { + public: + explicit Mk2PVRouterSensor(const char *tag); + void publish_val(const char *val) override; + void dump_config() override; +}; + +} // namespace esphome::mk2pvrouter diff --git a/esphome/components/modbus/__init__.py b/esphome/components/modbus/__init__.py index 769858e72a..76cfdbed70 100644 --- a/esphome/components/modbus/__init__.py +++ b/esphome/components/modbus/__init__.py @@ -89,9 +89,8 @@ _WRITE_FUNCTION_CODES = frozenset({0x05, 0x06, 0x0F, 0x10, 0x16, 0x17}) def is_function_code_write(function_code: int) -> bool: """True if the Modbus function code writes (mutates). The exception bit (0x80) is masked off first, - so an exception-flagged code still classifies by its base code - stricter than the runtime hub, - whose classify() treats an exception-flagged code as a read. Keep in sync with - modbus::helpers::is_function_code_write().""" + so an exception-flagged code still classifies by its base code (the runtime hub never queues one: + queue_pdu() refuses them). Keep in sync with modbus::helpers::is_function_code_write().""" return function_code & 0x7F in _WRITE_FUNCTION_CODES diff --git a/esphome/components/modbus/modbus.cpp b/esphome/components/modbus/modbus.cpp index e83ffb2708..f428236a82 100644 --- a/esphome/components/modbus/modbus.cpp +++ b/esphome/components/modbus/modbus.cpp @@ -3,6 +3,7 @@ #include #include "esphome/core/application.h" +#include "esphome/core/hal.h" #include "esphome/core/helpers.h" #include "esphome/core/log.h" @@ -10,43 +11,55 @@ namespace esphome::modbus { static const char *const TAG = "modbus"; -// Maximum bytes to log for Modbus frames (truncated if larger) static constexpr size_t MODBUS_MAX_LOG_BYTES = 64; -// Approximate bits per character on the wire (depends on parity/stop bit config) -static constexpr uint32_t MODBUS_BITS_PER_CHAR = 11; -// Milliseconds per second -static constexpr uint32_t MS_PER_SEC = 1000; +static constexpr uint32_t US_PER_SEC = 1000000; +static constexpr uint32_t US_PER_MS = 1000; -// Shortest gap between two "no device accepted broadcast" warnings -static constexpr uint32_t UNACCEPTED_BROADCAST_WARN_INTERVAL_MS = 60 * MS_PER_SEC; +// Minimum interframe delay per the Modbus spec (fixed 1750us above 19200 baud) +static constexpr uint32_t MODBUS_MIN_FRAME_DELAY_US = 1750; + +// Diagnostics only: the backdated byte stamp can precede last_send_ (echo, or noise during our own +// send), where an unsigned wrap would print ~4.29e9. +static uint32_t us_since_send(uint32_t last_modbus_byte, uint32_t last_send) { + const uint32_t elapsed = last_modbus_byte - last_send; + return (int32_t) elapsed < 0 ? 0 : elapsed; +} void Modbus::setup() { if (this->flow_control_pin_ != nullptr) { this->flow_control_pin_->setup(); } - this->frame_delay_ms_ = - std::max(2, // 1750us minimum per spec - rounded up to 2ms. - // 3.5 characters * 11 bits per character * 1000ms/sec / (bits/sec) (Standard modbus frame delay) - (uint16_t) (3.5 * MODBUS_BITS_PER_CHAR * MS_PER_SEC / this->parent_->get_baud_rate()) + 1); + // RTU specifies 11 bits per character but 8N1 is 10, so derive it from the framing. The schema + // forbids a zero, so one here means the hub never set it (weikai): fall back to 8N1 and a 1 baud floor. + const uint8_t data_bits = this->parent_->get_data_bits() != 0 ? this->parent_->get_data_bits() : 8; + const uint8_t stop_bits = this->parent_->get_stop_bits() != 0 ? this->parent_->get_stop_bits() : 1; + const uint32_t baud_rate = std::max(1u, this->parent_->get_baud_rate()); + this->bits_per_char_ = static_cast( + 1 + data_bits + (this->parent_->get_parity() == uart::UART_CONFIG_PARITY_NONE ? 0 : 1) + stop_bits); + + // 3.5 characters * bits per character * 1e6 us/sec / (bits/sec) (Standard modbus frame delay) + this->frame_delay_us_ = + std::max(MODBUS_MIN_FRAME_DELAY_US, (uint32_t) (3.5 * this->bits_per_char_ * US_PER_SEC / baud_rate) + 1); // When rx_full_threshold is configured (non-zero), the UART has a hardware FIFO with a // meaningful threshold (e.g., ESP32 native UART), so we can calculate a precise delay. // Otherwise (e.g., USB UART), use 50ms to handle data arriving in chunks. - static constexpr uint16_t DEFAULT_LONG_RX_BUFFER_DELAY_MS = 50; + static constexpr uint32_t DEFAULT_LONG_RX_BUFFER_DELAY_US = 50 * US_PER_MS; size_t rx_threshold = this->parent_->get_rx_full_threshold(); - this->long_rx_buffer_delay_ms_ = - rx_threshold != uart::UARTComponent::RX_FULL_THRESHOLD_UNSET - ? (rx_threshold * MODBUS_BITS_PER_CHAR * MS_PER_SEC / this->parent_->get_baud_rate()) + 1 - : DEFAULT_LONG_RX_BUFFER_DELAY_MS; + this->long_rx_buffer_delay_us_ = rx_threshold != uart::UARTComponent::RX_FULL_THRESHOLD_UNSET + ? (uint32_t) (rx_threshold * this->bits_per_char_ * US_PER_SEC / baud_rate) + 1 + : DEFAULT_LONG_RX_BUFFER_DELAY_US; + + // The idle-timeout interrupt fires rx_timeout characters after the last byte, so that much silence + // has already passed by the time we read it: backdate so the gap measures silence on the wire. + this->rx_detect_latency_us_ = + (uint32_t) (this->parent_->get_rx_timeout() * this->bits_per_char_ * US_PER_SEC / baud_rate); } void Modbus::loop() { - // Receive any available bytes from UART this->receive_bytes_(); - - // Parse bytes into frames and process them this->parse_modbus_frames(); } @@ -55,12 +68,12 @@ void ModbusClientHub::loop() { // never times out an entry whose pending count has not been drained. No-op when nothing is owed. this->sweep_(); - this->Modbus::loop(); // receive bytes and parse frames + this->Modbus::loop(); // Send-wait watchdog: only the cheap time check runs at loop rate; expire_waiting_() looks the // entry up and holds off if the response has started arriving. if (this->waiting_for_response_ && - this->last_receive_check_ - this->last_send_ > this->last_send_tx_offset_ + this->send_wait_time_) { + this->last_receive_check_ - this->last_send_ > this->last_send_tx_offset_ + this->send_wait_time_us_) { this->expire_waiting_(); } @@ -80,7 +93,7 @@ void ModbusClientHub::expire_waiting_() { } // Only a genuine WAITING entry warrants the log (a cleared or interrupted shell timing out is expected). if (cmd->state == FrameState::WAITING) { - ESP_LOGW(TAG, "Stop waiting for response from %" PRIu8 " %" PRIu32 "ms after last send", cmd->frame.address(), + ESP_LOGW(TAG, "Stop waiting for response from %" PRIu8 " %" PRIu32 "us after last send", cmd->frame.address(), this->last_receive_check_ - this->last_send_); } // Deliver on_no_response directly, the way the parse path delivers response()/error(): the entry @@ -94,52 +107,50 @@ void ModbusClientHub::expire_waiting_() { bool Modbus::timeout_() { // If the response frame is finished (including interframe delay) - we timeout. // The long_rx_buffer_delay accounts for long responses (larger than the UART rx_full_threshold) to avoid timeouts - // when the buffer is filling the back half of the response - const uint16_t timeout = std::max( - (uint16_t) this->frame_delay_ms_, - (uint16_t) (this->rx_buffer_.size() >= this->parent_->get_rx_full_threshold() ? this->long_rx_buffer_delay_ms_ - : 0)); + // when the buffer is filling the back half of the response. The latch decides, not the current size: + // parsing a leading frame can shrink the buffer below the threshold while the rest is still streaming. + // The latency term covers the final batch, which is idle-delivered. + const uint32_t timeout = + this->exceeded_rx_full_threshold_ + ? std::max(this->frame_delay_us_, this->long_rx_buffer_delay_us_ + this->rx_detect_latency_us_) + : this->frame_delay_us_; return this->last_receive_check_ - this->last_modbus_byte_ > timeout; } +// We use micros() here and elsewhere instead of App.get_loop_component_start_time() to avoid stale timestamps +// It's critical in all timestamp comparisons that the left timestamp comes before the right one in time +// If we use a cached value in place of micros() and last_modbus_byte_ is updated inside our loop +// then the comparison is backwards (small negative which wraps to large positive) and will cause a false timeout +// So in this component we don't use any cached timestamp values to avoid these annoying bugs. +// Compare before subtracting: a signed difference would read a bus idle past half the micros() wrap +// (~35 min) as a huge delay still owed. +static inline uint32_t remaining_delay(uint32_t elapsed, uint32_t required) { + return elapsed >= required ? 0 : required - elapsed; +} + int32_t Modbus::tx_delay_remaining() { - // We use millis() here and elsewhere instead of App.get_loop_component_start_time() to avoid stale timestamps - // It's critical in all timestamp comparisons that the left timestamp comes before the right one in time - // If we use a cached value in place of millis() and last_modbus_byte_ is updated inside our loop - // then the comparison is backwards (small negative which wraps to large positive) and will cause a false timeout - // So in this component we don't use any cached timestamp values to avoid these annoying bugs - const uint32_t now = millis(); - return std::max({(int32_t) 0, - (int32_t) (this->last_send_tx_offset_ + this->frame_delay_ms_ - (now - this->last_send_)), - (int32_t) (this->frame_delay_ms_ - (now - this->last_modbus_byte_))}); + const uint32_t now = micros(); + return (int32_t) std::max(remaining_delay(now - this->last_send_, this->last_send_tx_offset_ + this->frame_delay_us_), + remaining_delay(now - this->last_modbus_byte_, this->frame_delay_us_)); } int32_t ModbusClientHub::tx_delay_remaining() { - const uint32_t now = millis(); - return std::max({(int32_t) 0, - (int32_t) (this->last_send_tx_offset_ + this->frame_delay_ms_ + this->turnaround_delay_ms_ - - (now - this->last_send_)), - (int32_t) (this->frame_delay_ms_ + this->turnaround_delay_ms_ - (now - this->last_modbus_byte_))}); + const uint32_t now = micros(); + return (int32_t) std::max( + remaining_delay(now - this->last_send_, + this->last_send_tx_offset_ + this->frame_delay_us_ + this->turnaround_delay_us_), + remaining_delay(now - this->last_modbus_byte_, this->frame_delay_us_ + this->turnaround_delay_us_)); } bool Modbus::tx_blocked() { - // We block transmission in any of these cases: - // 1. There are bytes in the UART Rx buffer - // 2. There are bytes in our Rx buffer - // 3. The last sent byte isn't more than tx_delay ms ago (i.e. wait to tell receivers that our previous Tx is done) - // 4. The last received byte isn't more than tx_delay ms ago (i.e. wait to be sure there isn't more Rx coming) - // N.B. We allow a small delay (MODBUS_TX_MAX_DELAY_MS) to avoid looping on small delays. This gets handled by - // send_frame_. - return this->available() || !this->rx_buffer_.empty() || this->tx_delay_remaining() > MODBUS_TX_MAX_DELAY_MS; + // Blocked while any rx bytes are pending, or within tx_delay of the last byte in either direction + // (receivers must see our previous tx as done, and more rx may be coming). A remaining delay up to + // MODBUS_TX_MAX_DELAY_US doesn't block - send_frame_ absorbs it instead of looping on small waits. + return this->available() || !this->rx_buffer_.empty() || this->tx_delay_remaining() > MODBUS_TX_MAX_DELAY_US; } -bool ModbusClientHub::tx_blocked() { - // We block transmission in any of these case: - // 1. We're waiting for a response (a waiting entry: WAITING/INTERRUPTED/WAITING_RETIRED/INTERRUPTED_RETIRED) - // 2. Any of the base class tx_blocked conditions - return this->waiting_for_response_ || this->Modbus::tx_blocked(); -} +bool ModbusClientHub::tx_blocked() { return this->waiting_for_response_ || this->Modbus::tx_blocked(); } bool ModbusClientHub::tx_buffer_empty() { // "Empty" for ready_for_immediate_send(): no one-shot is queued ahead of the caller. Entries in @@ -153,20 +164,26 @@ bool ModbusClientHub::tx_buffer_empty() { } void Modbus::receive_bytes_() { - this->last_receive_check_ = millis(); + this->last_receive_check_ = micros(); size_t bytes = this->available(); if (bytes) { size_t buffer_size = this->rx_buffer_.size(); - this->last_modbus_byte_ = this->last_receive_check_; + // Below the threshold the batch can only be idle-delivered, so its last byte finished one detection + // latency ago; at or above it the frame may still be streaming, so stamp now. + this->last_modbus_byte_ = bytes < this->parent_->get_rx_full_threshold() + ? this->last_receive_check_ - this->rx_detect_latency_us_ + : this->last_receive_check_; this->rx_buffer_.resize(buffer_size + bytes); if (!this->read_array(this->rx_buffer_.data() + buffer_size, bytes)) { this->rx_buffer_.resize(buffer_size); return; } + if (this->rx_buffer_.size() >= this->parent_->get_rx_full_threshold()) + this->exceeded_rx_full_threshold_ = true; if (buffer_size == 0) { - ESP_LOGV(TAG, "Received first byte %" PRIu8 " (0X%x) of %zu bytes %" PRIu32 "ms after last send", - this->rx_buffer_[0], this->rx_buffer_[0], this->rx_buffer_.size(), millis() - this->last_send_); + ESP_LOGV(TAG, "Received first byte %" PRIu8 " (0X%x) of %zu bytes %" PRIu32 "us after last send", + this->rx_buffer_[0], this->rx_buffer_[0], this->rx_buffer_.size(), micros() - this->last_send_); } } } @@ -219,10 +236,9 @@ void ModbusServerHub::parse_modbus_frames() { this->clear_rx_buffer_(LOG_STR("timeout after partial response"), true); } +// Scans forward from min_length to find a frame boundary by CRC match for unknown-length function codes. +// Returns the matched frame length, or 0 if no valid CRC was found within MAX_FRAME_SIZE. uint16_t Modbus::find_frame_end_by_crc_(uint16_t min_length) const { - // Unknown-length functions (user-defined codes, unimplemented management codes, unassigned values) - // could be any length - we have to rely on the CRC to determine completeness. - // If a CRC match is never found, the buffer will eventually overflow and be cleared. const uint8_t *raw = &this->rx_buffer_[0]; const size_t size = this->rx_buffer_.size(); const auto max_len = static_cast(std::min(size, size_t(MAX_FRAME_SIZE))); @@ -320,8 +336,8 @@ void ModbusClientHub::process_modbus_server_frame(uint8_t address, std::spanwaiting_for_response_ ? this->find_waiting_() : nullptr; if (cmd == nullptr) { ESP_LOGW(TAG, - "Received unexpected frame from address %" PRIu8 ", function code 0x%X, %" PRIu32 "ms after last send", - address, function_code, this->last_modbus_byte_ - this->last_send_); + "Received unexpected frame from address %" PRIu8 ", function code 0x%X, %" PRIu32 "us after last send", + address, function_code, us_since_send(this->last_modbus_byte_, this->last_send_)); return; } @@ -331,9 +347,9 @@ void ModbusClientHub::process_modbus_server_frame(uint8_t address, std::span %" PRIu8 " or function code 0x%X <> 0x%X, %" PRIu32 - "ms after last send", + "us after last send", address, expected_address, (function_code & FUNCTION_CODE_MASK), expected_function_code, - this->last_modbus_byte_ - this->last_send_); + us_since_send(this->last_modbus_byte_, this->last_send_)); // Unexpected frame: flip a WAITING entry to an INTERRUPTED shell that ignores the rest of this // transaction and blocks tx until the send-wait timeout, where it gets its on_no_response. cmd->interrupt(); @@ -346,8 +362,8 @@ void ModbusClientHub::process_modbus_server_frame(uint8_t address, std::spanlast_modbus_byte_ - this->last_send_); + "us after last send", + address, us_since_send(this->last_modbus_byte_, this->last_send_)); return; } @@ -358,12 +374,12 @@ void ModbusClientHub::process_modbus_server_frame(uint8_t address, std::spansweep_needed_ = true; if (helpers::is_function_code_exception(function_code)) { uint8_t exception = pdu[1]; // exception frames are fixed-length, so the code is always present - ESP_LOGW(TAG, "Error function code: 0x%X exception: %" PRIu8 ", address: %" PRIu8 ", %" PRIu32 "ms after last send", - function_code, exception, address, this->last_modbus_byte_ - this->last_send_); + ESP_LOGW(TAG, "Error function code: 0x%X exception: %" PRIu8 ", address: %" PRIu8 ", %" PRIu32 "us after last send", + function_code, exception, address, us_since_send(this->last_modbus_byte_, this->last_send_)); cmd->error(static_cast(exception)); } else if (!cmd->response(pdu)) { - ESP_LOGV(TAG, "Ignoring response from %" PRIu8 " - no callback device set, %" PRIu32 "ms after last send", address, - this->last_modbus_byte_ - this->last_send_); + ESP_LOGV(TAG, "Ignoring response from %" PRIu8 " - no callback device set, %" PRIu32 "us after last send", address, + us_since_send(this->last_modbus_byte_, this->last_send_)); } } @@ -531,8 +547,7 @@ void ModbusServerHub::process_broadcast_frame_(uint8_t function_code, std::span< return; } // A broadcast is never answered, so a rejecting device has no other feedback channel: report the - // per-device outcome at V, and warn if the write reached nobody at all. - bool accepted = false; + // per-device outcome at V. for (auto *device : this->devices_) { // Same handlers as an addressed write - a device cannot tell a broadcast apart, and does not need // to: the hub owns the difference, which is only that no reply is ever sent. @@ -542,24 +557,6 @@ void ModbusServerHub::process_broadcast_frame_(uint8_t function_code, std::span< if (device_status.has_value()) { ESP_LOGV(TAG, "Device %" PRIu8 " rejected broadcast write with exception %" PRIu8, device->get_address(), static_cast(device_status.value())); - } else { - accepted = true; - } - } - if (!accepted && !this->devices_.empty()) { - const uint16_t entity_count = coils ? coil_count : static_cast(registers.size()); - const LogString *const entity_name = coils ? LOG_STR("coils") : LOG_STR("registers"); - // Warn at most once per interval, then drop to VERBOSE: on a shared bus a broadcast aimed at other nodes - // repeats forever, so warning per frame would flood the log. - const uint32_t now = millis(); - if (this->last_unaccepted_broadcast_warn_ == 0 || - now - this->last_unaccepted_broadcast_warn_ > UNACCEPTED_BROADCAST_WARN_INTERVAL_MS) { - this->last_unaccepted_broadcast_warn_ = now; - ESP_LOGW(TAG, "No device accepted broadcast write of %" PRIu16 " %s at 0x%04X", entity_count, - LOG_STR_ARG(entity_name), start_address); - } else { - ESP_LOGV(TAG, "No device accepted broadcast write of %" PRIu16 " %s at 0x%04X", entity_count, - LOG_STR_ARG(entity_name), start_address); } } } @@ -778,13 +775,18 @@ void ModbusServerHub::process_modbus_client_frame_(uint8_t address, uint8_t func // Callers gate on tx_blocked() first, but the pre-send delay below can span several ms, so re-check // after it and refuse (return false) if a byte arrived in that window rather than transmit over it. bool Modbus::send_frame_(const ModbusFrame &frame) { - const int32_t tx_delay_remaining = this->tx_delay_remaining(); + int32_t tx_delay_remaining = this->tx_delay_remaining(); if (tx_delay_remaining > 0) { - delay(tx_delay_remaining); + // Yield the whole-ms part: delay() never blocks past the request on FreeRTOS, and only slightly + // over elsewhere, which just lengthens the gap. The recompute below makes the remainder exact. + if (tx_delay_remaining >= (int32_t) US_PER_MS) { + delay(tx_delay_remaining / US_PER_MS); + tx_delay_remaining = this->tx_delay_remaining(); + } + if (tx_delay_remaining > 0) + delayMicroseconds(tx_delay_remaining); } - // The delay above can span several ms; a byte arriving in that window blocks transmission after the - // caller's gate already passed. Don't collide with the incoming frame - leave the entry to retry. if (this->tx_blocked()) { return false; } @@ -797,14 +799,15 @@ bool Modbus::send_frame_(const ModbusFrame &frame) { this->last_send_tx_offset_ = 0; } else { this->write_array(frame.data.data(), frame.size()); - this->last_send_tx_offset_ = frame.size() * MODBUS_BITS_PER_CHAR * MS_PER_SEC / this->parent_->get_baud_rate() + 1; + this->last_send_tx_offset_ = + frame.size() * this->bits_per_char_ * US_PER_SEC / std::max(1u, this->parent_->get_baud_rate()) + 1; } - uint32_t now = millis(); + uint32_t now = micros(); #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE char hex_buf[format_hex_pretty_size(MODBUS_MAX_LOG_BYTES)]; #endif - ESP_LOGV(TAG, "Write: %s %" PRIu32 "ms after last send, %" PRIu32 "ms after last receive", + ESP_LOGV(TAG, "Write: %s %" PRIu32 "us after last send, %" PRIu32 "us after last receive", format_hex_pretty_to(hex_buf, frame.data.data(), frame.size()), now - this->last_send_, now - this->last_modbus_byte_); this->last_send_ = now; @@ -812,6 +815,9 @@ bool Modbus::send_frame_(const ModbusFrame &frame) { } void ModbusClientHub::send_next_frame_() { + if (this->tx_buffer_.empty()) + return; + if (this->tx_blocked()) return; @@ -831,7 +837,7 @@ void ModbusClientHub::send_next_frame_() { // reports the transmission, and the entry then retires with no terminal callback instead of // occupying the waiting slot until the send-wait timeout expires. The turnaround delay already // spaces the next frame; the following sweep erases the entry. - ESP_LOGV(TAG, "Broadcast to address 0 sent; no reply expected (fire-and-forget)"); + ESP_LOGV(TAG, "Broadcast to address 0 sent; no reply expected"); cmd->complete_broadcast(); this->sweep_needed_ = true; return; @@ -842,20 +848,25 @@ void ModbusClientHub::send_next_frame_() { void ModbusClientHub::dump_config() { ESP_LOGCONFIG(TAG, "Modbus:\n" - " Send Wait Time: %" PRIu16 " ms\n" - " Turnaround Time: %" PRIu16 " ms\n" - " Frame Delay: %" PRIu16 " ms\n" - " Long Rx Buffer Delay: %" PRIu16 " ms", - this->send_wait_time_, this->turnaround_delay_ms_, this->frame_delay_ms_, - this->long_rx_buffer_delay_ms_); + " Send Wait Time: %" PRIu32 " ms\n" + " Turnaround Time: %" PRIu32 " ms\n" + " Frame Delay: %" PRIu32 " us\n" + " Long Rx Buffer Delay: %" PRIu32 " us\n" + " Bits Per Character: %" PRIu8 "\n" + " Rx Detect Latency: %" PRIu32 " us", + this->send_wait_time_us_ / US_PER_MS, this->turnaround_delay_us_ / US_PER_MS, this->frame_delay_us_, + this->long_rx_buffer_delay_us_, this->bits_per_char_, this->rx_detect_latency_us_); LOG_PIN(" Flow Control Pin: ", this->flow_control_pin_); } void ModbusServerHub::dump_config() { ESP_LOGCONFIG(TAG, "Modbus:\n" - " Frame Delay: %" PRIu16 " ms\n" - " Long Rx Buffer Delay: %" PRIu16 " ms", - this->frame_delay_ms_, this->long_rx_buffer_delay_ms_); + " Frame Delay: %" PRIu32 " us\n" + " Long Rx Buffer Delay: %" PRIu32 " us\n" + " Bits Per Character: %" PRIu8 "\n" + " Rx Detect Latency: %" PRIu32 " us", + this->frame_delay_us_, this->long_rx_buffer_delay_us_, this->bits_per_char_, + this->rx_detect_latency_us_); LOG_PIN(" Flow Control Pin: ", this->flow_control_pin_); } @@ -983,6 +994,8 @@ bool ModbusDeviceCommand::timed_out() { this->decrement_pending(); // resolve this request (WAITING-origin, so pending >= 1) if (this->device == nullptr) return false; // resolved, no one to tell + // A cleared frame that timed out still honors a retry: the clear is address-scoped (any device may + // call it) while the retry is the owning device's call via on_no_response - the bus obeys the owner. if (this->device->on_no_response(this->frame.pdu())) this->increment_pending(); // granted retry = re-request (capped) return true; @@ -1054,18 +1067,14 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span pdu, M ESP_LOGE(TAG, "Frame too large, refused: %" PRIu8 ":%zu bytes", address, pdu.size()); return false; } - // classify() drives both the broadcast guard and the continuous check below; compute it once. - const CommandPriority priority = ModbusDeviceCommand::classify(pdu[0]); - // A broadcast (address 0) is never answered (Modbus 4.1), so it is only meaningful for a command that - // changes state. Refuse a broadcast that expects a reply - anything but a write or a custom/vendor code - - // as it could never deliver a result, so the caller learns via the false return (and on_not_sent). - // 0x17 (read/write multiple) is a knowing inclusion: classify() treats it as a write, so its write half - // lands on every server and its unanswerable read half is simply discarded. An exception-flagged custom - // code (0x80 bit set) is refused: is_function_code_custom() masks that bit away, so exclude it explicitly - // here to match classify()'s exception-first handling of the write side. - if (address == BROADCAST_ADDRESS && priority != CommandPriority::WRITE && - (!helpers::is_function_code_custom(pdu[0]) || helpers::is_function_code_exception(pdu[0]))) { + if (helpers::is_function_code_exception(pdu[0])) { + ESP_LOGW(TAG, "Exception PDU refused for address %" PRIu8 ": function code 0x%X has the exception bit set", address, + pdu[0]); + return false; + } + + if (address == BROADCAST_ADDRESS && !helpers::is_function_code_broadcastable(pdu[0])) { ESP_LOGW(TAG, "Broadcast refused for function 0x%X: a broadcast (address 0) is never answered", pdu[0]); return false; } @@ -1073,7 +1082,7 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span pdu, M // Normalize the caller's options in place (the param is a by-value copy) so everything stored or // merged below carries effective options, never the raw request. // continuous is ignored for every mutating code (re-writing a value forever is never intended). - if (options.continuous && priority == CommandPriority::WRITE) { + if (options.continuous && helpers::is_function_code_write(pdu[0])) { ESP_LOGW(TAG, "continuous is ignored for a mutating function (0x%X, address %" PRIu8 ")", pdu[0], address); options.continuous = false; } @@ -1089,9 +1098,7 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span pdu, M continue; if (device == nullptr) { // A dropped read is routine (DEBUG); a dropped write/custom warns (unobservable without a device). - const bool requeueable = - !helpers::is_function_code_exception(pdu[0]) && helpers::is_function_code_read_only(pdu[0]); - if (requeueable) { + if (helpers::is_function_code_read_only(pdu[0])) { ESP_LOGD(TAG, "Anonymous duplicate of active frame for %" PRIu8 " (function 0x%X), dropped", address, pdu[0]); } else { ESP_LOGW(TAG, @@ -1188,18 +1195,21 @@ void ModbusServerHub::send_raw_(const uint8_t *payload, uint16_t len) { // without a heap allocation. Only one server reply is ever waiting, so a single buffer suffices. std::memcpy(this->deferred_payload_.data(), payload, len); this->deferred_payload_len_ = len; - this->set_timeout("deferred_send", this->tx_delay_remaining(), [this]() { + // set_timeout() takes milliseconds; round the microsecond delay up so we never fire early. + this->set_timeout("deferred_send", (this->tx_delay_remaining() + US_PER_MS - 1) / US_PER_MS, [this]() { ModbusFrame frame(this->deferred_payload_[0], this->deferred_payload_.data() + 1, this->deferred_payload_len_ - 1); - if (!this->send_frame_(frame)) + if (!this->send_frame_(frame)) { ESP_LOGE(TAG, "Deferred server reply dropped: transmission still blocked"); + } }); return; } ModbusFrame frame(payload[0], payload + 1, len - 1); - if (!this->send_frame_(frame)) + if (!this->send_frame_(frame)) { ESP_LOGE(TAG, "Server reply dropped: a frame arrived during the send delay"); + } } void Modbus::clear_rx_buffer_(const LogString *reason, bool warn, size_t bytes_to_clear) { @@ -1208,11 +1218,11 @@ void Modbus::clear_rx_buffer_(const LogString *reason, bool warn, size_t bytes_t bytes = bytes_to_clear; if (bytes > 0) { if (warn) { - ESP_LOGW(TAG, "Clearing buffer of %zu bytes - %s %" PRIu32 "ms after last send", bytes, LOG_STR_ARG(reason), - millis() - this->last_send_); + ESP_LOGW(TAG, "Clearing buffer of %zu bytes - %s %" PRIu32 "us after last send", bytes, LOG_STR_ARG(reason), + micros() - this->last_send_); } else { - ESP_LOGV(TAG, "Clearing buffer of %zu bytes - %s %" PRIu32 "ms after last send", bytes, LOG_STR_ARG(reason), - millis() - this->last_send_); + ESP_LOGV(TAG, "Clearing buffer of %zu bytes - %s %" PRIu32 "us after last send", bytes, LOG_STR_ARG(reason), + micros() - this->last_send_); } if (bytes == this->rx_buffer_.size()) { this->rx_buffer_.clear(); @@ -1220,6 +1230,8 @@ void Modbus::clear_rx_buffer_(const LogString *reason, bool warn, size_t bytes_t this->rx_buffer_.erase(this->rx_buffer_.begin(), this->rx_buffer_.begin() + bytes); } } + if (this->rx_buffer_.empty()) + this->exceeded_rx_full_threshold_ = false; } void ModbusClientDevice::dispatch_response_(std::span request_pdu, std::span response_pdu, @@ -1364,7 +1376,6 @@ void ModbusClientDevice::dispatch_response_(std::span request_pdu } } -// Default on_custom_response handler to warn when responses unexpectedly trigger on_custom_response void ModbusClientDevice::on_custom_response(std::span request_pdu, std::span response_pdu, ResponseStatus status) { // The dispatcher never calls this with an empty request, but this is a public virtual - stay safe. diff --git a/esphome/components/modbus/modbus.h b/esphome/components/modbus/modbus.h index e766ff04cc..7d7818239d 100644 --- a/esphome/components/modbus/modbus.h +++ b/esphome/components/modbus/modbus.h @@ -16,26 +16,21 @@ namespace esphome::modbus { -// Tx queue backstop. Duplicate frames dedup into one entry, so reads can never approach this in a -// sane config - it exists to stop a runaway generator of distinct frames (e.g. a loop writing a -// changing value) from growing the heap unboundedly. The deque grows on demand; this reserves nothing. -// Worst case the cap permits: 128 distinct max-size frames = ~32 kB of spilled frame data plus -// ~3 kB of deque node storage (typical 8-byte frames stay inline; large PDUs spill to one -// allocation each) - pathological configs only, but the numbers matter when tuning for ESP8266. +// Tx queue backstop: duplicates dedup into one entry, so only a runaway generator of distinct frames +// (e.g. a loop writing a changing value) could grow the heap unboundedly. static constexpr uint16_t MODBUS_TX_BUFFER_SIZE = 128; -static constexpr uint16_t MODBUS_TX_MAX_DELAY_MS = 5; +static constexpr uint16_t MODBUS_TX_MAX_DELAY_US = 5000; // Typical frames -- reads and single-register/coil writes -- are exactly 8 bytes -// (address + 5-byte PDU + 2-byte CRC) and fit inline with no heap allocation. +// (address + 5-byte PDU + 2-byte CRC). static constexpr uint16_t MODBUS_FRAME_INLINE_SIZE = 8; struct ModbusFrame { - // Frame held in a small-buffer-optimized buffer. Typical frames fit inline; only larger - // multi-register or custom frames spill to a single heap allocation. This keeps the common, - // high-frequency tx traffic off the heap entirely, avoiding per-frame alloc/free churn. - // The buffer tracks its own length, so no separate size field is needed. - SmallInlineBuffer data; // Modbus RTU max is 256 bytes + // Small-buffer-optimized: typical frames fit inline, keeping high-frequency tx traffic off the + // heap; only large multi-register or custom frames spill to a single heap allocation. + SmallInlineBuffer data; + // A frame is [address][PDU...][CRC lo][CRC hi]. These are the only places that need to know that layout ModbusFrame(uint8_t address, const uint8_t *pdu, uint16_t pdu_len) { uint8_t *buf = this->data.init(pdu_len + 3); buf[0] = address; @@ -46,12 +41,9 @@ struct ModbusFrame { } uint16_t size() const { return static_cast(this->data.size()); } - - // A frame is [address][PDU...][CRC lo][CRC hi]. These are the only places that need to know that layout uint8_t address() const { return this->data.data()[0]; } - /// The PDU: function code + data, without address or CRC. Only valid while the frame is alive. - /// Requires a complete frame (size() >= MIN_FRAME_SIZE, guaranteed by the constructors) - the - /// subtraction would wrap on anything shorter. + /// A PDU is [function code][data...] without address or CRC. Only valid while the frame is alive. + /// Requires a complete frame (size() >= MIN_FRAME_SIZE, guaranteed by the constructors) std::span pdu() const { return std::span(this->data.data() + 1, this->size() - 3u); } }; @@ -73,23 +65,23 @@ class Modbus : public uart::UARTDevice, public Component { virtual int32_t tx_delay_remaining(); virtual void parse_modbus_frames() = 0; bool parse_modbus_server_frame_(); - // pdu is the whole PDU (function code + payload, no address/CRC); pdu[0] is the (standard or custom) function code. virtual void process_modbus_server_frame(uint8_t address, std::span pdu) = 0; void clear_rx_buffer_(const LogString *reason, bool warn = false, size_t bytes_to_clear = 0); - // Transmit a frame. Callers gate on tx_blocked() first, but the pre-send delay can span several ms, - // so this re-checks after the delay and returns false without transmitting if a byte arrived in that - // window (the caller then leaves its entry to retry). Returns true once the frame has been transmitted. bool send_frame_(const ModbusFrame &frame); - // Scans forward from min_length to find a frame boundary by CRC match for custom function codes. - // Returns the matched frame length, or 0 if no valid CRC was found within MAX_FRAME_SIZE. uint16_t find_frame_end_by_crc_(uint16_t min_length) const; + // All timestamps and durations below are micros()-based uint32_t last_modbus_byte_{0}; uint32_t last_receive_check_{0}; uint32_t last_send_{0}; uint32_t last_send_tx_offset_{0}; - uint16_t frame_delay_ms_{5}; - uint16_t long_rx_buffer_delay_ms_{0}; + uint32_t frame_delay_us_{5000}; + uint32_t long_rx_buffer_delay_us_{0}; + uint32_t rx_detect_latency_us_{0}; + // Bits on the wire per character (start + data + optional parity + stop); 12 at most. + uint8_t bits_per_char_{11}; + // Latched when a read reaches rx_full_threshold, cleared when the buffer drains. + bool exceeded_rx_full_threshold_{false}; GPIOPin *flow_control_pin_{nullptr}; @@ -99,8 +91,7 @@ class Modbus : public uart::UARTDevice, public Component { class ModbusClientDevice; class ModbusServerDevice; -// Transmit ordering, highest first: writes before one-shot reads before continuous polls. Derived -// at selection time, never caller-chosen or stored. +// Transmit ordering, highest first: writes before one-shot reads before continuous polls. enum class CommandPriority : uint8_t { CONTINUOUS = 0, READ, WRITE }; // Per-entry lifecycle state. Waiting states (see waiting_state()) hold the bus; the sweep delivers owed @@ -112,20 +103,15 @@ enum class FrameState : uint8_t { RECEIVED_EXCEPTION, TIMED_OUT, // on_no_response delivered at the send-wait timeout; awaiting reschedule/erase INTERRUPTED, // unexpected frame arrived; ignores this transaction, waits out the timeout - WAITING_RETIRED, // cleared while WAITING: a late response is still delivered as its usual terminal - INTERRUPTED_RETIRED, // cleared while INTERRUPTED: still distrusts late frames, ends in on_no_response - RETIRED, // cleared, off the wire + WAITING_RETIRED, // retired while WAITING: a late response is still delivered as its usual terminal + INTERRUPTED_RETIRED, // retired while INTERRUPTED: still distrusts late frames, ends in on_no_response + RETIRED, // retired, off the wire }; // Per-command send options. Append-only; pass via designated initializers ({.continuous = true}). -// The queue entry stores this struct whole, so a new field arrives at the queue with no plumbing - -// but it arrives inert. Every new field must define three rules before it does anything: -// 1. normalization in queue_pdu() (is it valid for this function code? e.g. continuous is -// stripped for mutating codes), -// 2. a merge rule for when a duplicate send absorbs into a live entry (continuous -// upgrades/downgrades via make_continuous(); a new field needs its own answer), -// 3. teardown: retire() resets the whole struct; silent_retire() leaves it, relying on the sweep -// to erase the entry. +// A new field reaches the queue with no plumbing but arrives inert until it defines three rules: +// normalization in queue_pdu(), a merge rule for duplicate absorption, and teardown in +// retire()/silent_retire(). struct CommandOptions { // A continuous poll lives in the queue until cancelled or failed; ignored for mutating codes. bool continuous{false}; @@ -135,17 +121,13 @@ struct ModbusDeviceCommand { ModbusClientDevice *device; ModbusFrame frame; // Place-in-line stamp (hub's free-running counter); selection takes the oldest for round-robin - // fairness within a class. Meant to wrap. Declared ahead of the byte fields so the tail packs - // densely and a growing CommandOptions eats trailing padding before enlarging the struct. + // fairness within a class. Meant to wrap. uint16_t seq{0}; FrameState state{FrameState::READY}; // Accepted requests this entry stands for, capped at max_pending(); drains one terminal each. // A continuous poll is a subscription: pending fixed at 1, removed only by cancellation or failure. uint8_t pending{1}; - // The entry's LIVE effective options, not a record of the caller's request: queue_pdu() normalizes - // before storing, duplicate absorption mutates continuous via make_continuous(), and retire() resets - // the struct (silent_retire() leaves it, relying on the sweep to erase the entry). See the - // CommandOptions comment for the rules a new field must define. + // The entry's LIVE effective options, not a record of the caller's request CommandOptions options; // Build a command from a PDU span (caller bounds it to MAX_PDU_SIZE) and pre-normalized options; @@ -154,28 +136,22 @@ struct ModbusDeviceCommand { CommandOptions options = {}, uint16_t seq = 0) : device(device), frame(address, pdu.data(), static_cast(pdu.size())), seq(seq), options(options) {} - // Transmit ordering class, derived (never stored): a continuous poll ranks below every one-shot. CommandPriority priority() const { - return this->options.continuous ? CommandPriority::CONTINUOUS : classify(this->frame.pdu()[0]); - } - // Wire-derived class: mutating codes rank WRITE; exception-flagged codes are excluded. - static CommandPriority classify(uint8_t function_code) { - if (helpers::is_function_code_exception(function_code)) - return CommandPriority::READ; - if (helpers::is_function_code_write(function_code)) { + if (this->options.continuous) + return CommandPriority::CONTINUOUS; + if (helpers::is_function_code_write(this->frame.pdu()[0])) { return CommandPriority::WRITE; } return CommandPriority::READ; } - // Requests this entry can serve: a standard read twice (run plus one re-run), everything else once. + // Requests this entry can serve uint8_t max_pending() const { const uint8_t fc = this->frame.pdu()[0]; - const bool requeueable = !helpers::is_function_code_exception(fc) && helpers::is_function_code_read_only(fc); - return (requeueable && !this->options.continuous) ? 2 : 1; + return (helpers::is_function_code_read_only(fc) && !this->options.continuous) ? 2 : 1; } - // Device-scoped clear: detach with no callback (device-less, pending 0). An entry still waiting for - // a response keeps its state as a reply-ignoring shell that resolves silently; any other goes RETIRED. + // Device-scoped clear: detach with no callback. An entry still waiting for a response keeps its state as a + // reply-ignoring shell that resolves silently; any other goes RETIRED. void silent_retire() { if (!this->waiting_state()) this->state = FrameState::RETIRED; @@ -183,28 +159,18 @@ struct ModbusDeviceCommand { this->device = nullptr; } // Fire-and-forget completion for a broadcast (address 0): the frame was transmitted (on_sent already - // fired), but a broadcast is never answered (Modbus 4.1), so the entry retires with NO terminal - // callback and the sweep erases it. Unlike response()/error()/timed_out(), it delivers nothing. - // A broadcast only carries a write or a custom code (reads are refused at queue_pdu()), and every such - // code caps pending at 1, so pending is always 1 here - clear it. + // fired), but a broadcast is never answered (Modbus 4.1), so the entry retires with no terminal callback. void complete_broadcast() { this->state = FrameState::RETIRED; this->pending = 0; } - // Re-ready for another transmission, restamped to the tail of its class (hub passes next_seq_++). + // Re-ready for another transmission, restamped to the tail of its class void requeue(uint16_t seq) { this->state = FrameState::READY; this->seq = seq; } // Re-task a frame that lives on: upgrade a one-shot to a continuous poll, or downgrade a poll back to - // a one-shot. Either way the entry keeps running and owes a request, so this is not a plain setter - - // to tear an entry down instead, use retire()/silent_retire(), which leave pending as the count owed. - // On: the entry becomes a continuous poll, superseding any absorbed requests (pending resets to the - // single subscription). Off: a one-shot duplicate has cancelled the poll, but the entry must still run - // once to serve that request - so restore one first. While the flag is still set max_pending() is 1, - // so the restore lifts a terminated poll (pending 0, after an error/timeout) back to 1 and is a no-op - // on a live poll already at 1; the flag drops afterwards, when a read's cap can widen to 2 without - // retroactively inflating that no-op. + // a one-shot. void make_continuous(bool continuous) { if (continuous) { this->options.continuous = true; @@ -214,13 +180,9 @@ struct ModbusDeviceCommand { this->options.continuous = false; } } - // Address-scoped clear: keep pending and device so the sweep delivers one on_not_sent() per un-run + // Address-scoped clear: keep pending and device so the sweep delivers one on_not_sent() per un-delivered // request. An entry still waiting for a response keeps its in-flight request (whose usual terminal is - // still coming) and drains only its duplicates: WAITING -> WAITING_RETIRED, and INTERRUPTED -> - // INTERRUPTED_RETIRED which keeps distrusting late frames (they were already interrupted). Any other - // state -> RETIRED, draining everything. A cleared frame that then times out still honors a retry: - // the clear is address-scoped (any device may call it) while the retry is the owning device's call - // via on_no_response - the bus obeys the owner. + // still coming) and drains only its duplicates. void retire() { if (this->state == FrameState::WAITING) { this->state = FrameState::WAITING_RETIRED; @@ -229,10 +191,10 @@ struct ModbusDeviceCommand { } else if (!this->waiting_state()) { // an already-retired shell stays put; off the wire -> RETIRED this->state = FrameState::RETIRED; } - this->options = {}; // reset every option so a future field is torn down without editing here + this->options = {}; // reset every option } - // True while the entry is still waiting for a response; the erase pass exempts these even at pending 0. + // True while the entry is still waiting for a response bool waiting_state() const { return this->state == FrameState::WAITING || this->state == FrameState::INTERRUPTED || this->state == FrameState::WAITING_RETIRED || this->state == FrameState::INTERRUPTED_RETIRED; @@ -245,7 +207,7 @@ struct ModbusDeviceCommand { } return false; } - // Add one request, honouring the cap; false = already at cap (absorb a duplicate, restore a retry). + bool increment_pending() { if (this->pending < this->max_pending()) { this->pending++; @@ -255,7 +217,7 @@ struct ModbusDeviceCommand { } // Terminal/lifecycle methods: each owns its transition, callback, and pending accounting and - // returns whether a callback ran. Out-of-line: ModbusClientDevice is incomplete here. + // returns whether a callback ran. bool sent(); bool response(std::span response_pdu); bool error(ExceptionCode exception_code); @@ -264,9 +226,6 @@ struct ModbusDeviceCommand { bool notify_retired(); /// True if this command carries the same wire frame (address + PDU) as the given one. - /// Cancellation matches the exact frame, not the action instance: a continuous poll whose - /// start_address (or other field) is templated produces one poll per distinct frame, and a later - /// cancel built from different argument values will not reach the polls it does not byte-match. bool same_frame(uint8_t address, std::span pdu) const { const auto own_pdu = this->frame.pdu(); return own_pdu.size() == pdu.size() && this->frame.address() == address && @@ -279,8 +238,9 @@ class ModbusClientHub : public Modbus { ModbusClientHub() = default; void dump_config() override; void loop() override; - void set_send_wait_time(uint16_t time_in_ms) { this->send_wait_time_ = time_in_ms; } - void set_turnaround_time(uint16_t time_in_ms) { this->turnaround_delay_ms_ = time_in_ms; } + // Config arrives in milliseconds; stored internally in microseconds like all other timing. + void set_send_wait_time(uint16_t time_in_ms) { this->send_wait_time_us_ = time_in_ms * 1000UL; } + void set_turnaround_time(uint16_t time_in_ms) { this->turnaround_delay_us_ = time_in_ms * 1000UL; } bool tx_buffer_empty(); bool tx_blocked() override; ESPDEPRECATED("Use queue_pdu() with create_client_pdu() instead. Removed in 2026.10.0", "2026.4.0") @@ -291,17 +251,13 @@ class ModbusClientHub : public Modbus { payload_len), device); }; - /// Queue a request. The name says queue, not send: the frame is appended to the transmit queue and - /// goes out later from loop(), so a true return means accepted into the machine (it will resolve in - /// exactly one terminal callback - except a broadcast (address 0), which is never answered and so gets - /// only on_sent()), NOT that anything reached the wire - that is on_sent(). False means - /// it never entered the machine at all (empty or oversize PDU, full queue, anonymous or over-cap - /// duplicate) and no callback of any kind will follow; the false return is the whole story. + /// Queue a request. True = accepted: it resolves in exactly one terminal callback (a broadcast, + /// address 0, gets only on_sent()). False = refused, and no callback of any kind follows. + /// Neither means anything reached the wire - on_sent() reports that. bool queue_pdu(uint8_t address, std::span pdu, ModbusClientDevice *device = nullptr, CommandOptions options = {}); - // Remove before 2027.2.0. Deliberately the signature 2026.7.4 shipped - void, and no CommandOptions: - // the bool return and the options argument arrived after that release, so nothing external can be - // relying on them under this name. Callers who want the queued/refused answer move to queue_pdu(). + // Remove before 2027.2.0. Deliberately the void, no-options signature 2026.7.4 shipped: nothing + // external can rely on the later additions under this name. ESPDEPRECATED("Use queue_pdu() instead - the call queues a request, it does not send one, and it " "reports whether the request was accepted. Removed in 2027.2.0", "2026.8.0") @@ -310,9 +266,10 @@ class ModbusClientHub : public Modbus { } ESPDEPRECATED("Use queue_pdu(payload[0], , device) instead. Removed in 2027.2.0", "2026.8.0") void send_raw(const std::vector &payload, ModbusClientDevice *device = nullptr); - // Clear an address's commands; each un-run request resolves via on_not_sent(), but a frame on the - // wire still runs to its usual terminal. clear_tx_queue_for_device() instead discards silently. + // Clear all commands matching the given address; each unsent request resolves via on_not_sent(), but a + // frame on the wire still runs to its usual terminal. void clear_tx_queue_for_address(uint8_t address); + // Clear all commands for a given device; no callbacks are delivered. void clear_tx_queue_for_device(ModbusClientDevice *device); protected: @@ -322,16 +279,15 @@ class ModbusClientHub : public Modbus { void send_next_frame_(); // Deliver owed callbacks from a quiescent hub and apply lifecycle bookkeeping; see FrameState. void sweep_(); - // The selection function: best READY entry (WRITE class first, then one-shot reads, then the - // least-recently-served continuous; FIFO by seq within each group), or nullptr. + // The selection function: best READY entry (ordered by priority; FIFO by seq within each group), or nullptr. ModbusDeviceCommand *select_next_ready_(); // Locate the single entry waiting for a response (WAITING/INTERRUPTED/WAITING_RETIRED/INTERRUPTED_RETIRED). ModbusDeviceCommand *find_waiting_(); // End the wait for a response on send-wait timeout (the loop() watchdog body); see FrameState. void expire_waiting_(); - uint16_t send_wait_time_{2000}; - uint16_t turnaround_delay_ms_{0}; + uint32_t send_wait_time_us_{2000000}; + uint32_t turnaround_delay_us_{0}; // Set on transmit, cleared on the transaction-ending transition; send_next_frame_ won't select // while it is set, so at most one frame is awaiting a response. @@ -349,13 +305,10 @@ class ModbusClientHub : public Modbus { // Transaction status: std::nullopt on success, otherwise a Modbus exception code using ResponseStatus = std::optional; -/// True when a transaction carried no exception. The optional holds the exception, so has_value() means -/// the request FAILED - the inverse of how "status" usually reads. Prefer this at the call site; the -/// bare !status.has_value() has already been mistaken for a failure check more than once. Where the code -/// is going to unwrap the exception anyway, status.has_value() followed by status.value() stays clearer. +/// True when a transaction carried no exception. inline bool succeeded(ResponseStatus status) { return !status.has_value(); } -// Register values exchanged with server handlers, in host byte order. Sized at the larger of the two protocol +// Register values exchanged with server handlers, in address order. Sized at the larger of the two protocol // maxima (read = 125 / 0x7D, write = 123 / 0x7B); the per-direction count limit is enforced by the hub, not by // the capacity of this type. using RegisterValues = StaticVector; @@ -373,59 +326,46 @@ class ModbusServerHub : public Modbus { void process_modbus_client_frame_(uint8_t address, uint8_t function_code, std::span data); // Dispatches a broadcast (address 0) write to every registered device; broadcasts are never answered. void process_broadcast_frame_(uint8_t function_code, std::span data); - // Parses a WRITE_SINGLE_REGISTER / WRITE_MULTIPLE_REGISTERS PDU into start_address and the host-order register - // values, validating the register count and address range. Returns std::nullopt on success, otherwise the Modbus - // exception code describing the failure. Shared by unicast writes (which reply with the exception) and broadcast - // writes (which silently drop invalid frames). + // Parses a WRITE_SINGLE_REGISTER / WRITE_MULTIPLE_REGISTERS PDU into start_address and the address order register + // values, validating the register count and address range. Shared by unicast and broadcast writes. ResponseStatus parse_write_single_(std::span data, uint16_t &start_address, RegisterValues ®isters); ResponseStatus parse_write_multiple_(std::span data, uint16_t &start_address, RegisterValues ®isters); - // Appends the big-endian register values in values to registers, in host byte order. + // Assembles host-order registers from the big-endian bytes in values and appends them to registers. void assemble_registers_(std::span values, RegisterValues ®isters); ModbusServerDevice *find_device_(uint8_t address); - // Returns std::nullopt if [start_address, start_address + count) fits in the 16-bit address space, - // otherwise ILLEGAL_DATA_ADDRESS. The caller sends the exception reply if one is required - a broadcast - // write is never answered, so the check cannot send it itself. Shared by the register and - // coil/discrete-input handlers, which all address the same 16-bit space. + // Returns std::nullopt if [start_address, start_address + count) fits in a 16-bit address space, otherwise + // ILLEGAL_DATA_ADDRESS. The caller sends the exception reply if one is required. Shared by the + // register/coil/discrete-input handlers, which all use a 16-bit address space. ResponseStatus check_address_range_(uint16_t start_address, uint16_t count); - // Parses a read request PDU (start address(2) + quantity(2)), shared by the register and - // coil/discrete-input reads so the two cannot drift apart. max_entities is the protocol ceiling for the - // function code; entity_name only labels the rejection log. + // Parses read request data. max_entities is the protocol ceiling for the function code; entity_name labels + // the rejection log. ResponseStatus parse_read_request_(std::span data, uint16_t max_entities, const LogString *entity_name, uint16_t &start_address, uint16_t &count); - // Parses a single-coil write PDU (FC 0x05), which carries a 2-byte on/off value rather than packed - // bytes. The caller packs value into a byte it owns to build the PackedBits view the handlers take. + // Parses single-coil write data ResponseStatus parse_write_single_coil_(std::span data, uint16_t &start_address, bool &value); - // Parses a multiple-coil write PDU (FC 0x0F) into a packed-bit view pointing straight into the receive - // buffer, so the coil values are never copied. Both coil parsers are shared by the addressed and - // broadcast paths so the two validate identically. + // Parses write-multiple-coil data into a packed-bit view pointing straight into the receive buffer, so the + // coil values are never copied. ResponseStatus parse_write_multiple_coils_(std::span data, uint16_t &start_address, uint16_t &count, std::span &packed_bytes); - // Builds the body of a register read response (byte count followed by the big-endian register values) into - // response_buffer. Shared by every function code that answers with register values, so the read reply stays - // identical across them. Returns false once an exception has been sent: the one the handler reported via - // status, or SERVICE_DEVICE_FAILURE if it returned the wrong number of registers, the count exceeds the - // protocol read limit, or the body does not fit. + // Builds the body of a register read response into response_buffer. Returns false once an exception has + // been sent: the one the handler reported via status, or SERVICE_DEVICE_FAILURE if it returned the wrong + // number of registers, the count exceeds the protocol read limit, or the body does not fit. bool build_or_reject_read_response_(uint8_t address, uint8_t function_code, ResponseStatus status, uint16_t number_of_registers, const RegisterValues ®isters, std::span response_buffer, uint16_t &response_len); void send_raw_(const uint8_t *payload, uint16_t len); // Sends and logs the exception reply when status holds one; returns true if the request was rejected. - // Every parse and handler rejection funnels through here, so the reply and its log cannot drift apart. bool rejected_(uint8_t address, uint8_t function_code, ResponseStatus status); void send_exception_(uint8_t address, uint8_t function_code, ExceptionCode exception_code); void send_response_(uint8_t address, uint8_t function_code, const uint8_t *payload, uint16_t payload_len); uint8_t expecting_peer_response_{0}; std::vector devices_; - // Stamp of the last "broadcast reached no device" warning, 0 until the first one is logged. Rate limiting - // on time rather than on address keeps the log bounded no matter how many addresses a shared bus carries. - uint32_t last_unaccepted_broadcast_warn_{0}; - // Holds the raw payload of a single reply deferred for sending when tx was blocked at send time. // Only one server reply can be waiting at once, so a single fixed buffer avoids heap allocation. std::array deferred_payload_; @@ -555,10 +495,7 @@ class ModbusClientDevice { helpers::create_client_pdu((FunctionCode) function, start_address, number_of_entities, payload, payload_len), this); } - /// See ModbusClientHub::queue_pdu(): true = accepted into the queue and a terminal callback will - /// follow (except a broadcast (address 0), which is never answered and so gets only on_sent()), - /// false = refused at the door and nothing further happens. Neither means the frame is on the wire; - /// on_sent() reports that. + /// See ModbusClientHub::queue_pdu() for the return contract. bool queue_pdu(std::span pdu, CommandOptions options = {}) { return this->parent_->queue_pdu(this->address_, pdu, this, options); } @@ -573,11 +510,8 @@ class ModbusClientDevice { return; // too short to contain a PDU; refused at the door like any invalid send this->parent_->queue_pdu(payload[0], std::span(payload).subspan(1), this); } - // The typed request builders below all queue through queue_pdu(), so they share its contract: true - // means the request is queued and will resolve in exactly one terminal callback (except a broadcast - // (address 0), which is never answered and so gets only on_sent()), false means it was refused outright - // with no callback. Neither says the frame has been transmitted - on_sent() does. - // Reads via the table-appropriate function code; an unreadable entity type maps to INVALID, which + // The typed request builders below all queue through queue_pdu() and share its return contract. + // Reads use the table-appropriate function code; an unreadable entity type maps to INVALID, which // create_read_pdu() rejects into an empty PDU and queue_pdu() refuses with a false return. bool read_entities(EntityType entity_type, uint16_t start_address, uint16_t number_of_entities, CommandOptions options = {}) { @@ -607,6 +541,9 @@ class ModbusClientDevice { return this->queue_pdu(helpers::create_write_single_coil_pdu(address, value)); } bool write_multiple_registers(uint16_t start_address, std::span values) { + // Empty goes to the full-size builder so the rejection log names this method's limit, not the small one's. + if (!values.empty() && values.size() <= helpers::MAX_FEW_REGISTERS) + return this->queue_pdu(helpers::create_write_few_registers_pdu(start_address, values)); return this->queue_pdu(helpers::create_write_registers_pdu(start_address, values)); } /// Note: std::vector cannot bind to std::span; use a contiguous bool container or the packed @@ -619,11 +556,9 @@ class ModbusClientDevice { bool write_multiple_coils(uint16_t start_address, PackedBits bits) { return this->queue_pdu(helpers::create_write_coils_pdu(start_address, bits)); } - /// FC 0x17: the read-back is delivered through on_read_holding_registers() (the response carries only the - /// read registers, the same wire shape as a holding-register read). A device exception - typically a - /// rejected write half - arrives at that same on_read_holding_registers() with the error in its status, - /// exactly as success does, so a subclass overriding that one callback handles both outcomes and never - /// needs to also override on_error(). + /// FC 0x17: the read-back is delivered through on_read_holding_registers(), and a device exception + /// (typically a rejected write half) arrives there too via its status - one callback handles both + /// outcomes with no on_error() override needed. bool read_write_multiple_registers(uint16_t read_start_address, uint16_t read_count, uint16_t write_start_address, std::span write_values) { return this->queue_pdu(helpers::create_read_write_multiple_registers_pdu(read_start_address, read_count, @@ -644,12 +579,9 @@ class ModbusClientDevice { bool custom_response_warned_{false}; // first unhandled custom response warns; repeats log at VERBOSE }; -// Compatibility shim for external components written against the pre-2026.8 API, which subclassed -// ModbusDevice and overrode on_modbus_data()/on_modbus_error(). The name is free (nothing in-tree -// uses it), so instead of a plain alias it adapts the new span-based hooks back to the old -// signatures: on_modbus_data() receives the response payload as an owning vector (the heap copy -// exists only on this deprecated path) and on_modbus_error() the function code and exception code. -// Remove before 2027.2.0 (window restarted when the plain alias became a behavior shim in 2026.8.0) +// Compatibility shim adapting the span-based hooks back to the pre-2026.8 on_modbus_data()/ +// on_modbus_error() signatures (the owning-vector heap copy exists only on this deprecated path). +// Remove before 2027.2.0 (window restarted when the plain alias became a behavior shim in 2026.8.0). class ESPDEPRECATED("Subclass ModbusClientDevice and override on_response()/on_error() instead. Removed in 2027.2.0", "2026.8.0") ModbusDevice : public ModbusClientDevice { public: diff --git a/esphome/components/modbus/modbus_definitions.h b/esphome/components/modbus/modbus_definitions.h index 64f7210585..0939f9e76c 100644 --- a/esphome/components/modbus/modbus_definitions.h +++ b/esphome/components/modbus/modbus_definitions.h @@ -20,7 +20,9 @@ const uint8_t FUNCTION_CODE_USER_DEFINED_SPACE_2_END = 110; // 0x6E enum class FunctionCode : uint8_t { INVALID = 0x00, // 0x00 is not a valid function code (even for custom functions). - CUSTOM = 0x00, // The CUSTOM alias should be removed in future. + // Remove before 2027.3.0 + CUSTOM ESPDEPRECATED("0x00 is not a function code; use FunctionCode::INVALID for the sentinel. Removed in 2027.3.0", + "2026.9.0") = 0x00, READ_COILS = 0x01, READ_DISCRETE_INPUTS = 0x02, READ_HOLDING_REGISTERS = 0x03, @@ -45,7 +47,6 @@ enum class FunctionCode : uint8_t { using ModbusFunctionCode ESPDEPRECATED("Use modbus::FunctionCode instead. Removed in 2027.2.0", "2026.8.0") = FunctionCode; -/*Allow direct comparison operators between FunctionCode and uint8_t*/ inline bool operator==(FunctionCode lhs, uint8_t rhs) { return static_cast(lhs) == rhs; } inline bool operator==(uint8_t lhs, FunctionCode rhs) { return lhs == static_cast(rhs); } inline bool operator!=(FunctionCode lhs, uint8_t rhs) { return !(static_cast(lhs) == rhs); } @@ -115,6 +116,9 @@ static constexpr uint16_t MAX_RAW_SIZE = 254; // Max RAW size is 256 - CRC(2) = static constexpr uint16_t READ_PDU_SIZE = 5; // A single-write PDU is always function code(1) + address(2) + value(2) static constexpr uint16_t WRITE_SINGLE_PDU_SIZE = 5; +// A multiple-write PDU starts with function code(1) + start address(2) + quantity(2) + byte count(1), +// followed by two bytes per register. +static constexpr uint16_t WRITE_MULTIPLE_HEADER_SIZE = 6; static constexpr uint16_t MAX_FRAME_SIZE = 256; // 4.1 Address 0 is the broadcast address: the request is processed by every device and never answered. diff --git a/esphome/components/modbus/modbus_helpers.cpp b/esphome/components/modbus/modbus_helpers.cpp index db21b6e6fd..d80e6c86ad 100644 --- a/esphome/components/modbus/modbus_helpers.cpp +++ b/esphome/components/modbus/modbus_helpers.cpp @@ -30,9 +30,11 @@ uint16_t server_pdu_length(const uint8_t *frame, size_t size) { switch (static_cast(frame[0])) { case FunctionCode::READ_COILS: case FunctionCode::READ_DISCRETE_INPUTS: + // function(1) + byte count(1) + packed coil bytes + return 2 + (size > 1 ? std::min(frame[1], uint8_t(packed_bit_bytes(MAX_NUM_OF_COILS_TO_READ))) : 0); case FunctionCode::READ_HOLDING_REGISTERS: case FunctionCode::READ_INPUT_REGISTERS: - // function(1) + byte count(1) + data + // function(1) + byte count(1) + register data return 2 + (size > 1 ? std::min(frame[1], uint8_t(MAX_NUM_OF_REGISTERS_TO_READ * 2)) : 0); case FunctionCode::WRITE_SINGLE_COIL: case FunctionCode::WRITE_SINGLE_REGISTER: @@ -60,6 +62,9 @@ uint16_t server_pdu_length(const uint8_t *frame, size_t size) { uint16_t client_pdu_length(const uint8_t *frame, size_t size) { if (size < MIN_PDU_SIZE) return MIN_PDU_SIZE; + if (is_function_code_exception(frame[0])) { + return 2; // never a valid request; sized like the exception reply so the CRC fails at once + } switch (static_cast(frame[0])) { case FunctionCode::READ_COILS: case FunctionCode::READ_DISCRETE_INPUTS: @@ -287,25 +292,52 @@ std::optional payload_to_number(const uint8_t *data, size_t size, Senso } std::optional registers_to_number(const uint16_t *registers, size_t count, SensorValueType sensor_value_type) { - const size_t required_size = required_payload_size(sensor_value_type); - if (required_size == 0) { - return 0; // RAW/unsupported: nothing to read + // RAW and BIT carry no fixed-width number, so there is nothing to decode whatever the span holds. + // register_width_for() reports 1 for them, so this must be checked before the width test below. + if (sensor_value_type == SensorValueType::RAW || sensor_value_type == SensorValueType::BIT) { + return 0; } - const size_t required_words = required_size / 2; + const uint16_t required_words = register_width_for(sensor_value_type); if (required_words > count) { - ESP_LOGE(TAG, "not enough registers for value type=%u count=%zu required=%zu", - static_cast(sensor_value_type), count, required_words); + ESP_LOGE(TAG, "not enough registers for value type=%u count=%zu required=%u", + static_cast(sensor_value_type), count, static_cast(required_words)); return std::nullopt; } - // Serialize the needed words back to big-endian bytes and reuse the audited byte decoder so the - // sign-extension behaviour stays identical to the wire path. - uint8_t bytes[8]; // at most 4 registers (QWORD) - for (size_t i = 0; i < required_words; i++) { - uint16_t reg = registers[i]; - bytes[i * 2] = static_cast(reg >> 8); - bytes[i * 2 + 1] = static_cast(reg & 0xFF); + // Registers are the wire's own unit, so decode them directly rather than serializing back to bytes. + // Each case defers to registers_to_value() so the word order and sign rules have one definition, with + // two deliberate exceptions matching what the byte decoder returned: the float types yield their bit + // pattern rather than a float, and U_QWORD shares the signed branch because the return type is int64_t. + switch (sensor_value_type) { + case SensorValueType::U_WORD: + return registers_to_value(registers); + case SensorValueType::U_WORD_S: + return registers_to_value(registers); + case SensorValueType::S_WORD: + return registers_to_value(registers); + case SensorValueType::S_WORD_S: + return registers_to_value(registers); + case SensorValueType::U_DWORD: + return registers_to_value(registers); + case SensorValueType::U_DWORD_R: + return registers_to_value(registers); + case SensorValueType::S_DWORD: + return registers_to_value(registers); + case SensorValueType::S_DWORD_R: + return registers_to_value(registers); + case SensorValueType::FP32: + return registers_to_uint32(registers[0], registers[1]); + case SensorValueType::FP32_R: + return registers_to_uint32(registers[1], registers[0]); + // Signed for both: an unsigned QWORD above INT64_MAX has to come back as a negative int64_t. + case SensorValueType::U_QWORD: + case SensorValueType::S_QWORD: + return registers_to_value(registers); + case SensorValueType::U_QWORD_R: + case SensorValueType::S_QWORD_R: + return registers_to_value(registers); + default: + return 0; } - return payload_to_number(bytes, required_size, sensor_value_type, 0, 0xFFFFFFFF); } // Append a 16-bit value to a PDU in big-endian (wire) byte order. @@ -381,8 +413,6 @@ ReadPdu create_read_pdu(FunctionCode function_code, uint16_t start_address, uint PduBuffer create_client_pdu(FunctionCode function_code, uint16_t start_address, uint16_t number_of_entities, const uint8_t *values, size_t values_len) { PduBuffer pdu; // declared before every return so NRVO fires (all paths return the same object) - // Generic entry point; prefer the direction- and type-specific builders (create_read_pdu(), - // create_write_registers_pdu(), etc.) which bound their inputs per spec. if (is_function_code_read_only(static_cast(function_code))) { if (values != nullptr || values_len > 0) { ESP_LOGW(TAG, "Values provided for read function code %02X, but will be ignored", @@ -445,9 +475,7 @@ PduBuffer create_client_pdu(FunctionCode function_code, uint16_t start_address, return pdu; } // The quantity is spec-bounded above, so the data length just has to agree with it exactly - // (registers are 2 bytes each, coils pack 8 per byte). This is the same consistency the response - // dispatch enforces via is_client_pdu_standard(), so a frame built here can never be classified - // non-standard on reply, and the spec bound keeps the PDU within capacity by construction. + // (registers are 2 bytes each, coils pack 8 per byte). // Checked before the header append: a failed check must return an empty PDU, not a 5-byte partial one. const bool bits = function_code == FunctionCode::WRITE_MULTIPLE_COILS; const size_t expected_len = bits ? packed_bit_bytes(number_of_entities) : static_cast(number_of_entities) * 2; @@ -484,9 +512,12 @@ static bool register_block_in_range(const LogString *role, uint16_t start_addres return true; } -PduBuffer create_write_registers_pdu(uint16_t start_address, std::span values) { - PduBuffer pdu; // declared before every return so NRVO fires (all paths return the same object) - if (!register_block_in_range(LOG_STR("Write"), start_address, values.size(), MAX_NUM_OF_REGISTERS_TO_WRITE)) { +// The ceiling comes from the buffer itself: push_back() drops silently, so a bound wider than the buffer +// would put a truncated frame on the wire. +template static Pdu build_write_registers_pdu(uint16_t start_address, std::span values) { + constexpr auto max_registers = static_cast((Pdu::capacity() - WRITE_MULTIPLE_HEADER_SIZE) / 2); + Pdu pdu; // declared before every return so NRVO fires (all paths return the same object) + if (!register_block_in_range(LOG_STR("Write"), start_address, values.size(), max_registers)) { return pdu; } append_pdu_header(pdu, FunctionCode::WRITE_MULTIPLE_REGISTERS, start_address, values.size()); @@ -497,6 +528,19 @@ PduBuffer create_write_registers_pdu(uint16_t start_address, std::span values) { + return build_write_registers_pdu(start_address, values); +} + +WriteFewRegistersPdu create_write_few_registers_pdu(uint16_t start_address, std::span values) { + return build_write_registers_pdu(start_address, values); +} + PduBuffer create_read_write_multiple_registers_pdu(uint16_t read_start_address, uint16_t read_count, uint16_t write_start_address, std::span write_values) { diff --git a/esphome/components/modbus/modbus_helpers.h b/esphome/components/modbus/modbus_helpers.h index b2454e6f14..9488a88088 100644 --- a/esphome/components/modbus/modbus_helpers.h +++ b/esphome/components/modbus/modbus_helpers.h @@ -60,14 +60,11 @@ inline bool is_function_code_custom(uint8_t function_code) { /// in step with those switches). Deliberately wider than is_function_code_custom(): the user-defined /// ranges are unknown to the parser too, but so are the assigned-but-unimplemented codes /// (READ_EXCEPTION_STATUS, DIAGNOSTICS, GET_COMM_EVENT_*, REPORT_SERVER_ID) and every unassigned value. -/// The 0x80 exception flag is masked off first, so a frame with it set classifies by its base code - -/// even though a spec exception reply has a known 2-byte PDU. That is deliberate, matching what -/// is_function_code_custom() has always done: some vendors use codes with the 0x80 bit set as ordinary -/// codes with longer payloads, so the response parser CRC-scans these rather than assuming the spec -/// length. For an intact spec exception the scan matches at its first candidate, so only a corrupt one -/// pays (recovery by timeout instead of an immediate CRC failure). +/// Exception-flagged codes (0x80 set) are always the 2-byte spec exception shape, so never unknown. inline bool is_function_code_unknown_length(uint8_t function_code) { - switch (static_cast(function_code & FUNCTION_CODE_MASK)) { + if (is_function_code_exception(function_code)) + return false; + switch (static_cast(function_code)) { case FunctionCode::READ_COILS: case FunctionCode::READ_DISCRETE_INPUTS: case FunctionCode::READ_HOLDING_REGISTERS: @@ -87,6 +84,17 @@ inline bool is_function_code_unknown_length(uint8_t function_code) { } } +/// True when the underlying function code (exception bit masked off) may be broadcast (address 0). +/// Refused: the reads (including read-write), plus every other code whose response length the parser +/// knows (file record, FIFO). Allowed: the writes, and any code the parser does not know, since the +/// hub cannot tell one of those apart from a vendor write. +inline bool is_function_code_broadcastable(uint8_t function_code) { + uint8_t masked_function_code = function_code & FUNCTION_CODE_MASK; + if (is_function_code_read(masked_function_code)) + return false; + return is_function_code_write(masked_function_code) || is_function_code_unknown_length(masked_function_code); +} + // Returns the expected length of a server response PDU based on the function code. // If too few bytes have arrived to determine the length, returns the minimum length. `size` is the // number of bytes available so far, which may exceed the eventual PDU (e.g. include the frame's CRC @@ -153,6 +161,50 @@ inline std::span server_pdu_payload(std::span pdu) inline uint8_t client_frame_data_offset(const uint8_t *, size_t) { return 2; } +/** Extract data from modbus response buffer + * @param T one of supported integer data types int_8,int_16,int_32,int_64 + * @param data modbus response buffer (uint8_t) + * @param buffer_offset offset in bytes. + * @return value of type T extracted from buffer + */ +template T get_data(const uint8_t *data, size_t buffer_offset) { + if (sizeof(T) == sizeof(uint8_t)) { + return T(data[buffer_offset]); + } + if (sizeof(T) == sizeof(uint16_t)) { + return T((uint16_t(data[buffer_offset + 0]) << 8) | (uint16_t(data[buffer_offset + 1]) << 0)); + } + if (sizeof(T) == sizeof(uint32_t)) { + return static_cast(get_data(data, buffer_offset)) << 16 | + static_cast(get_data(data, buffer_offset + 2)); + } + if (sizeof(T) == sizeof(uint64_t)) { + return static_cast(get_data(data, buffer_offset)) << 32 | + (static_cast(get_data(data, buffer_offset + 4))); + } + static_assert(sizeof(T) == sizeof(uint8_t) || sizeof(T) == sizeof(uint16_t) || sizeof(T) == sizeof(uint32_t) || + sizeof(T) == sizeof(uint64_t), + "Unsupported type size in get_data; only 1, 2, 4, or 8-byte integer types are supported."); + return T{}; +} + +/// Function code of a PDU, exception flag masked; 0 for an empty PDU. +inline uint8_t pdu_function_code(std::span pdu) { + return pdu.empty() ? 0 : (pdu[0] & FUNCTION_CODE_MASK); +} + +/// Start address of a standard client request PDU ([fc, addr_hi, addr_lo, ...]). Empty when the PDU is +/// too short or its function code has no known layout - custom-frame bytes are not misread as an address. +inline std::optional client_pdu_start_address(std::span pdu) { + if (pdu.size() < 3 || is_function_code_unknown_length(pdu[0])) + return std::nullopt; + const auto fc = static_cast(pdu[0]); + // The file-record PDUs are known-length but carry a byte count, not a start address. + if (fc == FunctionCode::READ_FILE_RECORD || fc == FunctionCode::WRITE_FILE_RECORD) + return std::nullopt; + return get_data(pdu.data(), 1); +} + enum class SensorValueType : uint8_t { RAW = 0x00, // variable length U_WORD = 0x1, // 1 Register unsigned @@ -161,7 +213,7 @@ enum class SensorValueType : uint8_t { S_DWORD = 0x4, // 2 Registers signed BIT = 0x5, U_DWORD_R = 0x6, // 2 Registers unsigned - S_DWORD_R = 0x7, // 2 Registers unsigned + S_DWORD_R = 0x7, // 2 Registers signed U_QWORD = 0x8, S_QWORD = 0x9, U_QWORD_R = 0xA, @@ -176,6 +228,26 @@ inline bool value_type_is_float(SensorValueType v) { return v == SensorValueType::FP32 || v == SensorValueType::FP32_R; } +/// Number of 16-bit registers a value of this type occupies (RAW counts as one register). +constexpr uint16_t register_width_for(SensorValueType v) { + switch (v) { + case SensorValueType::U_DWORD: + case SensorValueType::S_DWORD: + case SensorValueType::U_DWORD_R: + case SensorValueType::S_DWORD_R: + case SensorValueType::FP32: + case SensorValueType::FP32_R: + return 2; + case SensorValueType::U_QWORD: + case SensorValueType::S_QWORD: + case SensorValueType::U_QWORD_R: + case SensorValueType::S_QWORD_R: + return 4; + default: + return 1; + } +} + /// Coils and discrete inputs are the bit-addressed entity tables; the other types are 16-bit registers. inline bool is_entity_type_binary(EntityType type) { return type == EntityType::COIL || type == EntityType::DISCRETE_INPUT; @@ -216,7 +288,7 @@ inline uint8_t c_to_hex(char c) { return (c >= 'A') ? (c >= 'a') ? (c - 'a' + 10 * byte_from_hex_str("1122", 1) returns uint_8 value 0x22 == 34 * byte_from_hex_str("1122", 0) returns 0x11 * @param value string containing hex encoding - * @param position offset in bytes. Because each byte is encoded in 2 hex digits the position of the original byte in + * @param pos offset in bytes. Because each byte is encoded in 2 hex digits the position of the original byte in * the hex string is byte_pos * 2 * @return byte value */ @@ -228,8 +300,7 @@ inline uint8_t byte_from_hex_str(const std::string &value, uint8_t pos) { /** Get a word from a hex string * @param value string containing hex encoding - * @param position offset in bytes. Because each byte is encoded in 2 hex digits the position of the original byte in - * the hex string is byte_pos * 2 + * @param pos offset in bytes (see byte_from_hex_str) * @return word value */ inline uint16_t word_from_hex_str(const std::string &value, uint8_t pos) { @@ -238,8 +309,7 @@ inline uint16_t word_from_hex_str(const std::string &value, uint8_t pos) { /** Get a dword from a hex string * @param value string containing hex encoding - * @param position offset in bytes. Because each byte is encoded in 2 hex digits the position of the original byte in - * the hex string is byte_pos * 2 + * @param pos offset in bytes (see byte_from_hex_str) * @return dword value */ inline uint32_t dword_from_hex_str(const std::string &value, uint8_t pos) { @@ -248,42 +318,13 @@ inline uint32_t dword_from_hex_str(const std::string &value, uint8_t pos) { /** Get a qword from a hex string * @param value string containing hex encoding - * @param position offset in bytes. Because each byte is encoded in 2 hex digits the position of the original byte in - * the hex string is byte_pos * 2 + * @param pos offset in bytes (see byte_from_hex_str) * @return qword value */ inline uint64_t qword_from_hex_str(const std::string &value, uint8_t pos) { return static_cast(dword_from_hex_str(value, pos)) << 32 | dword_from_hex_str(value, pos + 4); } -// Extract data from modbus response buffer -/** Extract data from modbus response buffer - * @param T one of supported integer data types int_8,int_16,int_32,int_64 - * @param data modbus response buffer (uint8_t) - * @param buffer_offset offset in bytes. - * @return value of type T extracted from buffer - */ -template T get_data(const uint8_t *data, size_t buffer_offset) { - if (sizeof(T) == sizeof(uint8_t)) { - return T(data[buffer_offset]); - } - if (sizeof(T) == sizeof(uint16_t)) { - return T((uint16_t(data[buffer_offset + 0]) << 8) | (uint16_t(data[buffer_offset + 1]) << 0)); - } - if (sizeof(T) == sizeof(uint32_t)) { - return static_cast(get_data(data, buffer_offset)) << 16 | - static_cast(get_data(data, buffer_offset + 2)); - } - if (sizeof(T) == sizeof(uint64_t)) { - return static_cast(get_data(data, buffer_offset)) << 32 | - (static_cast(get_data(data, buffer_offset + 4))); - } - static_assert(sizeof(T) == sizeof(uint8_t) || sizeof(T) == sizeof(uint16_t) || sizeof(T) == sizeof(uint32_t) || - sizeof(T) == sizeof(uint64_t), - "Unsupported type size in get_data; only 1, 2, 4, or 8-byte integer types are supported."); - return T{}; -} - template T get_data(const std::vector &data, size_t buffer_offset) { return get_data(data.data(), buffer_offset); } @@ -292,9 +333,9 @@ template T get_data(const std::vector &data, size_t buffer_ * Responses for coil are packed into bytes . * coil 3 is bit 3 of the first response byte * coil 9 is bit 2 of the second response byte - * @param coil number of the cil + * @param bit index of the bit to extract * @param data modbus response buffer (uint8_t) - * @return content of coil register + * @return value of the requested bit */ inline bool bit_from_packed(int bit, std::span data) { auto data_byte = bit / 8; @@ -432,11 +473,96 @@ inline int64_t payload_to_number(const std::vector &data, SensorValueTy */ std::optional registers_to_number(const uint16_t *registers, size_t count, SensorValueType sensor_value_type); +/// Combine two register words into a 32-bit value. +constexpr uint32_t registers_to_uint32(uint16_t high_word, uint16_t low_word) { + return (static_cast(high_word) << 16) | low_word; +} + +/// Combine four register words into a 64-bit value, most significant word first. +constexpr uint64_t registers_to_uint64(uint16_t word0, uint16_t word1, uint16_t word2, uint16_t word3) { + return (static_cast(registers_to_uint32(word0, word1)) << 32) | registers_to_uint32(word2, word3); +} + +// Always false, whatever the type: it exists only to make the static_assert below depend on the +// template argument. Not a queryable trait. +template inline constexpr bool VALUE_TYPE_SUPPORTED = false; + +/** Decode one value whose type is known at compile time, from registers in host byte order. + * Unlike registers_to_number(), the type is a template argument, so only the one decode is compiled + * and the caller gets the value's natural type back rather than an int64_t. The "_R" types take the + * low word first; the rest take the high word first. + * Supports every fixed-width type: the WORD, DWORD, QWORD and FP32 families, including their _S and + * _R forms. RAW and BIT have no fixed width and fail to compile. + * Use register_width_for() for the number of registers the caller must supply. + * Note that the FP32 branches are only usable in a constant expression where std::bit_cast is + * available; elsewhere bit_cast falls back to a non-constexpr memcpy (see core/helpers.h). + */ +template constexpr auto registers_to_value(const uint16_t *registers) { + if constexpr (VALUE_TYPE == SensorValueType::U_WORD) { + return registers[0]; + } else if constexpr (VALUE_TYPE == SensorValueType::S_WORD) { + return static_cast(registers[0]); + } else if constexpr (VALUE_TYPE == SensorValueType::U_WORD_S) { + return byteswap(registers[0]); + } else if constexpr (VALUE_TYPE == SensorValueType::S_WORD_S) { + return static_cast(byteswap(registers[0])); + } else if constexpr (VALUE_TYPE == SensorValueType::U_DWORD) { + return registers_to_uint32(registers[0], registers[1]); + } else if constexpr (VALUE_TYPE == SensorValueType::U_DWORD_R) { + return registers_to_uint32(registers[1], registers[0]); + } else if constexpr (VALUE_TYPE == SensorValueType::S_DWORD) { + return static_cast(registers_to_uint32(registers[0], registers[1])); + } else if constexpr (VALUE_TYPE == SensorValueType::S_DWORD_R) { + return static_cast(registers_to_uint32(registers[1], registers[0])); + } else if constexpr (VALUE_TYPE == SensorValueType::FP32) { + return bit_cast(registers_to_uint32(registers[0], registers[1])); + } else if constexpr (VALUE_TYPE == SensorValueType::FP32_R) { + return bit_cast(registers_to_uint32(registers[1], registers[0])); + } else if constexpr (VALUE_TYPE == SensorValueType::U_QWORD) { + return registers_to_uint64(registers[0], registers[1], registers[2], registers[3]); + } else if constexpr (VALUE_TYPE == SensorValueType::U_QWORD_R) { + return registers_to_uint64(registers[3], registers[2], registers[1], registers[0]); + } else if constexpr (VALUE_TYPE == SensorValueType::S_QWORD) { + return static_cast(registers_to_uint64(registers[0], registers[1], registers[2], registers[3])); + } else if constexpr (VALUE_TYPE == SensorValueType::S_QWORD_R) { + return static_cast(registers_to_uint64(registers[3], registers[2], registers[1], registers[0])); + } else { + static_assert(VALUE_TYPE_SUPPORTED, "registers_to_value() does not support this value type"); + } +} + +/// The type registers_to_value() yields for a given value type. Distinct from modbus::RegisterValues, +/// which is a container of raw words. +template +using RegisterValueType = decltype(registers_to_value(static_cast(nullptr))); + +/** The value stored at an absolute register address, or nullopt when it is not wholly inside this + * response. Lets a device decode by address rather than by offset, so a poll split across several + * requests needs no extra bookkeeping: a value outside the response simply yields nullopt. + * @param registers the response registers, in host byte order + * @param start_address the address the response begins at + * @param address the address of the wanted value + */ +template +constexpr std::optional> value_at(std::span registers, + uint16_t start_address, uint16_t address) { + if (address < start_address) + return std::nullopt; + const size_t offset = static_cast(address) - start_address; + if (offset + register_width_for(VALUE_TYPE) > registers.size()) + return std::nullopt; + return registers_to_value(registers.data() + offset); +} + +/// The widest standard numeric value (a QWORD) spans 4 registers, so one entity value never writes more. +static constexpr uint16_t MAX_FEW_REGISTERS = 4; + // Named PDU buffer types: the builders' storage strategy (currently stack-allocated StaticVector, // right-sized per shape) can be swapped in one place without touching every signature. using PduBuffer = StaticVector; using ReadPdu = StaticVector; using WriteSinglePdu = StaticVector; +using WriteFewRegistersPdu = StaticVector; /// Scratch space for packing coils into wire layout: one bit per coil, sized for the spec maximum. using CoilPackBuffer = StaticVector; @@ -480,6 +606,15 @@ PduBuffer create_client_pdu(FunctionCode function_code, uint16_t start_address, */ PduBuffer create_write_registers_pdu(uint16_t start_address, std::span values); +/** Create modbus write multiple registers command (function 0x10) on a right-sized stack buffer. + * Identical wire bytes to create_write_registers_pdu() for any accepted input. + * @param start_address modbus address of the first register to write + * @param values register values to write, at most MAX_FEW_REGISTERS (an over-long or empty set is + * rejected and an empty PDU is returned) + * @return PDU (function code + data, no address, no CRC) + */ +WriteFewRegistersPdu create_write_few_registers_pdu(uint16_t start_address, std::span values); + /** Create modbus read/write multiple registers command * Function 0x17 Read/Write Multiple Registers * Writes write_values then reads read_count registers in one transaction (write first, per Modbus 6.17); diff --git a/esphome/components/modbus_controller/__init__.py b/esphome/components/modbus_controller/__init__.py index e87eccb32c..f888cc060e 100644 --- a/esphome/components/modbus_controller/__init__.py +++ b/esphome/components/modbus_controller/__init__.py @@ -41,6 +41,7 @@ from .const import ( CONF_REGISTER_COUNT, CONF_REGISTER_TYPE, CONF_RESPONSE_SIZE, + CONF_REUSE_PREVIOUS_RANGE, CONF_SERVER_COURTESY_RESPONSE, CONF_SERVER_REGISTERS, CONF_SKIP_UPDATES, @@ -60,6 +61,13 @@ ModbusController = modbus_controller_ns.class_("ModbusController", cg.PollingCom SensorItem = modbus_controller_ns.struct("SensorItem") +RangeReuse = modbus_controller_ns.enum("RangeReuse", is_class=True) +RANGE_REUSE = { + "auto": RangeReuse.AUTO, + True: RangeReuse.ALWAYS, + False: RangeReuse.NEVER, +} + _LOGGER = logging.getLogger(__name__) @@ -184,13 +192,88 @@ ModbusItemBaseSchema = cv.Schema( ): cv.positive_int, cv.Optional(CONF_BITMASK, default=0xFFFFFFFF): cv.hex_uint32_t, cv.Optional(CONF_SKIP_UPDATES): validate_skip_updates_deprecated, - cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean, + cv.Optional(CONF_REUSE_PREVIOUS_RANGE, default="auto"): cv.Any( + cv.boolean, cv.one_of("auto", lower=True) + ), + # Deprecated options, migrated by validate_range_reuse_migration(). Remove before 2027.3.0 + cv.Optional(CONF_FORCE_NEW_RANGE): cv.boolean, + cv.Optional(CONF_REGISTER_COUNT): cv.positive_int, cv.Optional(CONF_LAMBDA): cv.returning_lambda, - cv.Optional(CONF_RESPONSE_SIZE, default=0): cv.positive_int, + cv.Optional(CONF_RESPONSE_SIZE, default=0): cv.int_range(min=0, max=250), }, ) +def _derived_register_widths(config: ConfigType) -> set[int]: + """Register widths an item derives on its own; a matching register_count is redundant.""" + response_size = config.get(CONF_RESPONSE_SIZE, 0) + if (value_type := config.get(CONF_VALUE_TYPE)) is not None: + widths = {TYPE_REGISTER_MAP[value_type]} + if value_type == "RAW" and response_size > 0: + widths.add((response_size + 1) // 2) + return widths + if response_size > 0: + # text sensors: the old default was floor(response_size / 2); the derived width is now ceil + return {response_size // 2, (response_size + 1) // 2} + return {1} + + +def entity_label(config: ConfigType) -> str: + """The entity's name or id, so migration messages say which entry to edit.""" + label = config.get(CONF_NAME) or config.get(CONF_ID) + return str(label) if label is not None else "" + + +# Remove before 2027.3.0 +def validate_range_reuse_migration(config: ConfigType) -> ConfigType: + """Migrate the removed force_new_range/register_count options to reuse_previous_range.""" + if (force_new_range := config.pop(CONF_FORCE_NEW_RANGE, None)) is not None: + if config[CONF_REUSE_PREVIOUS_RANGE] != "auto": + raise cv.Invalid( + f"'{CONF_FORCE_NEW_RANGE}' and '{CONF_REUSE_PREVIOUS_RANGE}' can't be used together; " + f"remove '{CONF_FORCE_NEW_RANGE}'" + ) + if force_new_range: + _LOGGER.warning( + "%s: '%s' is deprecated; '%s: false' replaces it but only stops this entity joining " + "the PREVIOUS range - set it on the following entity too if the range must stay " + "isolated. Removed in 2027.3.0", + entity_label(config), + CONF_FORCE_NEW_RANGE, + CONF_REUSE_PREVIOUS_RANGE, + ) + config[CONF_REUSE_PREVIOUS_RANGE] = False + else: + _LOGGER.warning( + "%s: '%s: false' has no effect; remove it. Removed in 2027.3.0", + entity_label(config), + CONF_FORCE_NEW_RANGE, + ) + if (register_count := config.pop(CONF_REGISTER_COUNT, None)) is not None: + if ( + register_count not in _derived_register_widths(config) + and register_count != 0 + ): + raise cv.Invalid( + f"'{CONF_REGISTER_COUNT}' has been removed; the number of registers to read is now " + f"derived from '{CONF_VALUE_TYPE}' (or '{CONF_RESPONSE_SIZE}' for RAW values and text " + f"sensors). To make one request span extra registers up to the next sensor, set " + f"'{CONF_REUSE_PREVIOUS_RANGE}: true' on the NEXT sensor instead; for RAW or text block " + f"reads set '{CONF_RESPONSE_SIZE}' to the byte count; to force multi-register writes set " + f"'use_write_multiple: true'. See " + "https://esphome.io/components/modbus_controller/" + ) + _LOGGER.warning( + "%s: '%s' is now derived from '%s' (or '%s' for RAW values and text sensors) and has no " + "effect; remove it. Removed in 2027.3.0", + entity_label(config), + CONF_REGISTER_COUNT, + CONF_VALUE_TYPE, + CONF_RESPONSE_SIZE, + ) + return config + + def validate_modbus_register(config: ConfigType) -> ConfigType: # custom_command is the deprecated alias for custom_pdu (migrated later in final validate); treat # either as "a custom frame is configured" so the address/register_type rules match. @@ -278,20 +361,28 @@ def _final_validate(config: ConfigType) -> None: FINAL_VALIDATE_SCHEMA = _final_validate -def modbus_calc_properties(config: ConfigType) -> tuple[int, int]: +def reject_odd_holding_write_offset(config: ConfigType) -> ConfigType: + """Reject an odd byte offset on a holding-register write entity. + + A 16-bit register write cannot target half a register, so the residual byte is inexpressible. + """ + key = CONF_BYTE_OFFSET if CONF_BYTE_OFFSET in config else CONF_OFFSET + if config.get(key, 0) % 2: + raise cv.Invalid( + f"An odd '{key}' cannot be used with holding-register writes: a 16-bit register " + "write cannot target half a register. Use an even offset, or fold it into 'address'", + path=[key], + ) + return config + + +def modbus_calc_properties(config: ConfigType) -> int: byte_offset = 0 - reg_count = 0 if CONF_OFFSET in config: byte_offset = config[CONF_OFFSET] # A CONF_BYTE_OFFSET setting overrides CONF_OFFSET if CONF_BYTE_OFFSET in config: byte_offset = config[CONF_BYTE_OFFSET] - if CONF_REGISTER_COUNT in config: - reg_count = config[CONF_REGISTER_COUNT] - if CONF_VALUE_TYPE in config: - value_type = config[CONF_VALUE_TYPE] - if reg_count == 0: - reg_count = TYPE_REGISTER_MAP[value_type] if CONF_CUSTOM_PDU in config: if CONF_ADDRESS not in config: # generate a unique modbus address using the hash of the name @@ -302,8 +393,7 @@ def modbus_calc_properties(config: ConfigType) -> tuple[int, int]: value = value.encode() config[CONF_ADDRESS] = binascii.crc_hqx(value, 0) config[CONF_REGISTER_TYPE] = cv.enum(MODBUS_REGISTER_TYPE)("custom") - config[CONF_FORCE_NEW_RANGE] = True - return byte_offset, reg_count + return byte_offset async def add_modbus_base_properties( diff --git a/esphome/components/modbus_controller/binary_sensor/__init__.py b/esphome/components/modbus_controller/binary_sensor/__init__.py index 366dab6062..32247b4cec 100644 --- a/esphome/components/modbus_controller/binary_sensor/__init__.py +++ b/esphome/components/modbus_controller/binary_sensor/__init__.py @@ -5,6 +5,7 @@ import esphome.config_validation as cv from esphome.const import CONF_ADDRESS, CONF_ID from .. import ( + RANGE_REUSE, ModbusItemBaseSchema, SensorItem, add_modbus_base_properties, @@ -12,12 +13,13 @@ from .. import ( modbus_controller_ns, validate_custom_pdu_item, validate_modbus_register, + validate_range_reuse_migration, ) from ..const import ( CONF_BITMASK, - CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, CONF_REGISTER_TYPE, + CONF_REUSE_PREVIOUS_RANGE, ) DEPENDENCIES = ["modbus_controller"] @@ -38,20 +40,21 @@ CONFIG_SCHEMA = cv.All( } ), validate_modbus_register, + validate_range_reuse_migration, ) FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item async def to_code(config): - byte_offset, _ = modbus_calc_properties(config) + byte_offset = modbus_calc_properties(config) var = cg.new_Pvariable( config[CONF_ID], config[CONF_REGISTER_TYPE], config[CONF_ADDRESS], byte_offset, config[CONF_BITMASK], - config[CONF_FORCE_NEW_RANGE], + RANGE_REUSE[config[CONF_REUSE_PREVIOUS_RANGE]], ) await cg.register_component(var, config) await binary_sensor.register_binary_sensor(var, config) diff --git a/esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h b/esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h index f5ddbd82cc..a6b5bc4ef9 100644 --- a/esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h +++ b/esphome/components/modbus_controller/binary_sensor/modbus_binarysensor.h @@ -11,19 +11,22 @@ namespace esphome::modbus_controller { class ModbusBinarySensor final : public Component, public binary_sensor::BinarySensor, public SensorItem { public: ModbusBinarySensor(modbus::EntityType register_type, uint16_t start_address, uint8_t offset, uint32_t bitmask, - bool force_new_range) { + RangeReuse reuse_previous_range) { this->register_type = register_type; this->set_address(start_address); this->set_offset_from_start_address(offset); this->bitmask = bitmask; this->sensor_value_type = SensorValueType::BIT; - this->force_new_range = force_new_range; + this->reuse_previous_range = reuse_previous_range; + } - if (modbus::helpers::is_entity_type_binary(register_type)) { - this->register_count = offset + 1; - } else { - this->register_count = 1; + /// On the bit-addressed tables the bit sits at start_address + offset, so the read must span offset + 1 + /// bits. Uses the offset as configured: `offset` itself is overwritten with the position in the range. + uint16_t entity_count() const override { + if (modbus::helpers::is_entity_type_binary(this->register_type)) { + return this->offset_from_start_address + 1; } + return 1; } void parse_and_publish(std::span data) override; diff --git a/esphome/components/modbus_controller/const.py b/esphome/components/modbus_controller/const.py index 8412a651b8..364a0a510e 100644 --- a/esphome/components/modbus_controller/const.py +++ b/esphome/components/modbus_controller/const.py @@ -18,6 +18,7 @@ CONF_REGISTER_LAST_ADDRESS = "register_last_address" CONF_REGISTER_TYPE = "register_type" CONF_REGISTER_VALUE = "register_value" CONF_RESPONSE_SIZE = "response_size" +CONF_REUSE_PREVIOUS_RANGE = "reuse_previous_range" CONF_SERVER_COURTESY_RESPONSE = "server_courtesy_response" CONF_SERVER_REGISTERS = "server_registers" CONF_SKIP_UPDATES = "skip_updates" diff --git a/esphome/components/modbus_controller/modbus_controller.cpp b/esphome/components/modbus_controller/modbus_controller.cpp index 9d7b719e15..c7fc10a0bb 100644 --- a/esphome/components/modbus_controller/modbus_controller.cpp +++ b/esphome/components/modbus_controller/modbus_controller.cpp @@ -3,6 +3,7 @@ #include "esphome/core/log.h" #include +#include namespace esphome::modbus_controller { @@ -23,60 +24,106 @@ void WriterDevice::warn_write_buffer_deprecated(const LogString *platform, uint1 bool WriterDevice::send_raw_frame_deprecated(std::span frame) { if (frame.empty()) return false; - this->dispatched_ = true; return this->parent_->queue_pdu(frame[0], frame.subspan(1), this); } -void WriterDevice::set_controller(ModbusController *controller) { +void ControllerDevice::set_controller(ModbusController *controller) { this->controller_ = controller; this->set_parent(controller->hub()); this->set_address(controller->device_address()); } -void WriterDevice::notify_online_(std::span request_pdu) { - if (this->controller_ != nullptr) - this->controller_->set_online(true, fc_of(request_pdu), addr_of(request_pdu)); +// A request whose layout carries no start address (a custom PDU) reports -1; 0 stays a real address. +static int trigger_address(std::span request_pdu) { + const auto addr = modbus::helpers::client_pdu_start_address(request_pdu); + return addr.has_value() ? *addr : -1; +} + +void ControllerDevice::notify_online_(std::span request_pdu) { + if (this->controller_ != nullptr) { + this->controller_->set_online(true, modbus::helpers::pdu_function_code(request_pdu), trigger_address(request_pdu)); + } +} + +void ControllerDevice::on_response(std::span request_pdu, std::span response_pdu) { + this->notify_online_(request_pdu); +} + +void ControllerDevice::on_error(std::span request_pdu, modbus::ExceptionCode exception_code) { + ESP_LOGW(TAG, "Modbus error function code: 0x%X register %d exception: %d", + modbus::helpers::pdu_function_code(request_pdu), trigger_address(request_pdu), + static_cast(exception_code)); + this->notify_online_(request_pdu); // an exception is still a legitimate reply -> device is online } void WriterDevice::on_response(std::span request_pdu, std::span response_pdu) { - this->notify_online_(request_pdu); + ControllerDevice::on_response(request_pdu, response_pdu); this->dispatch_response_(request_pdu, response_pdu, std::nullopt); } void WriterDevice::on_error(std::span request_pdu, modbus::ExceptionCode exception_code) { - ESP_LOGW(TAG, "Modbus error function code: 0x%X register 0x%X exception: %d", fc_of(request_pdu), - addr_of(request_pdu), static_cast(exception_code)); - this->notify_online_(request_pdu); // an exception is still a legitimate reply -> device is online + ControllerDevice::on_error(request_pdu, exception_code); this->dispatch_response_(request_pdu, {}, exception_code); } // Fired once per wire transmission (including hub re-queues from a retry), so the on_command_sent trigger // reflects when the frame actually went out, not when it was queued. -void WriterDevice::on_sent(std::span request_pdu) { - if (this->controller_ != nullptr) - this->controller_->command_sent(fc_of(request_pdu), addr_of(request_pdu)); -} - -void WriterDevice::on_not_sent(std::span request_pdu) { - // Only the offline teardown reaches this (a supersede retires silently), so the frame is genuinely - // lost; a dropped write was already published optimistically, so surface it. - if (modbus::helpers::is_function_code_write(fc_of(request_pdu))) { - ESP_LOGW(TAG, "Write not sent: function 0x%X register 0x%X", fc_of(request_pdu), addr_of(request_pdu)); - } else { - ESP_LOGD(TAG, "Request not sent: function 0x%X register 0x%X", fc_of(request_pdu), addr_of(request_pdu)); +void ControllerDevice::on_sent(std::span request_pdu) { + if (this->controller_ != nullptr) { + this->controller_->command_sent(modbus::helpers::pdu_function_code(request_pdu), trigger_address(request_pdu)); } } -bool WriterDevice::on_no_response(std::span request_pdu) { +void ControllerDevice::on_not_sent(std::span request_pdu) { + const uint8_t fc = modbus::helpers::pdu_function_code(request_pdu); + const int addr = trigger_address(request_pdu); + // Only the offline teardown reaches this (a supersede retires silently), so the frame is genuinely + // lost; a dropped write was already published optimistically, so surface it. + if (modbus::helpers::is_function_code_write(fc)) { + ESP_LOGW(TAG, "Write not sent: function 0x%X register %d", fc, addr); + } else { + ESP_LOGD(TAG, "Request not sent: function 0x%X register %d", fc, addr); + } +} + +bool ControllerDevice::on_no_response(std::span request_pdu) { if (this->controller_ == nullptr) return false; this->controller_->increment_non_response_count(); if (this->controller_->can_send()) return true; // the hub re-queues the frame it is holding; on_sent fires again on the retry - this->controller_->set_online(false, fc_of(request_pdu), addr_of(request_pdu)); + this->controller_->set_online(false, modbus::helpers::pdu_function_code(request_pdu), trigger_address(request_pdu)); return false; } +PollingDevice::PollingDevice(ModbusController &controller, RegisterRange &&range) + : ControllerDevice(&controller), range_(std::move(range)) {} + +bool PollingDevice::queue(modbus::CommandOptions options) { + bool accepted; + if (this->range_.custom_pdu != nullptr) { + accepted = this->queue_pdu(std::span(*this->range_.custom_pdu), options); + } else { + accepted = this->read_entities(this->range_.register_type, this->range_.start_address, this->range_.register_count, + options); + } + if (accepted) { + ESP_LOGV(TAG, "Poll queued type=%u 0x%X %d", static_cast(this->range_.register_type), + this->range_.start_address, this->range_.register_count); + } + return accepted; +} + +void PollingDevice::on_response(std::span request_pdu, std::span response_pdu) { + this->notify_online_(request_pdu); + auto data = modbus::helpers::server_pdu_payload(response_pdu); + for (auto *sensor : this->range_.sensors) + sensor->parse_and_publish(data); +} + +// ModbusCommandItem's machinery stays as-is until its removal in 2027.3.0; silence its self-references. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" ModbusCommandItem::ModbusCommandItem(ModbusController &controller, modbus::ModbusClientHub *parent, uint8_t address, RegisterRange &&range) : modbus::ModbusClientDevice(parent, address), @@ -91,7 +138,7 @@ ModbusCommandItem::ModbusCommandItem(ModbusController &controller, modbus::Modbu SensorItem *sensor) : modbus::ModbusClientDevice(parent, address), start_address_(sensor->start_address), - register_count_(sensor->register_count), + register_count_(sensor->entity_count()), custom_pdu_(&sensor->custom_pdu), controller_(&controller) { // The PDU's first byte is its real function code; carry it so dump_config, the on_command_sent @@ -207,6 +254,8 @@ bool ModbusCommandItem::on_no_response(std::span request_pdu) { return false; } +#pragma GCC diagnostic pop + void ModbusController::set_online(bool online, int function_code, int register_address) { if (online) { this->cmd_non_responses_ = 0; @@ -228,6 +277,8 @@ void ModbusController::set_online(bool online, int function_code, int register_a } } +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" void ModbusController::queue_command(ModbusCommandItem command) { this->sweep_completed_one_shots_(); // reclaim finished one-shots before adding a new one // Duplicates are the caller's to manage; the controller only holds the item until its terminal callback. @@ -262,6 +313,8 @@ void ModbusController::sweep_completed_one_shots_() { [](const std::unique_ptr &item) { return item->pending_removal; }); } +#pragma GCC diagnostic pop + void ModbusController::update() { this->sweep_completed_one_shots_(); // reclaim one-shots deferred out of their own callbacks if (this->module_offline_) { @@ -270,11 +323,11 @@ void ModbusController::update() { if (offline_retry_due(this->update_counter_, this->module_offline_at_, this->offline_skip_updates_)) { ESP_LOGV(TAG, "Module offline - retrying"); this->cmd_non_responses_ = 0; // allow the probe through can_send() - for (auto &cmd : this->polling_command_items_) { + for (auto &poll : this->polling_devices_) { // Probes carry the read-side options too, so a recovering device resumes streaming on the // probe itself rather than waiting for the next update_interval. - if (!cmd.send(this->read_options_)) { - ESP_LOGD(TAG, "Probe refused by hub for range 0x%X", cmd.register_address()); + if (!poll.queue(this->read_options_)) { + ESP_LOGD(TAG, "Probe refused by hub for range 0x%X", poll.register_address()); } } } else { @@ -285,12 +338,12 @@ void ModbusController::update() { } if (this->can_send()) { - for (auto &cmd : this->polling_command_items_) { - ESP_LOGVV(TAG, "Updating range 0x%X", cmd.register_address()); + for (auto &poll : this->polling_devices_) { + ESP_LOGVV(TAG, "Updating range 0x%X", poll.register_address()); // read_options_ carries the controller's continuous flag (the offline probe above sends it too). // A refusal is already logged by the hub; note the affected range for controller-level diagnostics. - if (!cmd.send(this->read_options_)) { - ESP_LOGD(TAG, "Poll refused by hub for range 0x%X", cmd.register_address()); + if (!poll.queue(this->read_options_)) { + ESP_LOGD(TAG, "Poll refused by hub for range 0x%X", poll.register_address()); } } } @@ -298,125 +351,180 @@ void ModbusController::update() { } // walk through the sensors and determine the register ranges to read +namespace { + +class RangeBuilder { + public: + explicit RangeBuilder(FixedVector &ranges) : ranges_(ranges) {} + + bool can_join(const SensorItem *curr) const { + return this->have_range_ && curr->reuse_previous_range != RangeReuse::NEVER && + this->r_.register_type == curr->register_type && curr->register_type != modbus::EntityType::CUSTOM; + } + + // A sensor that joined mid-range must never anchor this - hence both address tests. + bool try_reuse_register(SensorItem *curr) { + const uint32_t range_end = this->range_end_(); + if (curr->start_address != range_end - this->prev_->entity_count() || + this->prev_->start_address + this->prev_->entity_count() != range_end || + curr->entity_count() != this->prev_->entity_count() || + curr->get_register_size() != this->prev_->get_register_size()) { + return false; + } + if (!place_offset(curr, static_cast(this->prev_->offset) + curr->offset_from_start_address)) + return false; + ESP_LOGV(TAG, "Re-use previous register 0x%X", curr->start_address); + return true; + } + + bool try_extend(SensorItem *curr) { + const uint32_t range_end = this->range_end_(); + const bool reachable = + curr->reuse_previous_range == RangeReuse::ALWAYS + ? curr->start_address >= range_end + : curr->start_address == range_end && (curr->addresses_bits() || !this->range_custom_size_); + if (!reachable) + return false; + const uint16_t gap = static_cast(curr->start_address - range_end); + const uint32_t new_count = this->r_.register_count + gap + curr->entity_count(); + const uint16_t max_quantity = + curr->addresses_bits() ? modbus::MAX_NUM_OF_COILS_TO_READ : modbus::MAX_NUM_OF_REGISTERS_TO_READ; + const uint32_t prospective_offset = + (curr->addresses_bits() ? static_cast(curr->start_address - this->r_.start_address) + : static_cast(this->range_bytes_) + gap * 2) + + curr->offset_from_start_address; + if (new_count > max_quantity || !place_offset(curr, prospective_offset)) { + return false; + } + if (!curr->addresses_bits()) + this->range_bytes_ += static_cast(gap) * 2; + this->range_bytes_ += curr->get_register_size(); + this->range_custom_size_ = this->range_custom_size_ || has_custom_size(curr); + this->r_.register_count = static_cast(new_count); + ESP_LOGV(TAG, "Extend range to include 0x%X", curr->start_address); + return true; + } + + bool try_cover(SensorItem *curr) { + if (!this->range_shared_ || this->range_forced_ || curr->start_address < this->r_.start_address || + curr->start_address + curr->entity_count() > this->range_end_() || this->range_custom_size_ || + has_custom_size(curr)) { + return false; + } + const uint32_t addr_delta = curr->start_address - this->r_.start_address; + if (!place_offset(curr, (curr->addresses_bits() ? addr_delta : addr_delta * 2) + curr->offset_from_start_address)) + return false; + ESP_LOGV(TAG, "Register 0x%X already covered by range 0x%X", curr->start_address, this->r_.start_address); + return true; + } + + // A response dispatches to a single range per (start address, register type), so same-address items + // must share - even reuse_previous_range: false and custom entities. + bool try_share(SensorItem *curr) { + if (!this->have_range_ || this->r_.register_type != curr->register_type || + this->r_.start_address != curr->start_address) { + return false; + } + curr->offset = curr->offset_from_start_address; + this->r_.register_count = std::max(this->r_.register_count, curr->entity_count()); + this->range_bytes_ = std::max(this->range_bytes_, curr->get_register_size()); + this->range_custom_size_ = this->range_custom_size_ || has_custom_size(curr); + this->range_shared_ = true; + this->range_forced_ = this->range_forced_ || curr->reuse_previous_range == RangeReuse::NEVER; + ESP_LOGV(TAG, "Share range start 0x%X", curr->start_address); + return true; + } + + bool always_declined(const SensorItem *curr) const { + return this->have_range_ && curr->reuse_previous_range == RangeReuse::ALWAYS && + this->r_.register_type == curr->register_type && curr->start_address != this->r_.start_address; + } + + void open(SensorItem *curr) { + this->close(); + this->r_ = {}; + this->range_bytes_ = curr->get_register_size(); + this->range_custom_size_ = has_custom_size(curr); + this->range_forced_ = curr->reuse_previous_range == RangeReuse::NEVER; + this->range_shared_ = false; + curr->offset = curr->offset_from_start_address; + this->r_.start_address = curr->start_address; + this->r_.register_count = curr->entity_count(); + this->r_.register_type = curr->register_type; + if (curr->register_type == modbus::EntityType::CUSTOM) + this->r_.custom_pdu = &curr->custom_pdu; + this->have_range_ = true; + } + + void record(SensorItem *curr) { + curr->range_start_address = this->r_.start_address; + this->r_.sensors.insert(curr); + this->prev_ = curr; + } + + void close() { + if (!this->have_range_) + return; + ESP_LOGV(TAG, "Add range 0x%X %d", this->r_.start_address, this->r_.register_count); + this->ranges_.push_back(std::move(this->r_)); + this->have_range_ = false; + } + + private: + uint32_t range_end_() const { return this->r_.start_address + this->r_.register_count; } + // The resolved offset must fit its uint8_t field or the sensor would parse the wrong slice. + static bool place_offset(SensorItem *curr, uint32_t offset) { + if (offset > std::numeric_limits::max()) + return false; + curr->offset = static_cast(offset); + return true; + } + static bool has_custom_size(const SensorItem *item) { + return item->get_register_size() != static_cast(item->entity_count()) * 2; + } + FixedVector &ranges_; + RegisterRange r_ = {}; + bool have_range_ = false; + bool range_forced_ = false; // a reuse: false member blocks the coverage join + bool range_shared_ = false; // only a share-widened range absorbs by coverage + size_t range_bytes_ = 0; + bool range_custom_size_ = false; + SensorItem *prev_ = nullptr; +}; + +} // namespace + void ModbusController::create_polling_commands_() { if (this->sensorset_.empty()) { ESP_LOGW(TAG, "No sensors registered"); return; } - // Sensors are walked in the sensor set's order (see SensorItemsComparator): register type, then - // force_new_range ahead of the rest, then address - so the walk is not purely address-ordered. - // Each keeps the address it was configured with; what is resolved here is its `offset`, the position - // of its data within the response of whichever range it ends up in. - RegisterRange r = {}; - bool have_range = false; - // Set while the open range belongs to a force_new_range sensor: a range the user asked to keep - // separate must not quietly absorb other sensors. - bool range_forced = false; - // Set once a sensor has joined by sharing the range's start address, which widens the read. Only a - // widened range can absorb a later sensor by coverage: ranges that were kept apart before stay apart, - // so their frames and polling rates are untouched. - bool range_shared = false; - // Bytes the range's registers have consumed so far. An extending sensor starts after them, so a - // register that returns more bytes than its count implies pushes the sensors after it along. - // range_custom_size records whether any of them returns something other than two bytes per register, - // which is what makes a position inside the range impossible to work out from addresses alone. Coils - // count as such: they carry one bit per address, so bit ranges never take the coverage join. - size_t range_bytes = 0; - bool range_custom_size = false; - SensorItem *prev = nullptr; + // At most one range closes per sensor plus one final close, so sensorset_.size() bounds the pushes + // (FixedVector silently drops past capacity). + FixedVector ranges; + ranges.init(this->sensorset_.size()); + RangeBuilder builder(ranges); for (SensorItem *curr : this->sensorset_) { - ESP_LOGV(TAG, "Register: 0x%X count=%d size=%zu offset=%u addr=%p", curr->start_address, curr->register_count, + ESP_LOGV(TAG, "Register: 0x%X width=%u size=%zu offset=%u addr=%p", curr->start_address, curr->entity_count(), curr->get_register_size(), curr->offset, curr); - - const bool custom_size = curr->get_register_size() != static_cast(curr->register_count) * 2; - - bool join = false; - if (have_range && !curr->force_new_range && r.register_type == curr->register_type && - curr->register_type != modbus::EntityType::CUSTOM) { - if (curr->start_address == (r.start_address + r.register_count - prev->register_count) && - prev->start_address + prev->register_count == r.start_address + r.register_count && - curr->register_count == prev->register_count && curr->get_register_size() == prev->get_register_size()) { - // A second sensor on the register(s) the previous one covers: it reads those same bytes, - // starting where that sensor's offset pointed, so a chain configured 0/2/4 resolves to 0/2/6. - // Both address tests matter. The first identifies the previous sensor's register by working back - // from the range's end, which only describes it while it actually sits there - hence the second. - // A sensor that joined mid-range must never anchor this, or the next one inherits its offset. - curr->offset = static_cast(prev->offset + curr->offset_from_start_address); - join = true; - ESP_LOGV(TAG, "Re-use previous register 0x%X", curr->start_address); - } else if (curr->start_address == (r.start_address + r.register_count)) { - // The next contiguous register(s): the data begins after what the range has consumed so far - - // the byte cursor for registers, the distance in bits for coils. - curr->offset = - static_cast((curr->addresses_bits() ? curr->start_address - r.start_address : range_bytes) + - curr->offset_from_start_address); - range_bytes += curr->get_register_size(); - range_custom_size = range_custom_size || custom_size; - r.register_count += curr->register_count; - join = true; - ESP_LOGV(TAG, "Extend range to include 0x%X", curr->start_address); - } else if (range_shared && !range_forced && curr->start_address >= r.start_address && - curr->start_address + curr->register_count <= r.start_address + r.register_count && - !range_custom_size && !custom_size) { - // The registers already fall inside a range that a shared-address join widened, so this sensor - // reads its slice of that response instead of adding an overlapping second poll. The guards keep - // it narrow: only a widened range, never a force-isolated one; only where every register in the - // range returns two bytes, so interior positions follow from the addresses; only sensors genuinely - // inside it, which is why the lower bound is needed given the walk is not address-ordered. - const uint16_t addr_delta = curr->start_address - r.start_address; - curr->offset = static_cast((curr->addresses_bits() ? addr_delta : addr_delta * 2) + - curr->offset_from_start_address); - join = true; - ESP_LOGV(TAG, "Register 0x%X already covered by range 0x%X", curr->start_address, r.start_address); - } + bool join = builder.can_join(curr) && + (builder.try_reuse_register(curr) || builder.try_extend(curr) || builder.try_cover(curr)); + if (!join && builder.always_declined(curr)) { + ESP_LOGW(TAG, "reuse_previous_range on 0x%X cannot join the previous range; starting a new range", + curr->start_address); } - - // Sensors on the same start address have to share one range: a response is dispatched to a single - // range per (start_address, register_type), so a second range with that key would never receive - // data. This holds for force_new_range and custom entities too. The read widens to cover whichever - // sensor needs the most registers, which also fixes a short read for coils that use offset. - if (!join && have_range && r.register_type == curr->register_type && r.start_address == curr->start_address) { - curr->offset = curr->offset_from_start_address; // shares the range start - r.register_count = std::max(r.register_count, curr->register_count); - range_bytes = std::max(range_bytes, curr->get_register_size()); - range_custom_size = range_custom_size || custom_size; - range_shared = true; - range_forced = range_forced || curr->force_new_range; - join = true; - ESP_LOGV(TAG, "Share range start 0x%X", curr->start_address); - } - - if (!join) { - if (have_range) { - ESP_LOGV(TAG, "Add range 0x%X %d", r.start_address, r.register_count); - this->create_polling_command_(std::move(r)); - } - r = {}; - range_bytes = curr->get_register_size(); - range_custom_size = custom_size; - range_forced = curr->force_new_range; - range_shared = false; - curr->offset = curr->offset_from_start_address; - r.start_address = curr->start_address; - r.register_count = curr->register_count; - r.register_type = curr->register_type; - have_range = true; - } - - // Every member records its range's first register. The resolved offset is relative to it, so the - // two together give the sensor's real position, and the address a write entity targets. - curr->range_start_address = r.start_address; - r.sensors.insert(curr); - prev = curr; + join = join || builder.try_share(curr); + if (!join) + builder.open(curr); + builder.record(curr); } - if (have_range) { - ESP_LOGV(TAG, "Add last range 0x%X %d", r.start_address, r.register_count); - this->create_polling_command_(std::move(r)); + builder.close(); + + this->polling_devices_.init(ranges.size()); + for (auto &range : ranges) { + this->polling_devices_.emplace_back(*this, std::move(range)); } - // Reclaim growth slack; safe here because nothing has registered with the hub yet (see the - // lifetime note on polling_command_items_). - this->polling_command_items_.shrink_to_fit(); } void ModbusController::dump_config() { @@ -430,18 +538,20 @@ void ModbusController::dump_config() { #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE ESP_LOGCONFIG(TAG, "sensormap"); for (auto &it : this->sensorset_) { - ESP_LOGCONFIG(TAG, " Sensor type=%u start=0x%X offset=0x%X count=%d size=%zu", - static_cast(it->register_type), it->start_address, it->offset, it->register_count, + ESP_LOGCONFIG(TAG, " Sensor type=%u start=0x%X offset=0x%X width=%u size=%zu", + static_cast(it->register_type), it->start_address, it->offset, it->entity_count(), it->get_register_size()); } ESP_LOGCONFIG(TAG, "ranges"); - for (auto &it : this->polling_command_items_) { + for (auto &it : this->polling_devices_) { ESP_LOGCONFIG(TAG, " Range type=%u start=0x%X count=%d", static_cast(it.register_type()), it.register_address(), it.register_count()); } #endif } +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" void ModbusController::on_write_register_response(EntityType register_type, uint16_t start_address, std::span data) { // A well-formed write ACK echoes address and value, but a truncated PDU yields a short/empty span. @@ -598,5 +708,6 @@ bool ModbusCommandItem::send(modbus::CommandOptions options) { } return accepted; } +#pragma GCC diagnostic pop } // namespace esphome::modbus_controller diff --git a/esphome/components/modbus_controller/modbus_controller.h b/esphome/components/modbus_controller/modbus_controller.h index 1f36d5a7c8..821c500a31 100644 --- a/esphome/components/modbus_controller/modbus_controller.h +++ b/esphome/components/modbus_controller/modbus_controller.h @@ -4,6 +4,7 @@ #include "esphome/components/modbus/modbus.h" #include "esphome/components/modbus/modbus_helpers.h" +#include "esphome/core/helpers.h" #include "esphome/core/automation.h" #include @@ -125,6 +126,16 @@ inline std::vector float_to_payload(float value, SensorValueType value class ModbusController; +/// How an item relates to the register range built just before it (same register type, address order). +/// The numeric order doubles as the comparator tiebreak for items at the same address (see +/// SensorItemsComparator): AUTO items form the shared range first, so a NEVER item comes last and +/// shares a range it did not start (items on one address must share, see create_polling_commands_()). +enum class RangeReuse : uint8_t { + AUTO = 0, // join when adjacent and the position in the reply is exact (no non-standard response_size ahead) + ALWAYS = 1, // join unconditionally, reading across any address gap + NEVER = 2, // never join backward (later items may still extend this item's range) +}; + class SensorItem { public: /// Parse this sensor's slice out of its range's response and publish it. The span points into the @@ -158,11 +169,26 @@ class SensorItem { } void set_custom_pdu(std::initializer_list pdu) { this->custom_pdu.set(pdu.begin(), pdu.size()); } + + /// Entities this item spans: one bit for bit-addressed types, ceil(bytes / 2) registers for RAW + /// with a response_size, else the value type's register width. + virtual uint16_t entity_count() const { + if (modbus::helpers::is_entity_type_binary(this->register_type)) { + return 1; + } + if (this->sensor_value_type == SensorValueType::RAW && this->response_bytes > 0) { + return (this->response_bytes + 1) / 2; + } + return modbus::helpers::register_width_for(this->sensor_value_type); + } + + /// Bytes this item's registers occupy in a response: one per bit for bit-addressed types; response_size + /// when set (devices that answer more bytes per register than the standard two); else two per register. size_t virtual get_register_size() const { if (this->addresses_bits()) { return 1; } else { // if CONF_RESPONSE_BYTES is used override the default - return response_bytes > 0 ? response_bytes : register_count * 2; + return response_bytes > 0 ? response_bytes : this->entity_count() * 2; } } // Override register size for modbus devices not using 1 register for one dword @@ -176,7 +202,6 @@ class SensorItem { /// for the registers ahead of it (including wide response_size ones) and for any offset inherited /// from an earlier sensor sharing the same register. uint8_t offset{0}; - uint8_t register_count{0}; uint8_t response_bytes{0}; /// The offset exactly as configured: measured from this sensor's own start_address, where `offset` /// is measured from the first register of the range it ends up polled in. Same units as `offset` - @@ -187,7 +212,7 @@ class SensorItem { /// First register of the range this sensor is polled in; equals start_address for an unpolled item. uint16_t range_start_address{0}; SmallInlineBuffer<8> custom_pdu{}; - bool force_new_range{false}; + RangeReuse reuse_previous_range{RangeReuse::AUTO}; }; // ModbusController::create_polling_commands_ tries to optimize register range @@ -200,16 +225,17 @@ class SensorItemsComparator { return lhs->register_type < rhs->register_type; } - // ensure that sensor with force_new_range set are before the others - if (lhs->force_new_range != rhs->force_new_range) { - return lhs->force_new_range > rhs->force_new_range; - } - // sort by start address if (lhs->start_address != rhs->start_address) { return lhs->start_address < rhs->start_address; } + // at the same address: AUTO before ALWAYS before NEVER, so a NEVER item never starts the range + // the others at that address are then forced to share (see RangeReuse) + if (lhs->reuse_previous_range != rhs->reuse_previous_range) { + return lhs->reuse_previous_range < rhs->reuse_previous_range; + } + // sort by the offset as configured (ensures update of sensors in ascending order). The resolved // `offset` is deliberately not used: ranges are built while iterating this set and assign it, and // a sort key that changed under the iteration would corrupt the set's ordering. @@ -228,17 +254,24 @@ using SensorSet = std::set; struct RegisterRange { uint16_t start_address; modbus::EntityType register_type; - uint8_t register_count; - SensorSet sensors; // all sensors of this range + uint16_t register_count; // registers (or bits) the poll command reads; joins across gaps can exceed 255 + SensorSet sensors; // all sensors of this range + /// A custom range polls this PDU, referenced from the sensor that opened the range. + const SmallInlineBuffer<8> *custom_pdu{nullptr}; }; -/// A hub device owned by a writer entity (switch/number/select/output) through WriterEntity. -/// Centralises the feedback to the controller - online/offline tracking, retry counting and the -/// on_command_sent trigger - and records every dispatch, so a write lambda can tell "I sent it myself" -/// from "use the default write". The hub base is inherited protected, so the public members below are -/// the entity's whole request API and nothing can bypass the recording or re-target the device. -class WriterDevice final : protected modbus::ModbusClientDevice { +/// The shared feedback half of a controller-owned hub device: online/offline tracking, retry counting +/// and the on_command_sent trigger all route to the controller from here. The hub base is inherited +/// protected, so a subclass chooses exactly what request API it exposes. +class ControllerDevice : protected modbus::ModbusClientDevice { + public: + // Public: only the owner can reach this instance, so reachability is the access gate. + void set_controller(ModbusController *controller); + protected: + ControllerDevice() = default; // WriterEntity's member is wired later via set_controller() + explicit ControllerDevice(ModbusController *controller) { this->set_controller(controller); } + void on_response(std::span request_pdu, std::span response_pdu) override; void on_error(std::span request_pdu, modbus::ExceptionCode exception_code) override; void on_sent(std::span request_pdu) override; @@ -246,90 +279,82 @@ class WriterDevice final : protected modbus::ModbusClientDevice { bool on_no_response(std::span request_pdu) override; void notify_online_(std::span request_pdu); - /// Function code / register address decoded from a request PDU ([fc, addr_hi, addr_lo, ...]). - static int fc_of(std::span pdu) { return pdu.empty() ? 0 : (pdu[0] & modbus::FUNCTION_CODE_MASK); } - static int addr_of(std::span pdu) { - return pdu.size() >= 3 ? modbus::helpers::get_data(pdu.data(), 1) : 0; - } - /// Declared before controller_ so they land in the padding after ModbusClientDevice::custom_response_warned_ - /// instead of adding a word to every entity that owns a device. - /// dispatched_: a frame was queued since the last clear_dispatched_(). - /// write_buffer_deprecated_warned_: warn-once for the legacy write_lambda buffer parameter. + /// Write-path state owned by WriterEntity's forwarders, stored here so both bools land in the base's + /// tail padding instead of adding a word to every writer entity. The warn flag leaves in 2027.3.0. bool dispatched_{false}; bool write_buffer_deprecated_warned_{false}; ModbusController *controller_{nullptr}; +}; +/// The write side of a ControllerDevice, owned by the writer entities through WriterEntity, whose +/// forwarders re-expose exactly the request API a write lambda may use and record every dispatch. +class WriterDevice final : public ControllerDevice { public: - /// Whether a frame was queued to the hub since the last clear_dispatched_(). - bool dispatched() const { return this->dispatched_; } + using modbus::ModbusClientDevice::clear_tx_queue_for_device; + using modbus::ModbusClientDevice::queue_pdu; + using modbus::ModbusClientDevice::write_multiple_coils; + using modbus::ModbusClientDevice::write_multiple_registers; + using modbus::ModbusClientDevice::write_single_coil; + using modbus::ModbusClientDevice::write_single_register; - bool write_single_register(uint16_t address, uint16_t value) { - this->dispatched_ = true; - return modbus::ModbusClientDevice::write_single_register(address, value); - } - bool write_single_coil(uint16_t address, bool value) { - this->dispatched_ = true; - return modbus::ModbusClientDevice::write_single_coil(address, value); - } - bool write_multiple_registers(uint16_t address, std::span values) { - this->dispatched_ = true; - return modbus::ModbusClientDevice::write_multiple_registers(address, values); - } - bool write_multiple_coils(uint16_t address, std::span values) { - this->dispatched_ = true; - return modbus::ModbusClientDevice::write_multiple_coils(address, values); - } - bool write_multiple_coils(uint16_t address, modbus::PackedBits bits) { - this->dispatched_ = true; - return modbus::ModbusClientDevice::write_multiple_coils(address, bits); - } - bool queue_pdu(std::span pdu, modbus::CommandOptions options = {}) { - this->dispatched_ = true; - return modbus::ModbusClientDevice::queue_pdu(pdu, options); - } /// Send a legacy raw frame (address + function code + data) to the frame's own address. /// Serves only the deprecated write_lambda buffer path. Remove before 2027.3.0. bool send_raw_frame_deprecated(std::span frame); - void clear_tx_queue_for_device() { modbus::ModbusClientDevice::clear_tx_queue_for_device(); } - - // Entity plumbing, public because the owning WriterEntity holds the only reachable instance (device_ is - // protected there and the hub sees just the masked base) - reachability is the access gate, not a friend. - void set_controller(ModbusController *controller); + bool dispatched() const { return this->dispatched_; } + void set_dispatched() { this->dispatched_ = true; } void clear_dispatched() { this->dispatched_ = false; } /// Warn once per entity that filling the write_lambda buffer parameter is deprecated (the entity is now the /// command - call a write helper / queue_pdu() on `item` instead). The buffer parameter is removed in 2027.3.0. void warn_write_buffer_deprecated(const LogString *platform, uint16_t address); + + protected: + // Only the write side forwards to the typed callbacks (for item->queue_pdu() replies): a poll parses + // its own response, and dispatching its errors would trip the base unhandled-custom-response warning. + void on_response(std::span request_pdu, std::span response_pdu) override; + void on_error(std::span request_pdu, modbus::ExceptionCode exception_code) override; }; /// Gives a writer entity the write API of the WriterDevice it owns. The device is a member, not a base: /// the mixin declares no virtual function, so an entity mixing it in gains no second vtable and all the /// writer platforms share the single WriterDevice vtable instead of each emitting its own copy. -/// The forwarders keep `item->write_*()` working unchanged inside a write_lambda. +/// The forwarders keep `item->write_*()` working unchanged inside a write_lambda, and record every +/// dispatch, so the write path can tell "the lambda sent it itself" from "use the default write". class WriterEntity { public: + /// Whether the lambda called a request helper since the last clear_dispatched_(). Deliberately records + /// the call, not the hub's accept/refuse: a refused lambda write must not fall through to the default write. bool dispatched() const { return this->device_.dispatched(); } bool write_single_register(uint16_t address, uint16_t value) { + this->device_.set_dispatched(); return this->device_.write_single_register(address, value); } - bool write_single_coil(uint16_t address, bool value) { return this->device_.write_single_coil(address, value); } + bool write_single_coil(uint16_t address, bool value) { + this->device_.set_dispatched(); + return this->device_.write_single_coil(address, value); + } bool write_multiple_registers(uint16_t address, std::span values) { + this->device_.set_dispatched(); return this->device_.write_multiple_registers(address, values); } bool write_multiple_coils(uint16_t address, std::span values) { + this->device_.set_dispatched(); return this->device_.write_multiple_coils(address, values); } bool write_multiple_coils(uint16_t address, modbus::PackedBits bits) { + this->device_.set_dispatched(); return this->device_.write_multiple_coils(address, bits); } bool queue_pdu(std::span pdu, modbus::CommandOptions options = {}) { + this->device_.set_dispatched(); return this->device_.queue_pdu(pdu, options); } void clear_tx_queue_for_device() { this->device_.clear_tx_queue_for_device(); } protected: bool send_raw_frame_deprecated_(std::span frame) { + this->device_.set_dispatched(); return this->device_.send_raw_frame_deprecated(frame); } void set_controller_(ModbusController *controller) { this->device_.set_controller(controller); } @@ -338,13 +363,40 @@ class WriterEntity { this->device_.warn_write_buffer_deprecated(platform, address); } + private: + // Private so a derived entity cannot reach the device except through the recording forwarders above. WriterDevice device_; }; +/// A persistent hub device that polls one register range - the read-side mirror of WriterDevice. +/// Owned by the controller, one per range; the response is parsed straight to the range's sensors. +class PollingDevice final : public ControllerDevice { + public: + PollingDevice(ModbusController &controller, RegisterRange &&range); + + /// Queue this range's read (or its sensor's custom PDU) on the hub. False = refused, no callback follows. + bool queue(modbus::CommandOptions options = {}); + + uint16_t register_address() const { return this->range_.start_address; } + uint16_t register_count() const { return this->range_.register_count; } + EntityType register_type() const { return this->range_.register_type; } + + protected: + void on_response(std::span request_pdu, std::span response_pdu) override; + + RegisterRange range_; +}; + /// A single modbus command. Each command is its own ModbusClientDevice: it sends its frame to the hub /// and the hub routes the response back to this object's on_modbus_* callbacks, so the controller no /// longer has to match responses to a FIFO queue. -class ModbusCommandItem : public modbus::ModbusClientDevice { +// The deprecated class references other deprecated names. Remove before 2027.3.0. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +class ESPDEPRECATED( + "One-shot writes go through the entity write helpers (WriterDevice) or the modbus_client actions, and " + "polling runs through PollingDevice. Removed in 2027.3.0", + "2026.9.0") ModbusCommandItem : public modbus::ModbusClientDevice { public: /// Empty command with no controller connection (kept for source compatibility with value-type usage). ModbusCommandItem(ModbusController &controller, modbus::ModbusClientHub *parent, uint8_t address) @@ -489,6 +541,7 @@ class ModbusCommandItem : public modbus::ModbusClientDevice { const SmallInlineBuffer<8> *custom_pdu_{nullptr}; ModbusController *controller_{nullptr}; }; +#pragma GCC diagnostic pop /// Whether an offline probe is due this update cycle: every offline_skip_updates + 1 cycles, /// anchored at the cycle the device went offline. Pure so the cadence (including update_counter @@ -522,14 +575,24 @@ class ModbusController final : public PollingComponent { modbus::ModbusClientHub *hub() const { return this->hub_; } uint8_t device_address() const { return this->address_; } +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" /// Queues a one-shot modbus command (writes, custom commands); taken by value, so std::move to avoid a copy. + /// Remove with ModbusCommandItem before 2027.3.0. + ESPDEPRECATED("Use the entity write helpers or the modbus_client actions instead. Removed in 2027.3.0", "2026.9.0") void queue_command(ModbusCommandItem command); /// Flags a finished one-shot command for removal. Called by the command as the last action of its own /// callback, so the item is not destroyed here (send() and the hub still touch it) but swept later. + /// Remove with ModbusCommandItem before 2027.3.0. + ESPDEPRECATED("Serves only ModbusCommandItem's own callbacks. Removed in 2027.3.0", "2026.9.0") void unqueue_command(const ModbusCommandItem *command); +#pragma GCC diagnostic pop /// Registers a sensor with the controller. Called by esphomes code generator void add_sensor_item(SensorItem *item) { sensorset_.insert(item); } /// Handles a write command acknowledgement (used by write command on_data_func handlers). + /// Remove with ModbusCommandItem before 2027.3.0. + ESPDEPRECATED("Write acknowledgements are handled by the writing entity's own device. Removed in 2027.3.0", + "2026.9.0") void on_write_register_response(EntityType register_type, uint16_t start_address, std::span data); /// Update the online/offline state after a response or a run of timeouts, firing the callbacks. void set_online(bool online, int function_code, int register_address); @@ -568,32 +631,22 @@ class ModbusController final : public PollingComponent { const modbus::CommandOptions &read_options() const { return this->read_options_; } protected: - /// parse sensormap_ and create range of sequential addresses - /// Group the registered sensors into contiguous ranges and create one polling command per range. + /// Group the registered sensors into contiguous ranges and create one PollingDevice per range. void create_polling_commands_(); - /// build one persistent polling command from a range and add it to polling_command_items_ - void create_polling_command_(RegisterRange &&range) { - // A custom range polls the first sensor's custom_pdu (referenced, not copied); the sensor constructor - // decodes the real function code. The response still dispatches to every sensor in the range. - if (range.register_type == EntityType::CUSTOM && !range.sensors.empty()) { - auto &cmd = this->polling_command_items_.emplace_back(*this, this->hub_, this->address_, *range.sensors.begin()); - cmd.sensors = std::move(range.sensors); - } else { - this->polling_command_items_.emplace_back(*this, this->hub_, this->address_, std::move(range)); - } - } /// The hub this controller's commands/entities send through, and the modbus address they target. modbus::ModbusClientHub *hub_{nullptr}; uint8_t address_{0}; /// Collection of all sensors for this component SensorSet sensorset_; - /// One persistent command per register range, each its own ModbusClientDevice. Built once in setup() - /// (create_polling_commands_ feeds each range straight in; the vector may reallocate as it grows, which - /// is safe because no command has registered with the hub yet) and never appended to afterward, so the - /// hub's device pointers stay valid once commands start sending. - std::vector polling_command_items_{}; + /// One persistent PollingDevice per register range. Built once in setup() with the exact count + /// (FixedVector never reallocates), so the hub's device pointers stay valid once polls start sending. + FixedVector polling_devices_; /// Dynamically queued one-shot commands (writes, custom commands). std::list keeps stable addresses. + /// Remove with ModbusCommandItem before 2027.3.0. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" std::list> one_shot_command_items_; +#pragma GCC diagnostic pop /// Erases one-shot commands flagged by unqueue_command(). Safe even when reached from inside a hub /// callback (via an on_online/on_offline/on_command_sent automation that queues a command): the /// destructor detaches via clear_tx_queue_for_device(), which the hub allows from callbacks, and the diff --git a/esphome/components/modbus_controller/number/__init__.py b/esphome/components/modbus_controller/number/__init__.py index 6a5b7041b8..6f7bf588af 100644 --- a/esphome/components/modbus_controller/number/__init__.py +++ b/esphome/components/modbus_controller/number/__init__.py @@ -17,20 +17,22 @@ from esphome.const import ( from esphome.types import ConfigType from .. import ( + RANGE_REUSE, ModbusItemBaseSchema, SensorItem, add_modbus_base_properties, modbus_calc_properties, modbus_controller_ns, validate_custom_pdu_item, + validate_range_reuse_migration, ) from ..const import ( CONF_BITMASK, CONF_CUSTOM_COMMAND, CONF_CUSTOM_PDU, - CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, CONF_REGISTER_TYPE, + CONF_REUSE_PREVIOUS_RANGE, CONF_USE_WRITE_MULTIPLE, CONF_VALUE_TYPE, CONF_WRITE_LAMBDA, @@ -86,13 +88,14 @@ CONFIG_SCHEMA = cv.All( ), validate_min_max, validate_modbus_number, + validate_range_reuse_migration, ) FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item async def to_code(config: ConfigType) -> None: - byte_offset, reg_count = modbus_calc_properties(config) + byte_offset = modbus_calc_properties(config) var = cg.new_Pvariable( config[CONF_ID], config[CONF_REGISTER_TYPE], @@ -100,8 +103,7 @@ async def to_code(config: ConfigType) -> None: byte_offset, config[CONF_BITMASK], config[CONF_VALUE_TYPE], - reg_count, - config[CONF_FORCE_NEW_RANGE], + RANGE_REUSE[config[CONF_REUSE_PREVIOUS_RANGE]], ) await cg.register_component(var, config) diff --git a/esphome/components/modbus_controller/number/modbus_number.cpp b/esphome/components/modbus_controller/number/modbus_number.cpp index e890a2a9ac..aff05cd517 100644 --- a/esphome/components/modbus_controller/number/modbus_number.cpp +++ b/esphome/components/modbus_controller/number/modbus_number.cpp @@ -83,10 +83,10 @@ void ModbusNumber::control(float value) { ESP_LOGD(TAG, "Updating register: connected Sensor=%s start address=0x%X register count=%d new value=%.02f (val=%.02f)", - this->get_name().c_str(), this->start_address, this->register_count, value, write_value); + this->get_name().c_str(), this->start_address, this->entity_count(), value, write_value); bool queued; - if (this->register_count == 1 && !this->use_write_multiple_) { + if (this->entity_count() == 1 && !this->use_write_multiple_) { queued = this->write_single_register(this->write_address(), data[0]); } else { queued = this->write_multiple_registers(this->write_address(), data); diff --git a/esphome/components/modbus_controller/number/modbus_number.h b/esphome/components/modbus_controller/number/modbus_number.h index 59c76e18f2..a61840cf5b 100644 --- a/esphome/components/modbus_controller/number/modbus_number.h +++ b/esphome/components/modbus_controller/number/modbus_number.h @@ -13,14 +13,13 @@ using value_to_data_t = std::function(float); class ModbusNumber final : public number::Number, public Component, public SensorItem, public WriterEntity { public: ModbusNumber(modbus::EntityType register_type, uint16_t start_address, uint8_t offset, uint32_t bitmask, - SensorValueType value_type, int register_count, bool force_new_range) { + SensorValueType value_type, RangeReuse reuse_previous_range) { this->register_type = register_type; this->set_address(start_address); this->set_offset_from_start_address(offset); this->bitmask = bitmask; this->sensor_value_type = value_type; - this->register_count = register_count; - this->force_new_range = force_new_range; + this->reuse_previous_range = reuse_previous_range; }; void dump_config() override; diff --git a/esphome/components/modbus_controller/output/__init__.py b/esphome/components/modbus_controller/output/__init__.py index 34a0f488ec..0e8d5363d7 100644 --- a/esphome/components/modbus_controller/output/__init__.py +++ b/esphome/components/modbus_controller/output/__init__.py @@ -1,3 +1,5 @@ +import logging + import esphome.codegen as cg from esphome.components import output from esphome.components.modbus.helpers import ( @@ -12,19 +14,26 @@ from esphome.types import ConfigType from .. import ( ModbusItemBaseSchema, SensorItem, + entity_label, modbus_calc_properties, modbus_controller_ns, + reject_odd_holding_write_offset, ) from ..const import ( CONF_CUSTOM_COMMAND, CONF_CUSTOM_PDU, + CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, + CONF_REGISTER_COUNT, CONF_REGISTER_TYPE, + CONF_REUSE_PREVIOUS_RANGE, CONF_USE_WRITE_MULTIPLE, CONF_VALUE_TYPE, CONF_WRITE_LAMBDA, ) +_LOGGER = logging.getLogger(__name__) + DEPENDENCIES = ["modbus_controller"] CODEOWNERS = ["@martgras"] @@ -37,49 +46,73 @@ ModbusBinaryOutput = modbus_controller_ns.class_( ) -CONFIG_SCHEMA = cv.typed_schema( - { - "coil": output.BINARY_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend( - { - cv.GenerateID(): cv.declare_id(ModbusBinaryOutput), - cv.Required(CONF_ADDRESS): cv.positive_int, - cv.Optional(CONF_CUSTOM_PDU): cv.invalid( - "custom_pdu is not supported for outputs; use a write_lambda instead" +def _warn_unused_range_options(config: ConfigType) -> ConfigType: + # Outputs are write-only and never polled, so nothing here builds a range for them. The write + # spans whatever the payload holds, so register_count no longer bounds it either. + for key in (CONF_FORCE_NEW_RANGE, CONF_REGISTER_COUNT): + if config.pop(key, None) is not None: + _LOGGER.warning( + "%s: '%s' has no effect on outputs; remove it. Removed in 2027.3.0", + entity_label(config), + key, + ) + if config.pop(CONF_REUSE_PREVIOUS_RANGE, None) not in (None, "auto"): + raise cv.Invalid( + f"'{CONF_REUSE_PREVIOUS_RANGE}' has no effect on outputs: they are write-only and are " + f"never part of a polled range. Remove it." + ) + return config + + +CONFIG_SCHEMA = cv.All( + cv.typed_schema( + { + "coil": output.BINARY_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend( + { + cv.GenerateID(): cv.declare_id(ModbusBinaryOutput), + cv.Required(CONF_ADDRESS): cv.positive_int, + cv.Optional(CONF_CUSTOM_PDU): cv.invalid( + "custom_pdu is not supported for outputs; use a write_lambda instead" + ), + cv.Optional(CONF_CUSTOM_COMMAND): cv.invalid( + "custom_command is not supported for outputs; use a write_lambda instead" + ), + cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda, + cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean, + } + ), + "holding": cv.All( + output.FLOAT_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend( + { + cv.GenerateID(): cv.declare_id(ModbusFloatOutput), + cv.Required(CONF_ADDRESS): cv.positive_int, + cv.Optional(CONF_CUSTOM_PDU): cv.invalid( + "custom_pdu is not supported for outputs; use a write_lambda instead" + ), + cv.Optional(CONF_CUSTOM_COMMAND): cv.invalid( + "custom_command is not supported for outputs; use a write_lambda instead" + ), + cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum( + SENSOR_VALUE_TYPE + ), + cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda, + cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_, + cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean, + } ), - cv.Optional(CONF_CUSTOM_COMMAND): cv.invalid( - "custom_command is not supported for outputs; use a write_lambda instead" - ), - cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda, - cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean, - } - ), - "holding": output.FLOAT_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend( - { - cv.GenerateID(): cv.declare_id(ModbusFloatOutput), - cv.Required(CONF_ADDRESS): cv.positive_int, - cv.Optional(CONF_CUSTOM_PDU): cv.invalid( - "custom_pdu is not supported for outputs; use a write_lambda instead" - ), - cv.Optional(CONF_CUSTOM_COMMAND): cv.invalid( - "custom_command is not supported for outputs; use a write_lambda instead" - ), - cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum( - SENSOR_VALUE_TYPE - ), - cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda, - cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_, - cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean, - } - ), - }, - lower=True, - key=CONF_REGISTER_TYPE, - default_type="holding", + reject_odd_holding_write_offset, + ), + }, + lower=True, + key=CONF_REGISTER_TYPE, + default_type="holding", + ), + _warn_unused_range_options, ) async def to_code(config: ConfigType) -> None: - byte_offset, reg_count = modbus_calc_properties(config) + byte_offset = modbus_calc_properties(config) # Binary Output write_template = None if config[CONF_REGISTER_TYPE] == "coil": @@ -105,7 +138,6 @@ async def to_code(config: ConfigType) -> None: config[CONF_ADDRESS], byte_offset, config[CONF_VALUE_TYPE], - reg_count, ) cg.add(var.set_write_multiply(config[CONF_MULTIPLY])) if CONF_WRITE_LAMBDA in config: diff --git a/esphome/components/modbus_controller/output/modbus_output.cpp b/esphome/components/modbus_controller/output/modbus_output.cpp index b05d3889fd..ad29015d32 100644 --- a/esphome/components/modbus_controller/output/modbus_output.cpp +++ b/esphome/components/modbus_controller/output/modbus_output.cpp @@ -46,29 +46,24 @@ void ModbusFloatOutput::write_state(float value) { modbus::helpers::float_to_payload(data, value, this->sensor_value_type); } - ESP_LOGD(TAG, "Updating register: start address=0x%X register count=%d new value=%.02f (val=%.02f)", - this->start_address, this->register_count, value, original_value); + ESP_LOGD(TAG, "Updating register: start address=0x%X register count=%u new value=%.02f (val=%.02f)", + this->start_address, this->entity_count(), value, original_value); - // The command declares register_count registers, so the payload must be exactly that many words; - // anything else would put a byte count on the wire that disagrees with the quantity field. - // number_to_payload() appends nothing for RAW, so an empty payload must be caught before data[0]. + // float_to_payload() appends nothing for RAW, so an empty payload must be caught before data[0]. if (data.empty()) { ESP_LOGW(TAG, "No payload was created for updating output"); return; } - // register_count declares the READ range width - it may pull neighboring registers into one poll - - // so a write covers exactly the registers the value occupies: the quantity comes from the payload, - // never from register_count (padding to it would zero registers the user only declared for reading). - // A payload wider than the declared range means the config and the lambda disagree - drop it. - if (data.size() > this->register_count) { - ESP_LOGE(TAG, "Payload has %zu registers but register_count is %u; dropping write", data.size(), - this->register_count); + // The value type sets the write width, so a wider payload means the config and the lambda disagree. + if (data.size() > this->entity_count()) { + ESP_LOGE(TAG, "Payload has %zu registers but the value type only spans %u; dropping write", data.size(), + this->entity_count()); return; } bool queued; - if (this->register_count == 1 && !this->use_write_multiple_) { + if (this->entity_count() == 1 && !this->use_write_multiple_) { queued = this->write_single_register(this->write_address(), data[0]); } else { queued = this->write_multiple_registers(this->write_address(), data); @@ -85,7 +80,7 @@ void ModbusFloatOutput::dump_config() { " Device start address: 0x%X\n" " Register count: %d\n" " Value type: %d", - this->start_address, this->register_count, static_cast(this->sensor_value_type)); + this->start_address, this->entity_count(), static_cast(this->sensor_value_type)); } // ModbusBinaryOutput @@ -145,7 +140,7 @@ void ModbusBinaryOutput::dump_config() { " Device start address: 0x%X\n" " Register count: %d\n" " Value type: %d", - this->start_address, this->register_count, static_cast(this->sensor_value_type)); + this->start_address, this->entity_count(), static_cast(this->sensor_value_type)); } } // namespace esphome::modbus_controller diff --git a/esphome/components/modbus_controller/output/modbus_output.h b/esphome/components/modbus_controller/output/modbus_output.h index b942dcea62..f76c7eada7 100644 --- a/esphome/components/modbus_controller/output/modbus_output.h +++ b/esphome/components/modbus_controller/output/modbus_output.h @@ -10,12 +10,12 @@ namespace esphome::modbus_controller { class ModbusFloatOutput final : public output::FloatOutput, public Component, public SensorItem, public WriterEntity { public: - ModbusFloatOutput(uint16_t start_address, uint8_t offset, SensorValueType value_type, int register_count) { + ModbusFloatOutput(uint16_t start_address, uint8_t offset, SensorValueType value_type) { this->register_type = modbus::EntityType::HOLDING; - this->set_address(start_address + offset); + // A byte offset folds into the address as whole registers; odd offsets are rejected at validation. + this->set_address(start_address + offset / 2); this->set_offset_from_start_address(0); this->bitmask = 0xFFFFFFFF; - this->register_count = register_count; this->sensor_value_type = value_type; } void dump_config() override; @@ -45,7 +45,6 @@ class ModbusBinaryOutput final : public output::BinaryOutput, public Component, this->set_address(start_address + offset); this->bitmask = 0xFFFFFFFF; this->sensor_value_type = SensorValueType::BIT; - this->register_count = 1; this->set_offset_from_start_address(0); } void dump_config() override; diff --git a/esphome/components/modbus_controller/select/__init__.py b/esphome/components/modbus_controller/select/__init__.py index 07893e3303..d8319932ab 100644 --- a/esphome/components/modbus_controller/select/__init__.py +++ b/esphome/components/modbus_controller/select/__init__.py @@ -3,25 +3,24 @@ from typing import Any import esphome.codegen as cg from esphome.components import select -from esphome.components.modbus.helpers import ( - SENSOR_VALUE_TYPE, - TYPE_REGISTER_MAP, - RegisterValues, -) +from esphome.components.modbus.helpers import SENSOR_VALUE_TYPE, RegisterValues import esphome.config_validation as cv from esphome.const import CONF_ADDRESS, CONF_ID, CONF_LAMBDA, CONF_OPTIMISTIC from esphome.types import ConfigType from .. import ( + RANGE_REUSE, ModbusController, SensorItem, modbus_controller_ns, + validate_range_reuse_migration, validate_skip_updates_deprecated, ) from ..const import ( CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, CONF_REGISTER_COUNT, + CONF_REUSE_PREVIOUS_RANGE, CONF_SKIP_UPDATES, CONF_USE_WRITE_MULTIPLE, CONF_VALUE_TYPE, @@ -55,18 +54,6 @@ def ensure_option_map() -> Callable[[Any], dict[str, int]]: return validator -def register_count_value_type_min(value: ConfigType) -> ConfigType: - reg_count = value.get(CONF_REGISTER_COUNT) - if reg_count is not None: - value_type = value[CONF_VALUE_TYPE] - min_register_count = TYPE_REGISTER_MAP[value_type] - if min_register_count > reg_count: - raise cv.Invalid( - f"Value type {value_type} needs at least {min_register_count} registers" - ) - return value - - INTEGER_SENSOR_VALUE_TYPE = { key: value for key, value in SENSOR_VALUE_TYPE.items() if not key.startswith("FP") } @@ -81,9 +68,13 @@ CONFIG_SCHEMA = cv.All( cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum( INTEGER_SENSOR_VALUE_TYPE ), - cv.Optional(CONF_REGISTER_COUNT): cv.positive_int, cv.Optional(CONF_SKIP_UPDATES): validate_skip_updates_deprecated, - cv.Optional(CONF_FORCE_NEW_RANGE, default=False): cv.boolean, + cv.Optional(CONF_REUSE_PREVIOUS_RANGE, default="auto"): cv.Any( + cv.boolean, cv.one_of("auto", lower=True) + ), + # Deprecated options, migrated by validate_range_reuse_migration(). Remove before 2027.3.0 + cv.Optional(CONF_FORCE_NEW_RANGE): cv.boolean, + cv.Optional(CONF_REGISTER_COUNT): cv.positive_int, cv.Required(CONF_OPTIONSMAP): ensure_option_map(), cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean, cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean, @@ -91,24 +82,18 @@ CONFIG_SCHEMA = cv.All( cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda, }, ), - register_count_value_type_min, + validate_range_reuse_migration, ) async def to_code(config: ConfigType) -> None: - value_type = config[CONF_VALUE_TYPE] - reg_count = config.get(CONF_REGISTER_COUNT) - if reg_count is None: - reg_count = TYPE_REGISTER_MAP[value_type] - options_map = config[CONF_OPTIONSMAP] var = cg.new_Pvariable( config[CONF_ID], - value_type, + config[CONF_VALUE_TYPE], config[CONF_ADDRESS], - reg_count, - config[CONF_FORCE_NEW_RANGE], + RANGE_REUSE[config[CONF_REUSE_PREVIOUS_RANGE]], list(options_map.values()), ) diff --git a/esphome/components/modbus_controller/select/modbus_select.cpp b/esphome/components/modbus_controller/select/modbus_select.cpp index c1cc241d6b..a2f15d54f6 100644 --- a/esphome/components/modbus_controller/select/modbus_select.cpp +++ b/esphome/components/modbus_controller/select/modbus_select.cpp @@ -83,19 +83,17 @@ void ModbusSelect::control(size_t index) { } } - // register_count declares the READ range width - it may pull neighboring registers into one poll - - // so a write covers exactly the registers the value occupies: the quantity comes from the payload, - // never from register_count (padding to it would zero registers the user only declared for reading). - // A payload wider than the declared range means the config and the lambda disagree - drop it. - if (data.size() > this->register_count) { - ESP_LOGE(TAG, "Payload has %zu registers but register_count is %u; dropping write", data.size(), - this->register_count); + // A write covers exactly the registers the value occupies: the quantity comes from the payload. A + // payload wider than the value type's register width means the config and the lambda disagree - drop it. + if (data.size() > this->entity_count()) { + ESP_LOGE(TAG, "Payload has %zu registers but the value type only spans %u; dropping write", data.size(), + this->entity_count()); return; } const uint16_t write_address = this->write_address(); bool queued; - if ((this->register_count == 1) && (!this->use_write_multiple_)) { + if ((this->entity_count() == 1) && (!this->use_write_multiple_)) { queued = this->write_single_register(write_address, data[0]); } else { queued = this->write_multiple_registers(write_address, data); diff --git a/esphome/components/modbus_controller/select/modbus_select.h b/esphome/components/modbus_controller/select/modbus_select.h index c6ac76a45b..3827d38755 100644 --- a/esphome/components/modbus_controller/select/modbus_select.h +++ b/esphome/components/modbus_controller/select/modbus_select.h @@ -11,16 +11,15 @@ namespace esphome::modbus_controller { class ModbusSelect final : public Component, public select::Select, public SensorItem, public WriterEntity { public: - ModbusSelect(SensorValueType sensor_value_type, uint16_t start_address, uint8_t register_count, bool force_new_range, + ModbusSelect(SensorValueType sensor_value_type, uint16_t start_address, RangeReuse reuse_previous_range, std::vector mapping) { this->register_type = modbus::EntityType::HOLDING; // not configurable this->sensor_value_type = sensor_value_type; this->set_address(start_address); this->set_offset_from_start_address(0); // not configurable this->bitmask = 0xFFFFFFFF; // not configurable - this->register_count = register_count; - this->response_bytes = 0; // not configurable - this->force_new_range = force_new_range; + this->response_bytes = 0; // not configurable + this->reuse_previous_range = reuse_previous_range; this->mapping_ = std::move(mapping); } diff --git a/esphome/components/modbus_controller/sensor/__init__.py b/esphome/components/modbus_controller/sensor/__init__.py index 2c34ef04b4..bd51b9a8a3 100644 --- a/esphome/components/modbus_controller/sensor/__init__.py +++ b/esphome/components/modbus_controller/sensor/__init__.py @@ -5,6 +5,7 @@ import esphome.config_validation as cv from esphome.const import CONF_ADDRESS, CONF_ID from .. import ( + RANGE_REUSE, ModbusItemBaseSchema, SensorItem, add_modbus_base_properties, @@ -12,13 +13,13 @@ from .. import ( modbus_controller_ns, validate_custom_pdu_item, validate_modbus_register, + validate_range_reuse_migration, ) from ..const import ( CONF_BITMASK, - CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, - CONF_REGISTER_COUNT, CONF_REGISTER_TYPE, + CONF_REUSE_PREVIOUS_RANGE, CONF_VALUE_TYPE, ) @@ -38,27 +39,25 @@ CONFIG_SCHEMA = cv.All( { cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE), cv.Optional(CONF_VALUE_TYPE, default="U_WORD"): cv.enum(SENSOR_VALUE_TYPE), - cv.Optional(CONF_REGISTER_COUNT, default=0): cv.positive_int, } ), validate_modbus_register, + validate_range_reuse_migration, ) FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item async def to_code(config): - byte_offset, reg_count = modbus_calc_properties(config) - value_type = config[CONF_VALUE_TYPE] + byte_offset = modbus_calc_properties(config) var = cg.new_Pvariable( config[CONF_ID], config[CONF_REGISTER_TYPE], config[CONF_ADDRESS], byte_offset, config[CONF_BITMASK], - value_type, - reg_count, - config[CONF_FORCE_NEW_RANGE], + config[CONF_VALUE_TYPE], + RANGE_REUSE[config[CONF_REUSE_PREVIOUS_RANGE]], ) await cg.register_component(var, config) await sensor.register_sensor(var, config) diff --git a/esphome/components/modbus_controller/sensor/modbus_sensor.h b/esphome/components/modbus_controller/sensor/modbus_sensor.h index 68dc9e6fcc..12c29bf584 100644 --- a/esphome/components/modbus_controller/sensor/modbus_sensor.h +++ b/esphome/components/modbus_controller/sensor/modbus_sensor.h @@ -11,14 +11,13 @@ namespace esphome::modbus_controller { class ModbusSensor final : public Component, public sensor::Sensor, public SensorItem { public: ModbusSensor(modbus::EntityType register_type, uint16_t start_address, uint8_t offset, uint32_t bitmask, - SensorValueType value_type, int register_count, bool force_new_range) { + SensorValueType value_type, RangeReuse reuse_previous_range) { this->register_type = register_type; this->set_address(start_address); this->set_offset_from_start_address(offset); this->bitmask = bitmask; this->sensor_value_type = value_type; - this->register_count = register_count; - this->force_new_range = force_new_range; + this->reuse_previous_range = reuse_previous_range; } void parse_and_publish(std::span data) override; diff --git a/esphome/components/modbus_controller/switch/__init__.py b/esphome/components/modbus_controller/switch/__init__.py index c52067f941..00b67446a3 100644 --- a/esphome/components/modbus_controller/switch/__init__.py +++ b/esphome/components/modbus_controller/switch/__init__.py @@ -6,19 +6,22 @@ from esphome.const import CONF_ADDRESS, CONF_ASSUMED_STATE, CONF_ID from esphome.types import ConfigType from .. import ( + RANGE_REUSE, ModbusItemBaseSchema, SensorItem, add_modbus_base_properties, modbus_calc_properties, modbus_controller_ns, + reject_odd_holding_write_offset, validate_custom_pdu_item, validate_modbus_register, + validate_range_reuse_migration, ) from ..const import ( CONF_BITMASK, - CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, CONF_REGISTER_TYPE, + CONF_REUSE_PREVIOUS_RANGE, CONF_USE_WRITE_MULTIPLE, CONF_WRITE_LAMBDA, ) @@ -31,6 +34,14 @@ ModbusSwitch = modbus_controller_ns.class_( "ModbusSwitch", cg.Component, switch.Switch, SensorItem ) + +def _validate_holding_offset(config: ConfigType) -> ConfigType: + # Only a holding-register switch folds the byte offset into a 16-bit register write. + if config.get(CONF_REGISTER_TYPE) == "holding": + reject_odd_holding_write_offset(config) + return config + + CONFIG_SCHEMA = cv.All( switch.switch_schema(ModbusSwitch, default_restore_mode="DISABLED") .extend(cv.COMPONENT_SCHEMA) @@ -44,20 +55,22 @@ CONFIG_SCHEMA = cv.All( } ), validate_modbus_register, + _validate_holding_offset, + validate_range_reuse_migration, ) FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item async def to_code(config: ConfigType) -> None: - byte_offset, _ = modbus_calc_properties(config) + byte_offset = modbus_calc_properties(config) var = cg.new_Pvariable( config[CONF_ID], config[CONF_REGISTER_TYPE], config[CONF_ADDRESS], byte_offset, config[CONF_BITMASK], - config[CONF_FORCE_NEW_RANGE], + RANGE_REUSE[config[CONF_REUSE_PREVIOUS_RANGE]], ) await cg.register_component(var, config) await switch.register_switch(var, config) diff --git a/esphome/components/modbus_controller/switch/modbus_switch.cpp b/esphome/components/modbus_controller/switch/modbus_switch.cpp index c942ff1e6f..7bf45366c0 100644 --- a/esphome/components/modbus_controller/switch/modbus_switch.cpp +++ b/esphome/components/modbus_controller/switch/modbus_switch.cpp @@ -65,6 +65,7 @@ void ModbusSwitch::write_state(bool state) { // so a rapidly-changing value writes the latest, not every intermediate. this->clear_tx_queue_for_device(); modbus::helpers::PduBuffer data; + bool write_value = state; if (this->write_transform_func_.has_value()) { // The lambda may drive the write itself via item->write_*/queue_pdu(), override the written value (return a // value), or (deprecated) fill `data` with a custom PDU. @@ -92,26 +93,29 @@ void ModbusSwitch::write_state(bool state) { ESP_LOGV(TAG, "Communication handled by lambda - exiting control"); return; } + // The returned bool is the wire value only; the entity still reports the requested state. A polled + // entity needs the read lambda inverted to match, or the next poll flips the display back. ESP_LOGV(TAG, "Value overwritten by lambda"); - state = val.value(); + write_value = val.value(); } - ESP_LOGV(TAG, "write_state '%s': new value = %s type = %d address = %X offset = %x", this->get_name().c_str(), - ONOFF(state), (int) this->register_type, this->start_address, this->offset); + ESP_LOGV(TAG, "write_state '%s': new value = %s (wire = %s) type = %d address = %X offset = %x", + this->get_name().c_str(), ONOFF(state), ONOFF(write_value), (int) this->register_type, this->start_address, + this->offset); bool queued; if (this->register_type == EntityType::COIL) { // offset for coil and discrete inputs is the coil/register number not bytes if (this->use_write_multiple_) { - std::array states{state}; + std::array states{write_value}; queued = this->write_multiple_coils(this->write_address(), states); } else { - queued = this->write_single_coil(this->write_address(), state); + queued = this->write_single_coil(this->write_address(), write_value); } } else { if (this->use_write_multiple_) { - std::array states{static_cast(state ? (0xFFFF & this->bitmask) : 0)}; + std::array states{static_cast(write_value ? (0xFFFF & this->bitmask) : 0)}; queued = this->write_multiple_registers(this->write_address(), states); } else { - queued = this->write_single_register(this->write_address(), state ? 0xFFFF & this->bitmask : 0u); + queued = this->write_single_register(this->write_address(), write_value ? 0xFFFF & this->bitmask : 0u); } } if (!queued) { diff --git a/esphome/components/modbus_controller/switch/modbus_switch.h b/esphome/components/modbus_controller/switch/modbus_switch.h index 1d3d03919f..688a620bac 100644 --- a/esphome/components/modbus_controller/switch/modbus_switch.h +++ b/esphome/components/modbus_controller/switch/modbus_switch.h @@ -11,18 +11,22 @@ namespace esphome::modbus_controller { class ModbusSwitch final : public Component, public switch_::Switch, public SensorItem, public WriterEntity { public: ModbusSwitch(modbus::EntityType register_type, uint16_t start_address, uint8_t offset, uint32_t bitmask, - bool force_new_range) { + RangeReuse reuse_previous_range) { this->register_type = register_type; this->set_address(start_address); this->set_offset_from_start_address(offset); this->bitmask = bitmask; this->sensor_value_type = SensorValueType::BIT; - this->register_count = 1; - if (register_type == modbus::EntityType::HOLDING || register_type == modbus::EntityType::COIL) { - this->set_address(this->start_address + offset); + // A holding byte offset folds into the address as whole registers (odd offsets are rejected at + // validation: a 16-bit register write cannot target half a register); a coil offset is a coil count. + if (register_type == modbus::EntityType::HOLDING) { + this->set_address(start_address + offset / 2); + this->set_offset_from_start_address(0); + } else if (register_type == modbus::EntityType::COIL) { + this->set_address(start_address + offset); this->set_offset_from_start_address(0); } - this->force_new_range = force_new_range; + this->reuse_previous_range = reuse_previous_range; }; void setup() override; void write_state(bool state) override; diff --git a/esphome/components/modbus_controller/text_sensor/__init__.py b/esphome/components/modbus_controller/text_sensor/__init__.py index 31f5f87a98..7ab77700ca 100644 --- a/esphome/components/modbus_controller/text_sensor/__init__.py +++ b/esphome/components/modbus_controller/text_sensor/__init__.py @@ -5,6 +5,7 @@ import esphome.config_validation as cv from esphome.const import CONF_ADDRESS, CONF_ID from .. import ( + RANGE_REUSE, ModbusItemBaseSchema, SensorItem, add_modbus_base_properties, @@ -12,14 +13,14 @@ from .. import ( modbus_controller_ns, validate_custom_pdu_item, validate_modbus_register, + validate_range_reuse_migration, ) from ..const import ( - CONF_FORCE_NEW_RANGE, CONF_MODBUS_CONTROLLER_ID, CONF_RAW_ENCODE, - CONF_REGISTER_COUNT, CONF_REGISTER_TYPE, CONF_RESPONSE_SIZE, + CONF_REUSE_PREVIOUS_RANGE, ) DEPENDENCIES = ["modbus_controller"] @@ -47,32 +48,27 @@ CONFIG_SCHEMA = cv.All( { cv.GenerateID(): cv.declare_id(ModbusTextSensor), cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE), - cv.Optional(CONF_REGISTER_COUNT, default=0): cv.positive_int, - cv.Optional(CONF_RESPONSE_SIZE, default=2): cv.positive_int, + cv.Optional(CONF_RESPONSE_SIZE, default=2): cv.int_range(min=1, max=250), cv.Optional(CONF_RAW_ENCODE, default="ANSI"): cv.enum(RAW_ENCODING), } ), validate_modbus_register, + validate_range_reuse_migration, ) FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item async def to_code(config): - byte_offset, reg_count = modbus_calc_properties(config) - response_size = config[CONF_RESPONSE_SIZE] - reg_count = config[CONF_REGISTER_COUNT] - if reg_count == 0: - reg_count = response_size // 2 + byte_offset = modbus_calc_properties(config) var = cg.new_Pvariable( config[CONF_ID], config[CONF_REGISTER_TYPE], config[CONF_ADDRESS], byte_offset, - reg_count, config[CONF_RESPONSE_SIZE], config[CONF_RAW_ENCODE], - config[CONF_FORCE_NEW_RANGE], + RANGE_REUSE[config[CONF_REUSE_PREVIOUS_RANGE]], ) await cg.register_component(var, config) diff --git a/esphome/components/modbus_controller/text_sensor/modbus_textsensor.h b/esphome/components/modbus_controller/text_sensor/modbus_textsensor.h index 9e8dce57e7..6657967786 100644 --- a/esphome/components/modbus_controller/text_sensor/modbus_textsensor.h +++ b/esphome/components/modbus_controller/text_sensor/modbus_textsensor.h @@ -12,17 +12,16 @@ enum class RawEncoding { NONE = 0, HEXBYTES = 1, COMMA = 2, ANSI = 3 }; class ModbusTextSensor final : public Component, public text_sensor::TextSensor, public SensorItem { public: - ModbusTextSensor(modbus::EntityType register_type, uint16_t start_address, uint8_t offset, uint8_t register_count, - uint16_t response_bytes, RawEncoding encode, bool force_new_range) { + ModbusTextSensor(modbus::EntityType register_type, uint16_t start_address, uint8_t offset, uint16_t response_bytes, + RawEncoding encode, RangeReuse reuse_previous_range) { this->register_type = register_type; this->set_address(start_address); this->set_offset_from_start_address(offset); this->response_bytes = response_bytes; - this->register_count = register_count; this->encode_ = encode; this->bitmask = 0xFFFFFFFF; this->sensor_value_type = SensorValueType::RAW; - this->force_new_range = force_new_range; + this->reuse_previous_range = reuse_previous_range; } void dump_config() override; diff --git a/esphome/components/modbus_server/modbus_server.cpp b/esphome/components/modbus_server/modbus_server.cpp index feb0e67725..65bf4ef2f4 100644 --- a/esphome/components/modbus_server/modbus_server.cpp +++ b/esphome/components/modbus_server/modbus_server.cpp @@ -269,7 +269,8 @@ void ModbusServer::dump_config() { " Enabled: %s\n" " Register Last Address: 0x%02X\n" " Register Value: %" PRIu16, - this->address_, this->server_courtesy_response_.enabled ? "true" : "false", + this->address_, + this->server_courtesy_response_.enabled ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false"), this->server_courtesy_response_.register_last_address, this->server_courtesy_response_.register_value); #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE @@ -280,8 +281,9 @@ void ModbusServer::dump_config() { } ESP_LOGCONFIG(TAG, "server bits"); for (auto &b : this->server_bits_) { - ESP_LOGCONFIG(TAG, " Address=0x%04X readable=%s writable=%s", b->address, b->read_lambda ? "true" : "false", - b->write_lambda ? "true" : "false"); + ESP_LOGCONFIG(TAG, " Address=0x%04X readable=%s writable=%s", b->address, + b->read_lambda ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false"), + b->write_lambda ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false")); } #endif } diff --git a/esphome/components/mqtt/mqtt_client.cpp b/esphome/components/mqtt/mqtt_client.cpp index 1127c36dc6..2ecab47904 100644 --- a/esphome/components/mqtt/mqtt_client.cpp +++ b/esphome/components/mqtt/mqtt_client.cpp @@ -41,7 +41,11 @@ MQTTClientComponent::MQTTClientComponent() { global_mqtt_client = this; char mac_addr[MAC_ADDRESS_BUFFER_SIZE]; get_mac_address_into_buffer(mac_addr); - this->credentials_.client_id = make_name_with_suffix(App.get_name(), '-', mac_addr, MAC_ADDRESS_BUFFER_SIZE - 1); + const StringRef &name = App.get_name(); + char client_id[MAX_NAME_WITH_SUFFIX_SIZE]; + size_t len = make_name_with_suffix_to(client_id, sizeof(client_id), name.c_str(), name.size(), '-', mac_addr, + MAC_ADDRESS_BUFFER_SIZE - 1); + this->credentials_.client_id.assign(client_id, len); } // Connection diff --git a/esphome/components/mqtt/mqtt_component.cpp b/esphome/components/mqtt/mqtt_component.cpp index 18a759725f..a80cea6bd6 100644 --- a/esphome/components/mqtt/mqtt_component.cpp +++ b/esphome/components/mqtt/mqtt_component.cpp @@ -39,10 +39,12 @@ inline char *append_char(char *p, char c) { // Function implementation of LOG_MQTT_COMPONENT macro to reduce code size void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic) { char buf[MQTT_DEFAULT_TOPIC_MAX_LEN]; - if (state_topic) + if (state_topic) { ESP_LOGCONFIG(tag, " State Topic: '%s'", obj->get_state_topic_to_(buf).c_str()); - if (command_topic) + } + if (command_topic) { ESP_LOGCONFIG(tag, " Command Topic: '%s'", obj->get_command_topic_to_(buf).c_str()); + } } void MQTTComponent::set_qos(uint8_t qos) { this->qos_ = qos; } diff --git a/esphome/components/network/ip_address.h b/esphome/components/network/ip_address.h index f7aa7daf99..28f83cc4fa 100644 --- a/esphome/components/network/ip_address.h +++ b/esphome/components/network/ip_address.h @@ -188,6 +188,8 @@ struct IPAddress { } IPAddress(const std::string &in_address) { inet_aton(in_address.c_str(), &ip_addr_); } IPAddress(const ip_addr_t *other_ip) { ip_addr_ = *other_ip; } + bool is_ip4() const { return true; } + bool is_ip6() const { return false; } /// Write IP address to buffer. Buffer must be at least IP_ADDRESS_BUFFER_SIZE bytes. char *str_to(char *buf) const { inet_ntop(AF_INET, &ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE); diff --git a/esphome/components/nextion/nextion.cpp b/esphome/components/nextion/nextion.cpp index bdc66adb70..97910ba3d5 100644 --- a/esphome/components/nextion/nextion.cpp +++ b/esphome/components/nextion/nextion.cpp @@ -595,7 +595,8 @@ void Nextion::process_nextion_commands_() { uint8_t page_id = to_process[0]; uint8_t component_id = to_process[1]; uint8_t touch_event = to_process[2]; // 0 -> release, 1 -> press - ESP_LOGV(TAG, "Touch %s: page %u comp %u", touch_event ? "PRESS" : "RELEASE", page_id, component_id); + ESP_LOGV(TAG, "Touch %s: page %u comp %u", touch_event ? LOG_STR_LITERAL("PRESS") : LOG_STR_LITERAL("RELEASE"), + page_id, component_id); for (auto *touch : this->touch_) { touch->process_touch(page_id, component_id, touch_event != 0); } @@ -628,7 +629,7 @@ void Nextion::process_nextion_commands_() { const uint16_t x = (uint16_t(to_process[0]) << 8) | to_process[1]; const uint16_t y = (uint16_t(to_process[2]) << 8) | to_process[3]; const uint8_t touch_event = to_process[4]; // 0 -> release, 1 -> press - ESP_LOGV(TAG, "Touch %s at %u,%u", touch_event ? "PRESS" : "RELEASE", x, y); + ESP_LOGV(TAG, "Touch %s at %u,%u", touch_event ? LOG_STR_LITERAL("PRESS") : LOG_STR_LITERAL("RELEASE"), x, y); break; } diff --git a/esphome/components/noise/__init__.py b/esphome/components/noise/__init__.py index 3a8e2609ef..0f9328a482 100644 --- a/esphome/components/noise/__init__.py +++ b/esphome/components/noise/__init__.py @@ -45,6 +45,15 @@ def decode_encryption_key(value: str) -> bytes: return decoded +def is_reserved_key(value: str) -> bool: + """Whether the key is the reserved all-zeros provisioning sentinel. + + The device treats it as no key configured, so consumers that require a + real key must reject it. + """ + return not any(decode_encryption_key(value)) + + ENCRYPTION_SCHEMA = cv.Schema( { cv.Optional(CONF_KEY): cv.sensitive(validate_encryption_key), diff --git a/esphome/components/one_wire/one_wire_bus.cpp b/esphome/components/one_wire/one_wire_bus.cpp index c7ea59050c..b62e4f47d4 100644 --- a/esphome/components/one_wire/one_wire_bus.cpp +++ b/esphome/components/one_wire/one_wire_bus.cpp @@ -18,8 +18,9 @@ const std::vector &OneWireBus::get_devices() { return this->devices_; bool OneWireBus::reset_() { int res = this->reset_int(); - if (res == -1) + if (res == -1) { ESP_LOGE(TAG, "1-wire bus is held low"); + } return res == 1; } diff --git a/esphome/components/openthread/openthread.cpp b/esphome/components/openthread/openthread.cpp index 8bfc16b2e0..b98f109172 100644 --- a/esphome/components/openthread/openthread.cpp +++ b/esphome/components/openthread/openthread.cpp @@ -4,6 +4,7 @@ #include #include +#include #include #include #include @@ -229,26 +230,43 @@ void *OpenThreadSrpComponent::pool_alloc_(size_t size) { void OpenThreadSrpComponent::set_mdns(esphome::mdns::MDNSComponent *mdns) { this->mdns_ = mdns; } bool OpenThreadComponent::teardown() { - if (!this->teardown_started_) { - this->teardown_started_ = true; - ESP_LOGD(TAG, "Clear Srp"); - auto lock = InstanceLock::try_acquire(100); - if (!lock) { - ESP_LOGW(TAG, "Failed to acquire OpenThread lock during teardown, leaking memory"); - return true; - } - otInstance *instance = lock.get_instance(); - otSrpClientClearHostAndServices(instance); - otSrpClientBuffersFreeAllServices(instance); - global_openthread_component = nullptr; - ESP_LOGD(TAG, "Exit main loop "); - int error = this->openthread_stop_(); - if (error != 0) { - ESP_LOGW(TAG, "Failed attempt to stop main loop %d", error); - this->teardown_complete_ = true; - } + switch (this->teardown_stage_) { + case TeardownStage::TEARDOWN_STAGE_NOT_STARTED: { + auto lock = InstanceLock::try_acquire(100); + if (!lock) { + // Try again on next teardown loop + ESP_LOGV(TAG, "Failed to acquire OpenThread lock during teardown"); + return false; + } + // Start tearing down + this->teardown_stage_ = TeardownStage::TEARDOWN_STAGE_STOP_IN_PROCESS; + ESP_LOGV(TAG, "Clear SRP"); + otInstance *instance = lock.get_instance(); + otSrpClientClearHostAndServices(instance); + otSrpClientBuffersFreeAllServices(instance); + if (otThreadSetEnabled(instance, false) != OT_ERROR_NONE) { + ESP_LOGW(TAG, "Failed to disable Thread during teardown"); + } + if (otIp6SetEnabled(instance, false) != OT_ERROR_NONE) { + ESP_LOGW(TAG, "Failed to disable IPv6 during teardown"); + } + // Stop OpenThread + global_openthread_component = nullptr; + ESP_LOGV(TAG, "Stop OpenThread"); + int error = this->openthread_stop_(); + if (error != 0) { + ESP_LOGW(TAG, "Failed attempt to stop OpenThread %d", error); + this->teardown_stage_ = TeardownStage::TEARDOWN_STAGE_COMPLETED; + } + } break; + case TeardownStage::TEARDOWN_STAGE_STOP_IN_PROCESS: + // Waiting on OpenThread stop + break; + case TeardownStage::TEARDOWN_STAGE_COMPLETED: + ESP_LOGV(TAG, "OpenThreadComponent Teardown Complete"); + break; } - return this->teardown_complete_; + return this->teardown_stage_ == TeardownStage::TEARDOWN_STAGE_COMPLETED; } void OpenThreadComponent::on_factory_reset(std::function callback) { diff --git a/esphome/components/openthread/openthread.h b/esphome/components/openthread/openthread.h index b4654af21f..f4c6d0962a 100644 --- a/esphome/components/openthread/openthread.h +++ b/esphome/components/openthread/openthread.h @@ -19,6 +19,12 @@ namespace esphome::openthread { class InstanceLock; +enum class TeardownStage : uint8_t { + TEARDOWN_STAGE_NOT_STARTED = 0, + TEARDOWN_STAGE_STOP_IN_PROCESS, + TEARDOWN_STAGE_COMPLETED, +}; + template class OpenThreadComponentPollPeriodAction; class OpenThreadComponent final : public Component { @@ -71,9 +77,8 @@ class OpenThreadComponent final : public Component { #endif std::optional output_power_{}; std::atomic lock_initialized_{false}; - bool teardown_started_{false}; - bool teardown_complete_{false}; - bool connected_{false}; + std::atomic teardown_stage_{TeardownStage::TEARDOWN_STAGE_NOT_STARTED}; + std::atomic connected_{false}; private: // Stores a pointer to a string literal (static storage duration). diff --git a/esphome/components/openthread/openthread_esp.cpp b/esphome/components/openthread/openthread_esp.cpp index 4f6e618f49..881bbea3c9 100644 --- a/esphome/components/openthread/openthread_esp.cpp +++ b/esphome/components/openthread/openthread_esp.cpp @@ -168,7 +168,7 @@ void OpenThreadComponent::ot_main() { esp_netif_destroy(openthread_netif); esp_vfs_eventfd_unregister(); - this->teardown_complete_ = true; + this->teardown_stage_ = TeardownStage::TEARDOWN_STAGE_COMPLETED; vTaskDelete(NULL); } diff --git a/esphome/components/openthread/openthread_zephyr.cpp b/esphome/components/openthread/openthread_zephyr.cpp index 7b9f14ab8c..cacb4c0122 100644 --- a/esphome/components/openthread/openthread_zephyr.cpp +++ b/esphome/components/openthread/openthread_zephyr.cpp @@ -90,10 +90,8 @@ void OpenThreadComponent::ot_main() {} otInstance *OpenThreadComponent::get_openthread_instance_() { return openthread_get_default_instance(); } int OpenThreadComponent::openthread_stop_() { - // OT stack is intentionally left running — no Zephyr stop API. The state callback stays - // registered but is safe (null-checks global_openthread_component). nRF52840 never - // re-enters setup() after teardown so this is functionally correct. - this->teardown_complete_ = true; + // Zephyr has no stack-stop API, so stop is synchronous here; mark complete immediately. + this->teardown_stage_ = TeardownStage::TEARDOWN_STAGE_COMPLETED; return 0; } diff --git a/esphome/components/ota/ota_backend.h b/esphome/components/ota/ota_backend.h index 1c24fc320a..7348a0ce90 100644 --- a/esphome/components/ota/ota_backend.h +++ b/esphome/components/ota/ota_backend.h @@ -49,6 +49,7 @@ enum OTAResponseTypes { OTA_RESPONSE_ERROR_BOOTLOADER_VERIFY = 0x91, OTA_RESPONSE_ERROR_BOOTLOADER_UPDATE = 0x92, OTA_RESPONSE_ERROR_VERSION_DOWNGRADE = 0x93, + OTA_RESPONSE_ERROR_ENCRYPTION_REQUIRED = 0x94, OTA_RESPONSE_ERROR_UNKNOWN = 0xFF, }; diff --git a/esphome/components/packet_transport/packet_transport.cpp b/esphome/components/packet_transport/packet_transport.cpp index a21f0e2f63..998e1be5fc 100644 --- a/esphome/components/packet_transport/packet_transport.cpp +++ b/esphome/components/packet_transport/packet_transport.cpp @@ -551,12 +551,14 @@ void PacketTransport::dump_config() { " Ping-pong: %s", this->platform_name_, YESNO(this->is_encrypted_()), YESNO(this->ping_pong_enable_)); #ifdef USE_SENSOR - for (const auto &sensor : this->sensors_) + for (const auto &sensor : this->sensors_) { ESP_LOGCONFIG(TAG, " Sensor: %s", sensor.id); + } #endif #ifdef USE_BINARY_SENSOR - for (const auto &sensor : this->binary_sensors_) + for (const auto &sensor : this->binary_sensors_) { ESP_LOGCONFIG(TAG, " Binary Sensor: %s", sensor.id); + } #endif for (const auto &host : this->providers_) { ESP_LOGCONFIG(TAG, " Remote host: %s", host.first.c_str()); @@ -564,15 +566,17 @@ void PacketTransport::dump_config() { #ifdef USE_SENSOR auto rs = this->remote_sensors_.find(host.first.c_str()); if (rs != this->remote_sensors_.end()) { - for (const auto &key : rs->second | std::views::keys) + for (const auto &key : rs->second | std::views::keys) { ESP_LOGCONFIG(TAG, " Sensor: %s", key.c_str()); + } } #endif #ifdef USE_BINARY_SENSOR auto rbs = this->remote_binary_sensors_.find(host.first.c_str()); if (rbs != this->remote_binary_sensors_.end()) { - for (const auto &key : rbs->second | std::views::keys) + for (const auto &key : rbs->second | std::views::keys) { ESP_LOGCONFIG(TAG, " Binary Sensor: %s", key.c_str()); + } } #endif } diff --git a/esphome/components/pcm5122/pcm5122.cpp b/esphome/components/pcm5122/pcm5122.cpp index d178cb83b8..4f6417f6c0 100644 --- a/esphome/components/pcm5122/pcm5122.cpp +++ b/esphome/components/pcm5122/pcm5122.cpp @@ -119,7 +119,8 @@ void PCM5122::dump_config() { " Channel mix: %s\n" " Volume range: %.1f dB to %.1f dB\n" " Muted: %s", - this->bits_per_sample_, this->analog_gain_ == PCM5122_ANALOG_GAIN_0DB ? "0 dB" : "-6 dB", + this->bits_per_sample_, + this->analog_gain_ == PCM5122_ANALOG_GAIN_0DB ? LOG_STR_LITERAL("0 dB") : LOG_STR_LITERAL("-6 dB"), channel_mix_str, this->volume_min_db_, this->volume_max_db_, YESNO(this->is_muted_)); LOG_PIN(" Enable Pin: ", this->enable_pin_); } diff --git a/esphome/components/pn7150/pn7150.cpp b/esphome/components/pn7150/pn7150.cpp index 2a2724f56b..4e679c664a 100644 --- a/esphome/components/pn7150/pn7150.cpp +++ b/esphome/components/pn7150/pn7150.cpp @@ -243,8 +243,8 @@ uint8_t PN7150::reset_core_(const bool reset_config, const bool power) { } ESP_LOGD(TAG, "Configuration %s, NCI version: %s", - rx.get_message()[nfc::NCI_PKT_PAYLOAD_OFFSET + 2] ? "reset" : "retained", - rx.get_message()[nfc::NCI_PKT_PAYLOAD_OFFSET + 1] == 0x20 ? "2.0" : "1.0"); + rx.get_message()[nfc::NCI_PKT_PAYLOAD_OFFSET + 2] ? LOG_STR_LITERAL("reset") : LOG_STR_LITERAL("retained"), + rx.get_message()[nfc::NCI_PKT_PAYLOAD_OFFSET + 1] == 0x20 ? LOG_STR_LITERAL("2.0") : LOG_STR_LITERAL("1.0")); return nfc::STATUS_OK; } diff --git a/esphome/components/pn7160/pn7160.cpp b/esphome/components/pn7160/pn7160.cpp index 7abd89b371..f2cbfa6bcf 100644 --- a/esphome/components/pn7160/pn7160.cpp +++ b/esphome/components/pn7160/pn7160.cpp @@ -265,8 +265,8 @@ uint8_t PN7160::reset_core_(const bool reset_config, const bool power) { } ESP_LOGD(TAG, "Configuration %s, NCI version: %s, Manufacturer ID: 0x%02X", - rx.get_message()[4] ? "reset" : "retained", rx.get_message()[5] == 0x20 ? "2.0" : "1.0", - rx.get_message()[6]); + rx.get_message()[4] ? LOG_STR_LITERAL("reset") : LOG_STR_LITERAL("retained"), + rx.get_message()[5] == 0x20 ? LOG_STR_LITERAL("2.0") : LOG_STR_LITERAL("1.0"), rx.get_message()[6]); rx.get_message().erase(rx.get_message().begin(), rx.get_message().begin() + 8); char mfr_buf[nfc::FORMAT_BYTES_BUFFER_SIZE]; ESP_LOGD(TAG, "Manufacturer info: %s", nfc::format_bytes_to(mfr_buf, rx.get_message())); diff --git a/esphome/components/provisioning/__init__.py b/esphome/components/provisioning/__init__.py index 9462bbb3b7..63faaf8eae 100644 --- a/esphome/components/provisioning/__init__.py +++ b/esphome/components/provisioning/__init__.py @@ -23,6 +23,8 @@ class ProvisioningData: sources: set[str] = field(default_factory=set) # Names of source components that have their credentials set in the config. hardcoded_credentials: set[str] = field(default_factory=set) + # True when WiFi is configured with an access point but no station credentials. + ap_without_sta: bool = False def _get_data() -> ProvisioningData: @@ -56,6 +58,17 @@ def report_hardcoded_credentials(name: str) -> None: _get_data().hardcoded_credentials.add(name) +def report_ap_without_sta() -> None: + """Record that WiFi runs an access point with no station credentials. + + The access point (and captive portal) shut down when the provisioning window + closes. On a device where that access point is the only network connection, + closing the window makes the device unreachable until it is power-cycled, so + `provisioning:` warns about this combination. + """ + _get_data().ap_without_sta = True + + CONFIG_SCHEMA = cv.Schema( { cv.GenerateID(): cv.declare_id(ProvisioningManager), @@ -89,6 +102,13 @@ def _final_validate(config: ConfigType) -> None: "hardcoding them makes the window pointless.", ", ".join(sorted(data.hardcoded_credentials)), ) + if data.ap_without_sta: + _LOGGER.warning( + "'provisioning' is configured with a WiFi access point and no station " + "credentials. The access point shuts down when the provisioning window " + "closes, so if it is the device's only network connection, the device " + "will be unreachable until it is power-cycled." + ) FINAL_VALIDATE_SCHEMA = _final_validate diff --git a/esphome/components/pylontech/pylontech.cpp b/esphome/components/pylontech/pylontech.cpp index 0973699da8..54d9e5c654 100644 --- a/esphome/components/pylontech/pylontech.cpp +++ b/esphome/components/pylontech/pylontech.cpp @@ -137,7 +137,8 @@ void PylontechComponent::process_line_(std::string &buffer) { } else if (strcmp(token_buf, "Power") == 0) { // header line i.e. "Power Volt Curr" and so on this->has_tlow_id_ = buffer.find("Tlow.Id") != std::string::npos; - ESP_LOGD(TAG, "header line %s Tlow.Id: %s", this->has_tlow_id_ ? "with" : "without", + ESP_LOGD(TAG, "header line %s Tlow.Id: %s", + this->has_tlow_id_ ? LOG_STR_LITERAL("with") : LOG_STR_LITERAL("without"), buffer.substr(0, buffer.size() - 2).c_str()); return; } else { diff --git a/esphome/components/pzemac/pzemac.cpp b/esphome/components/pzemac/pzemac.cpp index d817888922..409de91124 100644 --- a/esphome/components/pzemac/pzemac.cpp +++ b/esphome/components/pzemac/pzemac.cpp @@ -3,62 +3,64 @@ namespace esphome::pzemac { +namespace helpers = modbus::helpers; + static const char *const TAG = "pzemac"; static const uint8_t PZEM_CMD_RESET_ENERGY = 0x42; static const uint8_t PZEM_REGISTER_COUNT = 10; // 10x 16-bit registers -void PZEMAC::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - if (data.size() < 20) { - ESP_LOGW(TAG, "Invalid size for PZEM AC!"); +// Register map, see https://github.com/esphome/feature-requests/issues/49#issuecomment-538636809 +// 32-bit values are two registers, low word first. +static const uint16_t PZEM_REGISTER_VOLTAGE = 0; // 1 register, 0.1 V +static const uint16_t PZEM_REGISTER_CURRENT = 1; // 2 registers, 0.001 A +static const uint16_t PZEM_REGISTER_ACTIVE_POWER = 3; // 2 registers, 0.1 W +static const uint16_t PZEM_REGISTER_ACTIVE_ENERGY = 5; // 2 registers, 1 Wh +static const uint16_t PZEM_REGISTER_FREQUENCY = 7; // 1 register, 0.1 Hz +static const uint16_t PZEM_REGISTER_POWER_FACTOR = 8; // 1 register, 0.01 + +void PZEMAC::on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status)) + return; // the hub already logs exception responses + + // Publish a sensor if its register(s) are in this response; skipping absent registers keeps this + // correct for any read range, so the poll may be split into multiple requests. + auto publish_1_register = [&](sensor::Sensor *sensor, uint16_t reg, float divisor) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value / divisor); + }; + + auto publish_2_registers = [&](sensor::Sensor *sensor, uint16_t reg, float divisor) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value / divisor); + }; + + publish_1_register(this->voltage_sensor_, PZEM_REGISTER_VOLTAGE, 10.0f); + publish_2_registers(this->current_sensor_, PZEM_REGISTER_CURRENT, 1000.0f); + publish_2_registers(this->power_sensor_, PZEM_REGISTER_ACTIVE_POWER, 10.0f); + publish_2_registers(this->energy_sensor_, PZEM_REGISTER_ACTIVE_ENERGY, 1.0f); + publish_1_register(this->frequency_sensor_, PZEM_REGISTER_FREQUENCY, 10.0f); + publish_1_register(this->power_factor_sensor_, PZEM_REGISTER_POWER_FACTOR, 100.0f); +} + +void PZEMAC::on_custom_response(std::span request_pdu, std::span response_pdu, + modbus::ResponseStatus status) { + // The only custom request this component sends is the energy reset; acknowledge its echo here so + // the default unhandled-response warning stays meaningful. + if (!request_pdu.empty() && request_pdu[0] == PZEM_CMD_RESET_ENERGY) { + if (modbus::succeeded(status)) { + ESP_LOGD(TAG, "Energy reset acknowledged"); + } else { + ESP_LOGW(TAG, "Energy reset rejected"); + } return; } - - // See https://github.com/esphome/feature-requests/issues/49#issuecomment-538636809 - // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 - // 01 04 14 08 D1 00 6C 00 00 00 F4 00 00 00 26 00 00 01 F4 00 64 00 00 51 34 - // Id Cc Sz Volt- Current---- Power------ Energy----- Frequ PFact Alarm Crc-- - // 0 2 6 10 14 16 - - auto pzem_get_16bit = [&](size_t i) -> uint16_t { - return (uint16_t(data[i + 0]) << 8) | (uint16_t(data[i + 1]) << 0); - }; - auto pzem_get_32bit = [&](size_t i) -> uint32_t { - return (uint32_t(pzem_get_16bit(i + 2)) << 16) | (uint32_t(pzem_get_16bit(i + 0)) << 0); - }; - - uint16_t raw_voltage = pzem_get_16bit(0); - float voltage = raw_voltage / 10.0f; // max 6553.5 V - - uint32_t raw_current = pzem_get_32bit(2); - float current = raw_current / 1000.0f; // max 4294967.295 A - - uint32_t raw_active_power = pzem_get_32bit(6); - float active_power = raw_active_power / 10.0f; // max 429496729.5 W - - float active_energy = static_cast(pzem_get_32bit(10)); - - uint16_t raw_frequency = pzem_get_16bit(14); - float frequency = raw_frequency / 10.0f; - - uint16_t raw_power_factor = pzem_get_16bit(16); - float power_factor = raw_power_factor / 100.0f; - - ESP_LOGD(TAG, "PZEM AC: V=%.1f V, I=%.3f A, P=%.1f W, E=%.1f Wh, F=%.1f Hz, PF=%.2f", voltage, current, active_power, - active_energy, frequency, power_factor); - if (this->voltage_sensor_ != nullptr) - this->voltage_sensor_->publish_state(voltage); - if (this->current_sensor_ != nullptr) - this->current_sensor_->publish_state(current); - if (this->power_sensor_ != nullptr) - this->power_sensor_->publish_state(active_power); - if (this->energy_sensor_ != nullptr) - this->energy_sensor_->publish_state(active_energy); - if (this->frequency_sensor_ != nullptr) - this->frequency_sensor_->publish_state(frequency); - if (this->power_factor_sensor_ != nullptr) - this->power_factor_sensor_->publish_state(power_factor); + modbus::ModbusClientDevice::on_custom_response(request_pdu, response_pdu, status); } void PZEMAC::update() { this->read_input_registers(0, PZEM_REGISTER_COUNT); } diff --git a/esphome/components/pzemac/pzemac.h b/esphome/components/pzemac/pzemac.h index 171212d3ee..723b21e0b0 100644 --- a/esphome/components/pzemac/pzemac.h +++ b/esphome/components/pzemac/pzemac.h @@ -22,7 +22,10 @@ class PZEMAC final : public PollingComponent, public modbus::ModbusClientDevice void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; + void on_custom_response(std::span request_pdu, std::span response_pdu, + modbus::ResponseStatus status) override; void dump_config() override; diff --git a/esphome/components/pzemdc/pzemdc.cpp b/esphome/components/pzemdc/pzemdc.cpp index 926ad83f09..eb9a355806 100644 --- a/esphome/components/pzemdc/pzemdc.cpp +++ b/esphome/components/pzemdc/pzemdc.cpp @@ -3,55 +3,63 @@ namespace esphome::pzemdc { +namespace helpers = modbus::helpers; + static const char *const TAG = "pzemdc"; static const uint8_t PZEM_CMD_RESET_ENERGY = 0x42; -static const uint8_t PZEM_REGISTER_COUNT = 10; // 10x 16-bit registers +static const uint8_t PZEM_REGISTER_COUNT = 8; // 8x 16-bit registers -void PZEMDC::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - if (data.size() < 16) { - ESP_LOGW(TAG, "Invalid size for PZEM DC!"); - return; - } +// Register map, see https://github.com/esphome/feature-requests/issues/49#issuecomment-538636809 +// 32-bit values are two registers, low word first. +static const uint16_t PZEM_REGISTER_VOLTAGE = 0; // 1 register, 0.01 V +static const uint16_t PZEM_REGISTER_CURRENT = 1; // 1 register, 0.01 A +static const uint16_t PZEM_REGISTER_POWER = 2; // 2 registers, 0.1 W +static const uint16_t PZEM_REGISTER_ENERGY = 4; // 2 registers, 1 Wh - // See https://github.com/esphome/feature-requests/issues/49#issuecomment-538636809 - // 0 1 2 3 4 5 6 7 = ModBus register - // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 = Buffer index - // 01 04 10 05 40 00 0A 00 0D 00 00 00 02 00 00 00 00 00 00 D6 29 - // Id Cc Sz Volt- Curre Power------ Energy----- HiAlm LoAlm Crc-- +void PZEMDC::on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status)) + return; // the hub already logs exception responses - auto pzem_get_16bit = [&](size_t i) -> uint16_t { - return (uint16_t(data[i + 0]) << 8) | (uint16_t(data[i + 1]) << 0); - }; - auto pzem_get_32bit = [&](size_t i) -> uint32_t { - return (uint32_t(pzem_get_16bit(i + 2)) << 16) | (uint32_t(pzem_get_16bit(i + 0)) << 0); + // Publish a sensor if its register(s) are in this response; skipping absent registers keeps this + // correct for any read range, so the poll may be split into multiple requests. + auto publish_1_register = [&](sensor::Sensor *sensor, uint16_t reg, float divisor) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value / divisor); }; - uint16_t raw_voltage = pzem_get_16bit(0); - float voltage = raw_voltage / 100.0f; // max 655.35 V + auto publish_2_registers = [&](sensor::Sensor *sensor, uint16_t reg, float divisor) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value / divisor); + }; - uint16_t raw_current = pzem_get_16bit(2); - float current = raw_current / 100.0f; // max 655.35 A - - uint32_t raw_power = pzem_get_32bit(4); - float power = raw_power / 10.0f; // max 429496729.5 W - - uint32_t raw_energy = pzem_get_32bit(8); - float energy = raw_energy / 1000.0f; // max 4294967.295 kWh - - ESP_LOGD(TAG, "PZEM DC: V=%.1f V, I=%.3f A, P=%.1f W", voltage, current, power); - if (this->voltage_sensor_ != nullptr) - this->voltage_sensor_->publish_state(voltage); - if (this->current_sensor_ != nullptr) - this->current_sensor_->publish_state(current); - if (this->power_sensor_ != nullptr) - this->power_sensor_->publish_state(power); - if (this->energy_sensor_ != nullptr) - this->energy_sensor_->publish_state(energy); + publish_1_register(this->voltage_sensor_, PZEM_REGISTER_VOLTAGE, 100.0f); + publish_1_register(this->current_sensor_, PZEM_REGISTER_CURRENT, 100.0f); + publish_2_registers(this->power_sensor_, PZEM_REGISTER_POWER, 10.0f); + publish_2_registers(this->energy_sensor_, PZEM_REGISTER_ENERGY, 1000.0f); } -void PZEMDC::update() { this->read_input_registers(0, 8); } +void PZEMDC::on_custom_response(std::span request_pdu, std::span response_pdu, + modbus::ResponseStatus status) { + // The only custom request this component sends is the energy reset; acknowledge its echo here so + // the default unhandled-response warning stays meaningful. + if (!request_pdu.empty() && request_pdu[0] == PZEM_CMD_RESET_ENERGY) { + if (modbus::succeeded(status)) { + ESP_LOGD(TAG, "Energy reset acknowledged"); + } else { + ESP_LOGW(TAG, "Energy reset rejected"); + } + return; + } + modbus::ModbusClientDevice::on_custom_response(request_pdu, response_pdu, status); +} + +void PZEMDC::update() { this->read_input_registers(0, PZEM_REGISTER_COUNT); } void PZEMDC::dump_config() { ESP_LOGCONFIG(TAG, "PZEMDC:\n" diff --git a/esphome/components/pzemdc/pzemdc.h b/esphome/components/pzemdc/pzemdc.h index b7657608e6..69c8a9dd6c 100644 --- a/esphome/components/pzemdc/pzemdc.h +++ b/esphome/components/pzemdc/pzemdc.h @@ -18,7 +18,10 @@ class PZEMDC final : public PollingComponent, public modbus::ModbusClientDevice void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; + void on_custom_response(std::span request_pdu, std::span response_pdu, + modbus::ResponseStatus status) override; void dump_config() override; diff --git a/esphome/components/qwiic_pir/qwiic_pir.cpp b/esphome/components/qwiic_pir/qwiic_pir.cpp index baf8dc122d..eb338db772 100644 --- a/esphome/components/qwiic_pir/qwiic_pir.cpp +++ b/esphome/components/qwiic_pir/qwiic_pir.cpp @@ -124,8 +124,9 @@ void QwiicPIRComponent::dump_config() { void QwiicPIRComponent::clear_events_() { // Clear event status register - if (!this->write_byte(QWIIC_PIR_EVENT_STATUS, 0x00)) + if (!this->write_byte(QWIIC_PIR_EVENT_STATUS, 0x00)) { ESP_LOGW(TAG, "Failed to clear events"); + } } } // namespace esphome::qwiic_pir diff --git a/esphome/components/rd03d/rd03d.cpp b/esphome/components/rd03d/rd03d.cpp index 2eb76a1087..18328def9f 100644 --- a/esphome/components/rd03d/rd03d.cpp +++ b/esphome/components/rd03d/rd03d.cpp @@ -55,8 +55,9 @@ void RD03DComponent::setup() { void RD03DComponent::dump_config() { ESP_LOGCONFIG(TAG, "RD-03D:"); if (this->tracking_mode_.has_value()) { - ESP_LOGCONFIG(TAG, " Tracking Mode: %s", - *this->tracking_mode_ == TrackingMode::SINGLE_TARGET ? "single" : "multi"); + ESP_LOGCONFIG( + TAG, " Tracking Mode: %s", + *this->tracking_mode_ == TrackingMode::SINGLE_TARGET ? LOG_STR_LITERAL("single") : LOG_STR_LITERAL("multi")); } if (this->throttle_ > 0) { ESP_LOGCONFIG(TAG, " Throttle: %" PRIu32 "ms", this->throttle_); diff --git a/esphome/components/remote_receiver/remote_receiver.cpp b/esphome/components/remote_receiver/remote_receiver.cpp index 36152d8854..bbcb7ae765 100644 --- a/esphome/components/remote_receiver/remote_receiver.cpp +++ b/esphome/components/remote_receiver/remote_receiver.cpp @@ -76,15 +76,16 @@ void RemoteReceiverComponent::setup() { } void RemoteReceiverComponent::dump_config() { - ESP_LOGCONFIG(TAG, - "Remote Receiver:\n" - " Buffer Size: %" PRIu32 "\n" - " Tolerance: %" PRIu32 "%s\n" - " Filter out pulses shorter than: %" PRIu32 " us\n" - " Signal is done after %" PRIu32 " us of no changes", - this->buffer_size_, this->tolerance_, - (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? " us" : "%", this->filter_us_, - this->idle_us_); + ESP_LOGCONFIG( + TAG, + "Remote Receiver:\n" + " Buffer Size: %" PRIu32 "\n" + " Tolerance: %" PRIu32 "%s\n" + " Filter out pulses shorter than: %" PRIu32 " us\n" + " Signal is done after %" PRIu32 " us of no changes", + this->buffer_size_, this->tolerance_, + (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? LOG_STR_LITERAL(" us") : LOG_STR_LITERAL("%"), + this->filter_us_, this->idle_us_); LOG_PIN(" Pin: ", this->pin_); } diff --git a/esphome/components/resistance/resistance_sensor.cpp b/esphome/components/resistance/resistance_sensor.cpp index 6056509093..7522d026a4 100644 --- a/esphome/components/resistance/resistance_sensor.cpp +++ b/esphome/components/resistance/resistance_sensor.cpp @@ -11,8 +11,8 @@ void ResistanceSensor::dump_config() { " Configuration: %s\n" " Resistor: %.2fΩ\n" " Reference Voltage: %.1fV", - this->configuration_ == UPSTREAM ? "UPSTREAM" : "DOWNSTREAM", this->resistor_, - this->reference_voltage_); + this->configuration_ == UPSTREAM ? LOG_STR_LITERAL("UPSTREAM") : LOG_STR_LITERAL("DOWNSTREAM"), + this->resistor_, this->reference_voltage_); } void ResistanceSensor::process_(float value) { if (std::isnan(value)) { diff --git a/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp b/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp index aacb217965..c0afc0607e 100644 --- a/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp +++ b/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp @@ -75,8 +75,9 @@ void RpiDpiRgb::draw_pixels_at(int x_start, int y_start, int w, int h, const uin break; } } - if (err != ESP_OK) + if (err != ESP_OK) { ESP_LOGE(TAG, "lcd_lcd_panel_draw_bitmap failed: %s", esp_err_to_name(err)); + } } int RpiDpiRgb::get_width() { diff --git a/esphome/components/runtime_image/__init__.py b/esphome/components/runtime_image/__init__.py index a220503045..e27fcadbee 100644 --- a/esphome/components/runtime_image/__init__.py +++ b/esphome/components/runtime_image/__init__.py @@ -28,6 +28,7 @@ ImageDecoder = runtime_image_ns.class_("ImageDecoder") BmpDecoder = runtime_image_ns.class_("BmpDecoder", ImageDecoder) JpegDecoder = runtime_image_ns.class_("JpegDecoder", ImageDecoder) PngDecoder = runtime_image_ns.class_("PngDecoder", ImageDecoder) +QoiDecoder = runtime_image_ns.class_("QoiDecoder", ImageDecoder) # Runtime image class RuntimeImage = runtime_image_ns.class_( @@ -37,9 +38,10 @@ RuntimeImage = runtime_image_ns.class_( # Image format enum ImageFormat = runtime_image_ns.enum("ImageFormat") IMAGE_FORMAT_AUTO = ImageFormat.AUTO +IMAGE_FORMAT_BMP = ImageFormat.BMP IMAGE_FORMAT_JPEG = ImageFormat.JPEG IMAGE_FORMAT_PNG = ImageFormat.PNG -IMAGE_FORMAT_BMP = ImageFormat.BMP +IMAGE_FORMAT_QOI = ImageFormat.QOI # Export enum for decode errors DecodeError = runtime_image_ns.enum("DecodeError") @@ -115,14 +117,27 @@ class PNGFormat(Format): cg.add_library("pngle", "1.1.0") +class QOIFormat(Format): + """QOI format decoder configuration.""" + + def __init__(self): + super().__init__("QOI", QoiDecoder) + + def actions(self) -> None: + cg.add_define("USE_RUNTIME_IMAGE_QOI") + + # Decodable formats only; platforms that support runtime detection accept # "AUTO" in their own schema and get_format() resolves it _JPEG_FORMAT = JPEGFormat() + +# Registry of available formats IMAGE_FORMATS = { "BMP": BMPFormat(), "JPEG": _JPEG_FORMAT, "JPG": _JPEG_FORMAT, # Alias for JPEG "PNG": PNGFormat(), + "QOI": QOIFormat(), } FILTER_SOURCE_FILES = filter_source_files_from_defines( diff --git a/esphome/components/runtime_image/image_format.cpp b/esphome/components/runtime_image/image_format.cpp index 9575b30887..9db8490415 100644 --- a/esphome/components/runtime_image/image_format.cpp +++ b/esphome/components/runtime_image/image_format.cpp @@ -21,6 +21,9 @@ static constexpr MimeLookup MIME_LOOKUP_TABLE[] = { #ifdef USE_RUNTIME_IMAGE_PNG {"image/png", ImageFormat::PNG}, {"image/x-png", ImageFormat::PNG}, #endif +#ifdef USE_RUNTIME_IMAGE_QOI + {"image/qoi", ImageFormat::QOI}, {"image/x-qoi", ImageFormat::QOI}, +#endif }; const char *get_mime_type_for_format(ImageFormat format) { diff --git a/esphome/components/runtime_image/image_format.h b/esphome/components/runtime_image/image_format.h index aff0c026b9..72bd81a06e 100644 --- a/esphome/components/runtime_image/image_format.h +++ b/esphome/components/runtime_image/image_format.h @@ -11,12 +11,14 @@ enum ImageFormat { /** Format is supplied per decode, e.g. detected from the Content-Type header * by online_image; sniffing the image data is not implemented. */ AUTO, + /** BMP format. */ + BMP, /** JPEG format. */ JPEG, /** PNG format. */ PNG, - /** BMP format. */ - BMP, + /** QOI format. */ + QOI, }; /// Canonical MIME type for a format; "image/*" for AUTO/unknown diff --git a/esphome/components/runtime_image/qoi_decoder.cpp b/esphome/components/runtime_image/qoi_decoder.cpp new file mode 100644 index 0000000000..b0fabb5233 --- /dev/null +++ b/esphome/components/runtime_image/qoi_decoder.cpp @@ -0,0 +1,174 @@ +#include "qoi_decoder.h" + +#ifdef USE_RUNTIME_IMAGE_QOI + +#include "esphome/components/display/display.h" +#include "esphome/core/helpers.h" +#include "esphome/core/log.h" + +#include + +namespace esphome::runtime_image { + +static const char *const TAG = "image_decoder.qoi"; + +constexpr uint8_t QOI_OP_RGB = 0b11111110; +constexpr uint8_t QOI_OP_RGBA = 0b11111111; +constexpr uint8_t QOI_OP_INDEX = 0b00000000; // 00xxxxxx +constexpr uint8_t QOI_OP_DIFF = 0b01000000; // 01xxxxxx +constexpr uint8_t QOI_OP_LUMA = 0b10000000; // 10xxxxxx +constexpr uint8_t QOI_OP_RUN = 0b11000000; // 11xxxxxx + +constexpr uint8_t QOI_RGB_CHUNK_SIZE = 4; +constexpr uint8_t QOI_RGBA_CHUNK_SIZE = 5; +constexpr uint8_t QOI_LUMA_CHUNK_SIZE = 2; + +constexpr uint8_t QOI_MASK_OP = 0b11000000; +constexpr uint8_t QOI_MASK_VALUE = 0b00111111; + +constexpr size_t QOI_HEADER_SIZE = 14; +constexpr size_t QOI_COLOR_TABLE_SIZE = 64; + +inline size_t qoi_color_table_index(const Color &color) { + // QOI color hash function: (r * 3 + g * 5 + b * 7 + a * 11) % 64 + return (color.r * 3 + color.g * 5 + color.b * 7 + color.w * 11) & + 63; // modulo 64 is equivalent to bitwise AND with 63 (0b00111111) +} + +void QoiDecoder::reset() { + ImageDecoder::reset(); + this->current_index_ = 0; + this->paint_index_ = 0; + this->width_ = 0; + this->height_ = 0; + this->bits_per_pixel_ = 0; + this->last_pixel_ = Color(0, 0, 0, 255); + if (this->color_table_) { + std::fill_n(this->color_table_.get(), QOI_COLOR_TABLE_SIZE, Color()); + } +} + +int HOT QoiDecoder::decode(uint8_t *buffer, size_t size) { + size_t index = 0; + if (this->current_index_ == 0) { + if (size < QOI_HEADER_SIZE) { + return 0; // Need more data for file header + } + + /** QOI Header definition, for reference: + char magic[4]; // magic bytes "qoif" + uint32_t width; // image width in pixels (BE) + uint32_t height; // image height in pixels (BE) + uint8_t channels; // 3 = RGB, 4 = RGBA + uint8_t colorspace; // 0 = sRGB with linear alpha, 1 = all channels linear + */ + // Check if the file is a QOI image + if (buffer[0] != 'q' || buffer[1] != 'o' || buffer[2] != 'i' || buffer[3] != 'f') { + ESP_LOGE(TAG, "Not a QOI file"); + return DECODE_ERROR_INVALID_TYPE; + } + + this->width_ = encode_uint32(buffer[4], buffer[5], buffer[6], buffer[7]); + this->height_ = encode_uint32(buffer[8], buffer[9], buffer[10], buffer[11]); + if (this->width_ == 0 || this->height_ == 0) { + ESP_LOGE(TAG, "Invalid image dimensions: (%zux%zu)", this->width_, this->height_); + return DECODE_ERROR_INVALID_TYPE; + } + uint8_t channels = buffer[12]; + if (channels < 3 || channels > 4) { + ESP_LOGE(TAG, "Unsupported number of channels: %d", channels); + return DECODE_ERROR_UNSUPPORTED_FORMAT; + } + this->bits_per_pixel_ = channels * 8; + uint8_t colorspace = buffer[13]; + if (colorspace > 1) { + ESP_LOGE(TAG, "Unsupported colorspace value: %d", colorspace); + return DECODE_ERROR_UNSUPPORTED_FORMAT; + } + ESP_LOGD(TAG, "QOI image header: width=%zu, height=%zu, channels=%d, colorspace=%d", this->width_, this->height_, + channels, colorspace); + + if (!this->color_table_) { + this->color_table_ = std::make_unique(QOI_COLOR_TABLE_SIZE); + } + + if (!this->set_size(this->width_, this->height_)) { + return DECODE_ERROR_OUT_OF_MEMORY; + } + + this->current_index_ = QOI_HEADER_SIZE; + index = QOI_HEADER_SIZE; + } // Current_index == 0 + + Color color; + const size_t total_pixels = this->width_ * this->height_; + while (index < size && this->paint_index_ < total_pixels) { + color = this->last_pixel_; + uint8_t byte = buffer[index]; + if (byte == QOI_OP_RGB) { + if (size < index + QOI_RGB_CHUNK_SIZE) { + return index; // Need more data for RGB chunk + } + index++; + color.r = buffer[index++]; + color.g = buffer[index++]; + color.b = buffer[index++]; + this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color); + this->paint_index_++; + } else if (byte == QOI_OP_RGBA) { + if (size < index + QOI_RGBA_CHUNK_SIZE) { + return index; // Need more data for RGBA chunk + } + index++; + color.r = buffer[index++]; + color.g = buffer[index++]; + color.b = buffer[index++]; + color.w = buffer[index++]; + this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color); + this->paint_index_++; + } else if ((byte & QOI_MASK_OP) == QOI_OP_RUN) { + // QOI run chunk + size_t run_length = (byte & QOI_MASK_VALUE) + 1; // run length is encoded in the lower 6 bits, plus one + for (size_t i = 0; i < run_length; i++) { + // TODO: optimize by drawing runs of pixels at once instead of one by one + this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color); + this->paint_index_++; + } + index++; + } else if ((byte & QOI_MASK_OP) == QOI_OP_LUMA) { + if (size < index + QOI_LUMA_CHUNK_SIZE) { + return index; // Need more data for LUMA chunk + } + index++; + uint8_t byte2 = buffer[index++]; + uint8_t delta_g = (byte & QOI_MASK_VALUE) - 32; + color.r += delta_g - 8 + ((byte2 >> 4) & 0x0f); + color.g += delta_g; + color.b += delta_g - 8 + (byte2 & 0x0f); + + this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color); + this->paint_index_++; + } else if ((byte & QOI_MASK_OP) == QOI_OP_DIFF) { + color.r += ((byte >> 4) & 0x03) - 2; + color.g += ((byte >> 2) & 0x03) - 2; + color.b += (byte & 0x03) - 2; + + this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color); + this->paint_index_++; + index++; + } else if ((byte & QOI_MASK_OP) == QOI_OP_INDEX) { + color = this->color_table_[byte]; + this->draw(this->paint_index_ % this->width_, this->paint_index_ / this->width_, 1, 1, color); + this->paint_index_++; + index++; + } + this->last_pixel_ = color; + this->color_table_[qoi_color_table_index(color)] = color; + } + this->decoded_bytes_ += size; + return size; +} + +} // namespace esphome::runtime_image + +#endif // USE_RUNTIME_IMAGE_QOI diff --git a/esphome/components/runtime_image/qoi_decoder.h b/esphome/components/runtime_image/qoi_decoder.h new file mode 100644 index 0000000000..c44afd83cf --- /dev/null +++ b/esphome/components/runtime_image/qoi_decoder.h @@ -0,0 +1,49 @@ +#pragma once + +#include "esphome/core/defines.h" +#ifdef USE_RUNTIME_IMAGE_QOI + +#include + +#include "image_decoder.h" +#include "runtime_image.h" + +namespace esphome::runtime_image { + +/** + * @brief Image decoder specialization for QOI images. + */ +class QoiDecoder : public ImageDecoder { + public: + /** + * @brief Construct a new QOI decoder object. + * + * @param image The RuntimeImage to decode the stream into. + */ + QoiDecoder(RuntimeImage *image) : ImageDecoder(image, QOI) {} + + void reset() override; + int HOT decode(uint8_t *buffer, size_t size) override; + + bool is_finished() const override { + if (this->bits_per_pixel_ == 0) { + // header not yet received, so dimensions not yet determined + return false; + } + // QOI is finished when we've decoded all pixel data + return this->paint_index_ >= static_cast(this->width_ * this->height_); + } + + protected: + std::unique_ptr color_table_; + size_t current_index_{0}; + size_t paint_index_{0}; + size_t width_{0}; + size_t height_{0}; + Color last_pixel_{0, 0, 0, 255}; // QOI spec defines initial previous pixel as opaque black + uint16_t bits_per_pixel_{0}; +}; + +} // namespace esphome::runtime_image + +#endif // USE_RUNTIME_IMAGE_QOI diff --git a/esphome/components/runtime_image/runtime_image.cpp b/esphome/components/runtime_image/runtime_image.cpp index f7417c2c8e..ef92d0d707 100644 --- a/esphome/components/runtime_image/runtime_image.cpp +++ b/esphome/components/runtime_image/runtime_image.cpp @@ -15,6 +15,9 @@ #ifdef USE_RUNTIME_IMAGE_PNG #include "png_decoder.h" #endif +#ifdef USE_RUNTIME_IMAGE_QOI +#include "qoi_decoder.h" +#endif namespace esphome::runtime_image { @@ -367,6 +370,10 @@ std::unique_ptr RuntimeImage::create_decoder_(ImageFormat format) #ifdef USE_RUNTIME_IMAGE_PNG case PNG: return make_unique(this); +#endif +#ifdef USE_RUNTIME_IMAGE_QOI + case QOI: + return make_unique(this); #endif case AUTO: ESP_LOGE(TAG, "Image format could not be determined; set `format:` explicitly in the configuration"); diff --git a/esphome/components/safe_mode/safe_mode.cpp b/esphome/components/safe_mode/safe_mode.cpp index ce029b4f55..8fd5911ab5 100644 --- a/esphome/components/safe_mode/safe_mode.cpp +++ b/esphome/components/safe_mode/safe_mode.cpp @@ -255,12 +255,17 @@ bool SafeModeComponent::should_enter_safe_mode(uint8_t num_attempts, uint32_t en } void SafeModeComponent::write_rtc_(uint32_t val) { - this->rtc_.save(&val); - global_preferences->sync(); + if (!this->rtc_.save(&val)) { + ESP_LOGE(TAG, "Failed to set rtc value (%" PRIu32 ")", val); + return; + } + if (!global_preferences->sync()) { + ESP_LOGE(TAG, "Failed to persist rtc value (%" PRIu32 ")", val); + } } uint32_t SafeModeComponent::read_rtc_() { - uint32_t val; + uint32_t val = 0; if (!this->rtc_.load(&val)) return 0; return val; @@ -272,7 +277,9 @@ void SafeModeComponent::clean_rtc() { // before sync, the boot wasn't really successful anyway and the counter should // remain incremented. uint32_t val = 0; - this->rtc_.save(&val); + if (!this->rtc_.save(&val)) { + ESP_LOGE(TAG, "Failed to clear boot loop counter"); + } } void SafeModeComponent::on_safe_shutdown() { diff --git a/esphome/components/sdm_meter/sdm_meter.cpp b/esphome/components/sdm_meter/sdm_meter.cpp index 1ebc7fa3d8..c1b359cc97 100644 --- a/esphome/components/sdm_meter/sdm_meter.cpp +++ b/esphome/components/sdm_meter/sdm_meter.cpp @@ -1,85 +1,48 @@ #include "sdm_meter.h" #include "sdm_meter_registers.h" -#include "esphome/core/helpers.h" #include "esphome/core/log.h" namespace esphome::sdm_meter { +namespace helpers = modbus::helpers; + static const char *const TAG = "sdm_meter"; -static const uint8_t MODBUS_REGISTER_COUNT = 80; // 74 x 16-bit registers +static const uint8_t MODBUS_REGISTER_COUNT = 80; // 80 x 16-bit registers (40 float values) -void SDMMeter::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - if (data.size() < MODBUS_REGISTER_COUNT * 2) { - ESP_LOGW(TAG, "Invalid size for SDMMeter!"); - return; - } +void SDMMeter::on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status)) + return; // the hub already logs exception responses - auto sdm_meter_get_float = [&](size_t i) -> float { - uint32_t temp = encode_uint32(data[i], data[i + 1], data[i + 2], data[i + 3]); - float f; - memcpy(&f, &temp, sizeof(f)); - return f; + // Publish a sensor if both of its registers are in this response; skipping absent registers keeps + // this correct for any read range, so the poll may be split into multiple requests. + auto publish = [&](uint16_t reg, sensor::Sensor *sensor) { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value); }; for (uint8_t i = 0; i < 3; i++) { - auto phase = this->phases_[i]; + auto &phase = this->phases_[i]; if (!phase.setup) continue; - - float voltage = sdm_meter_get_float(SDM_PHASE_1_VOLTAGE * 2 + (i * 4)); - float current = sdm_meter_get_float(SDM_PHASE_1_CURRENT * 2 + (i * 4)); - float active_power = sdm_meter_get_float(SDM_PHASE_1_ACTIVE_POWER * 2 + (i * 4)); - float apparent_power = sdm_meter_get_float(SDM_PHASE_1_APPARENT_POWER * 2 + (i * 4)); - float reactive_power = sdm_meter_get_float(SDM_PHASE_1_REACTIVE_POWER * 2 + (i * 4)); - float power_factor = sdm_meter_get_float(SDM_PHASE_1_POWER_FACTOR * 2 + (i * 4)); - float phase_angle = sdm_meter_get_float(SDM_PHASE_1_ANGLE * 2 + (i * 4)); - - ESP_LOGD( - TAG, - "SDMMeter Phase %c: V=%.3f V, I=%.3f A, Active P=%.3f W, Apparent P=%.3f VA, Reactive P=%.3f var, PF=%.3f, " - "PA=%.3f °", - i + 'A', voltage, current, active_power, apparent_power, reactive_power, power_factor, phase_angle); - if (phase.voltage_sensor_ != nullptr) - phase.voltage_sensor_->publish_state(voltage); - if (phase.current_sensor_ != nullptr) - phase.current_sensor_->publish_state(current); - if (phase.active_power_sensor_ != nullptr) - phase.active_power_sensor_->publish_state(active_power); - if (phase.apparent_power_sensor_ != nullptr) - phase.apparent_power_sensor_->publish_state(apparent_power); - if (phase.reactive_power_sensor_ != nullptr) - phase.reactive_power_sensor_->publish_state(reactive_power); - if (phase.power_factor_sensor_ != nullptr) - phase.power_factor_sensor_->publish_state(power_factor); - if (phase.phase_angle_sensor_ != nullptr) - phase.phase_angle_sensor_->publish_state(phase_angle); + publish(SDM_PHASE_1_VOLTAGE + i * 2, phase.voltage_sensor_); + publish(SDM_PHASE_1_CURRENT + i * 2, phase.current_sensor_); + publish(SDM_PHASE_1_ACTIVE_POWER + i * 2, phase.active_power_sensor_); + publish(SDM_PHASE_1_APPARENT_POWER + i * 2, phase.apparent_power_sensor_); + publish(SDM_PHASE_1_REACTIVE_POWER + i * 2, phase.reactive_power_sensor_); + publish(SDM_PHASE_1_POWER_FACTOR + i * 2, phase.power_factor_sensor_); + publish(SDM_PHASE_1_ANGLE + i * 2, phase.phase_angle_sensor_); } - float total_power = sdm_meter_get_float(SDM_TOTAL_SYSTEM_POWER * 2); - float frequency = sdm_meter_get_float(SDM_FREQUENCY * 2); - float import_active_energy = sdm_meter_get_float(SDM_IMPORT_ACTIVE_ENERGY * 2); - float export_active_energy = sdm_meter_get_float(SDM_EXPORT_ACTIVE_ENERGY * 2); - float import_reactive_energy = sdm_meter_get_float(SDM_IMPORT_REACTIVE_ENERGY * 2); - float export_reactive_energy = sdm_meter_get_float(SDM_EXPORT_REACTIVE_ENERGY * 2); - - ESP_LOGD(TAG, "SDMMeter: F=%.3f Hz, Im.A.E=%.3f Wh, Ex.A.E=%.3f Wh, Im.R.E=%.3f VARh, Ex.R.E=%.3f VARh, T.P=%.3f W", - frequency, import_active_energy, export_active_energy, import_reactive_energy, export_reactive_energy, - total_power); - - if (this->total_power_sensor_ != nullptr) - this->total_power_sensor_->publish_state(total_power); - if (this->frequency_sensor_ != nullptr) - this->frequency_sensor_->publish_state(frequency); - if (this->import_active_energy_sensor_ != nullptr) - this->import_active_energy_sensor_->publish_state(import_active_energy); - if (this->export_active_energy_sensor_ != nullptr) - this->export_active_energy_sensor_->publish_state(export_active_energy); - if (this->import_reactive_energy_sensor_ != nullptr) - this->import_reactive_energy_sensor_->publish_state(import_reactive_energy); - if (this->export_reactive_energy_sensor_ != nullptr) - this->export_reactive_energy_sensor_->publish_state(export_reactive_energy); + publish(SDM_TOTAL_SYSTEM_POWER, this->total_power_sensor_); + publish(SDM_FREQUENCY, this->frequency_sensor_); + publish(SDM_IMPORT_ACTIVE_ENERGY, this->import_active_energy_sensor_); + publish(SDM_EXPORT_ACTIVE_ENERGY, this->export_active_energy_sensor_); + publish(SDM_IMPORT_REACTIVE_ENERGY, this->import_reactive_energy_sensor_); + publish(SDM_EXPORT_REACTIVE_ENERGY, this->export_reactive_energy_sensor_); } void SDMMeter::update() { this->read_input_registers(0, MODBUS_REGISTER_COUNT); } diff --git a/esphome/components/sdm_meter/sdm_meter.h b/esphome/components/sdm_meter/sdm_meter.h index e09b74bbc0..80370010bd 100644 --- a/esphome/components/sdm_meter/sdm_meter.h +++ b/esphome/components/sdm_meter/sdm_meter.h @@ -55,7 +55,8 @@ class SDMMeter final : public PollingComponent, public modbus::ModbusClientDevic void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; void dump_config() override; diff --git a/esphome/components/selec_meter/selec_meter.cpp b/esphome/components/selec_meter/selec_meter.cpp index 688923d8e6..3ad1f8b87c 100644 --- a/esphome/components/selec_meter/selec_meter.cpp +++ b/esphome/components/selec_meter/selec_meter.cpp @@ -1,84 +1,47 @@ #include "selec_meter.h" #include "selec_meter_registers.h" -#include "esphome/core/helpers.h" #include "esphome/core/log.h" namespace esphome::selec_meter { +namespace helpers = modbus::helpers; + static const char *const TAG = "selec_meter"; static const uint8_t MODBUS_REGISTER_COUNT = 34; // 34 x 16-bit registers -void SelecMeter::on_response(std::span request_pdu, std::span response_pdu) { - auto data = modbus::helpers::server_pdu_payload(response_pdu); - if (data.size() < MODBUS_REGISTER_COUNT * 2) { - ESP_LOGW(TAG, "Invalid size for SelecMeter!"); - return; - } +void SelecMeter::on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) { + if (!modbus::succeeded(status)) + return; // the hub already logs exception responses - auto selec_meter_get_float = [&](size_t i, float unit) -> float { - uint32_t temp = encode_uint32(data[i + 2], data[i + 3], data[i], data[i + 1]); - - float f; - memcpy(&f, &temp, sizeof(f)); - return (f * unit); + // Publish a sensor if both of its registers are in this response; skipping absent registers keeps + // this correct for any read range, so the poll may be split into multiple requests. + // Values are 32-bit floats, low word first. + auto publish = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void { + if (sensor == nullptr) + return; + if (auto value = helpers::value_at(registers, start_address, reg)) + sensor->publish_state(*value * unit); }; - float total_active_energy = selec_meter_get_float(SELEC_TOTAL_ACTIVE_ENERGY * 2, NO_DEC_UNIT); - float import_active_energy = selec_meter_get_float(SELEC_IMPORT_ACTIVE_ENERGY * 2, NO_DEC_UNIT); - float export_active_energy = selec_meter_get_float(SELEC_EXPORT_ACTIVE_ENERGY * 2, NO_DEC_UNIT); - float total_reactive_energy = selec_meter_get_float(SELEC_TOTAL_REACTIVE_ENERGY * 2, NO_DEC_UNIT); - float import_reactive_energy = selec_meter_get_float(SELEC_IMPORT_REACTIVE_ENERGY * 2, NO_DEC_UNIT); - float export_reactive_energy = selec_meter_get_float(SELEC_EXPORT_REACTIVE_ENERGY * 2, NO_DEC_UNIT); - float apparent_energy = selec_meter_get_float(SELEC_APPARENT_ENERGY * 2, NO_DEC_UNIT); - float active_power = selec_meter_get_float(SELEC_ACTIVE_POWER * 2, MULTIPLY_THOUSAND_UNIT); - float reactive_power = selec_meter_get_float(SELEC_REACTIVE_POWER * 2, MULTIPLY_THOUSAND_UNIT); - float apparent_power = selec_meter_get_float(SELEC_APPARENT_POWER * 2, MULTIPLY_THOUSAND_UNIT); - float voltage = selec_meter_get_float(SELEC_VOLTAGE * 2, NO_DEC_UNIT); - float current = selec_meter_get_float(SELEC_CURRENT * 2, NO_DEC_UNIT); - float power_factor = selec_meter_get_float(SELEC_POWER_FACTOR * 2, NO_DEC_UNIT); - float frequency = selec_meter_get_float(SELEC_FREQUENCY * 2, NO_DEC_UNIT); - float maximum_demand_active_power = - selec_meter_get_float(SELEC_MAXIMUM_DEMAND_ACTIVE_POWER * 2, MULTIPLY_THOUSAND_UNIT); - float maximum_demand_reactive_power = - selec_meter_get_float(SELEC_MAXIMUM_DEMAND_REACTIVE_POWER * 2, MULTIPLY_THOUSAND_UNIT); - float maximum_demand_apparent_power = - selec_meter_get_float(SELEC_MAXIMUM_DEMAND_APPARENT_POWER * 2, MULTIPLY_THOUSAND_UNIT); - - if (this->total_active_energy_sensor_ != nullptr) - this->total_active_energy_sensor_->publish_state(total_active_energy); - if (this->import_active_energy_sensor_ != nullptr) - this->import_active_energy_sensor_->publish_state(import_active_energy); - if (this->export_active_energy_sensor_ != nullptr) - this->export_active_energy_sensor_->publish_state(export_active_energy); - if (this->total_reactive_energy_sensor_ != nullptr) - this->total_reactive_energy_sensor_->publish_state(total_reactive_energy); - if (this->import_reactive_energy_sensor_ != nullptr) - this->import_reactive_energy_sensor_->publish_state(import_reactive_energy); - if (this->export_reactive_energy_sensor_ != nullptr) - this->export_reactive_energy_sensor_->publish_state(export_reactive_energy); - if (this->apparent_energy_sensor_ != nullptr) - this->apparent_energy_sensor_->publish_state(apparent_energy); - if (this->active_power_sensor_ != nullptr) - this->active_power_sensor_->publish_state(active_power); - if (this->reactive_power_sensor_ != nullptr) - this->reactive_power_sensor_->publish_state(reactive_power); - if (this->apparent_power_sensor_ != nullptr) - this->apparent_power_sensor_->publish_state(apparent_power); - if (this->voltage_sensor_ != nullptr) - this->voltage_sensor_->publish_state(voltage); - if (this->current_sensor_ != nullptr) - this->current_sensor_->publish_state(current); - if (this->power_factor_sensor_ != nullptr) - this->power_factor_sensor_->publish_state(power_factor); - if (this->frequency_sensor_ != nullptr) - this->frequency_sensor_->publish_state(frequency); - if (this->maximum_demand_active_power_sensor_ != nullptr) - this->maximum_demand_active_power_sensor_->publish_state(maximum_demand_active_power); - if (this->maximum_demand_reactive_power_sensor_ != nullptr) - this->maximum_demand_reactive_power_sensor_->publish_state(maximum_demand_reactive_power); - if (this->maximum_demand_apparent_power_sensor_ != nullptr) - this->maximum_demand_apparent_power_sensor_->publish_state(maximum_demand_apparent_power); + publish(this->total_active_energy_sensor_, SELEC_TOTAL_ACTIVE_ENERGY, NO_DEC_UNIT); + publish(this->import_active_energy_sensor_, SELEC_IMPORT_ACTIVE_ENERGY, NO_DEC_UNIT); + publish(this->export_active_energy_sensor_, SELEC_EXPORT_ACTIVE_ENERGY, NO_DEC_UNIT); + publish(this->total_reactive_energy_sensor_, SELEC_TOTAL_REACTIVE_ENERGY, NO_DEC_UNIT); + publish(this->import_reactive_energy_sensor_, SELEC_IMPORT_REACTIVE_ENERGY, NO_DEC_UNIT); + publish(this->export_reactive_energy_sensor_, SELEC_EXPORT_REACTIVE_ENERGY, NO_DEC_UNIT); + publish(this->apparent_energy_sensor_, SELEC_APPARENT_ENERGY, NO_DEC_UNIT); + publish(this->active_power_sensor_, SELEC_ACTIVE_POWER, MULTIPLY_THOUSAND_UNIT); + publish(this->reactive_power_sensor_, SELEC_REACTIVE_POWER, MULTIPLY_THOUSAND_UNIT); + publish(this->apparent_power_sensor_, SELEC_APPARENT_POWER, MULTIPLY_THOUSAND_UNIT); + publish(this->voltage_sensor_, SELEC_VOLTAGE, NO_DEC_UNIT); + publish(this->current_sensor_, SELEC_CURRENT, NO_DEC_UNIT); + publish(this->power_factor_sensor_, SELEC_POWER_FACTOR, NO_DEC_UNIT); + publish(this->frequency_sensor_, SELEC_FREQUENCY, NO_DEC_UNIT); + publish(this->maximum_demand_active_power_sensor_, SELEC_MAXIMUM_DEMAND_ACTIVE_POWER, MULTIPLY_THOUSAND_UNIT); + publish(this->maximum_demand_reactive_power_sensor_, SELEC_MAXIMUM_DEMAND_REACTIVE_POWER, MULTIPLY_THOUSAND_UNIT); + publish(this->maximum_demand_apparent_power_sensor_, SELEC_MAXIMUM_DEMAND_APPARENT_POWER, MULTIPLY_THOUSAND_UNIT); } void SelecMeter::update() { this->read_input_registers(0, MODBUS_REGISTER_COUNT); } diff --git a/esphome/components/selec_meter/selec_meter.h b/esphome/components/selec_meter/selec_meter.h index 5ae1f9bf99..470242c918 100644 --- a/esphome/components/selec_meter/selec_meter.h +++ b/esphome/components/selec_meter/selec_meter.h @@ -37,7 +37,8 @@ class SelecMeter final : public PollingComponent, public modbus::ModbusClientDev void update() override; - void on_response(std::span request_pdu, std::span response_pdu) override; + void on_read_input_registers(uint16_t start_address, std::span registers, + modbus::ResponseStatus status) override; void dump_config() override; }; diff --git a/esphome/components/sen21231/sen21231.cpp b/esphome/components/sen21231/sen21231.cpp index b42ba2fa1d..3f6212e7f2 100644 --- a/esphome/components/sen21231/sen21231.cpp +++ b/esphome/components/sen21231/sen21231.cpp @@ -13,7 +13,7 @@ void Sen21231Sensor::dump_config() { if (this->is_failed()) { ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL); } - ESP_LOGI(TAG, "SEN21231: %s", this->is_failed() ? "FAILED" : "OK"); + ESP_LOGI(TAG, "SEN21231: %s", this->is_failed() ? LOG_STR_LITERAL("FAILED") : LOG_STR_LITERAL("OK")); LOG_UPDATE_INTERVAL(this); } diff --git a/esphome/components/sen6x/sen6x.cpp b/esphome/components/sen6x/sen6x.cpp index 2a6ea64735..ed6cb24c52 100644 --- a/esphome/components/sen6x/sen6x.cpp +++ b/esphome/components/sen6x/sen6x.cpp @@ -9,9 +9,11 @@ static const char *const TAG = "sen6x"; static constexpr uint8_t POLL_RETRIES = 24; // 24 attempts static constexpr uint32_t I2C_READ_DELAY = 20; // 20 ms to wait for I2C read to complete +static constexpr uint32_t CMD_EXEC_DELAY = 20; // execution time of set commands (datasheet section 4.8) static constexpr uint32_t POLL_INTERVAL = 50; // 50 ms between poll attempts -// Single numeric timeout ID — the chain is sequential so only one is active at a time. +// Numeric timeout IDs. Each chain is sequential, so only one timeout per ID is active at a time. static constexpr uint32_t TIMEOUT_POLL = 1; +static constexpr uint32_t TIMEOUT_SETUP_STEP = 2; static constexpr uint16_t SEN6X_CMD_GET_DATA_READY_STATUS = 0x0202; static constexpr uint16_t SEN6X_CMD_GET_FIRMWARE_VERSION = 0xD100; static constexpr uint16_t SEN6X_CMD_GET_PRODUCT_NAME = 0xD014; @@ -26,6 +28,8 @@ static constexpr uint16_t SEN6X_CMD_READ_MEASUREMENT_SEN69C = 0x04B5; static constexpr uint16_t SEN6X_CMD_START_MEASUREMENTS = 0x0021; static constexpr uint16_t SEN6X_CMD_RESET = 0xD304; +static constexpr uint16_t SEN6X_CMD_VOC_ALGORITHM_TUNING = 0x60D0; +static constexpr uint16_t SEN6X_CMD_NOX_ALGORITHM_TUNING = 0x60E1; static inline void set_read_command_and_words(SEN6XComponent::Sen6xType type, uint16_t &read_cmd, uint8_t &read_words) { read_cmd = SEN6X_CMD_READ_MEASUREMENT; @@ -143,21 +147,76 @@ void SEN6XComponent::setup() { this->firmware_version_minor_ = raw_firmware_version & 0xFF; ESP_LOGI(TAG, "Firmware: %u.%u", this->firmware_version_major_, this->firmware_version_minor_); - if (!this->write_command(SEN6X_CMD_START_MEASUREMENTS)) { - ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL); - this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL)); - return; - } - - this->set_timeout(60000, [this]() { this->startup_complete_ = true; }); - this->initialized_ = true; - ESP_LOGD(TAG, "Initialized"); + // Step 4: write configuration commands one at a time, then start measurements. + // Delay the first step so it doesn't run in the same loop tick as the read above. + this->set_timeout(TIMEOUT_SETUP_STEP, CMD_EXEC_DELAY, [this]() { this->run_next_setup_step_(); }); }); }); }); }); } +// One configuration write per invocation, spaced by CMD_EXEC_DELAY. Cases without a +// configured value fall through; each taken case must advance setup_step_index_ so the +// next invocation resumes at the following step. These writes are optional, so a failure +// only warns and the chain continues to the mandatory start-measurements write. +void SEN6XComponent::run_next_setup_step_() { + switch (this->setup_step_index_) { + // Tuning writes are skipped when setup() disabled the sensor for this variant + case 0: + this->setup_step_index_++; + if (this->voc_sensor_ != nullptr && this->voc_tuning_params_.has_value()) { + this->write_tuning_parameters_(SEN6X_CMD_VOC_ALGORITHM_TUNING, this->voc_tuning_params_.value()); + break; + } + [[fallthrough]]; + case 1: + this->setup_step_index_++; + if (this->nox_sensor_ != nullptr && this->nox_tuning_params_.has_value()) { + this->write_tuning_parameters_(SEN6X_CMD_NOX_ALGORITHM_TUNING, this->nox_tuning_params_.value()); + break; + } + [[fallthrough]]; + default: + this->finish_setup_(); + return; + } + this->set_timeout(TIMEOUT_SETUP_STEP, CMD_EXEC_DELAY, [this]() { this->run_next_setup_step_(); }); +} + +void SEN6XComponent::finish_setup_() { + if (!this->write_command(SEN6X_CMD_START_MEASUREMENTS)) { + ESP_LOGE(TAG, "Write 0x%04X failed, error %d", SEN6X_CMD_START_MEASUREMENTS, this->last_error_); + this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL)); + return; + } + + this->set_timeout(60000, [this]() { this->startup_complete_ = true; }); + this->initialized_ = true; + ESP_LOGD(TAG, "Initialized"); +} + +// Writes one optional configuration command. A failure warns and returns false, but does +// not stop setup: the sensor still measures with that setting left at its default. +bool SEN6XComponent::write_config_words_(uint16_t i2c_command, const uint16_t *data, uint8_t len) { + if (!this->write_command(i2c_command, data, len)) { + ESP_LOGE(TAG, "Write 0x%04X failed, error %d", i2c_command, this->last_error_); + this->status_set_warning(); + return false; + } + return true; +} + +bool SEN6XComponent::write_tuning_parameters_(uint16_t i2c_command, const GasTuning &tuning) { + uint16_t params[6] = {tuning.index_offset, + tuning.learning_time_offset_hours, + tuning.learning_time_gain_hours, + tuning.gating_max_duration_minutes, + tuning.std_initial, + tuning.gain_factor}; + return this->write_config_words_(i2c_command, params, 6); +} + void SEN6XComponent::dump_config() { ESP_LOGCONFIG(TAG, "sen6x:\n" diff --git a/esphome/components/sen6x/sen6x.h b/esphome/components/sen6x/sen6x.h index 041bf3b1aa..64ce3371fc 100644 --- a/esphome/components/sen6x/sen6x.h +++ b/esphome/components/sen6x/sen6x.h @@ -1,11 +1,25 @@ #pragma once #include "esphome/core/component.h" +#include "esphome/core/optional.h" #include "esphome/components/sensor/sensor.h" #include "esphome/components/sensirion_common/i2c_sensirion.h" namespace esphome::sen6x { +// The NOx algorithm requires std_initial to stay at 50 (Sensirion datasheet) +static constexpr uint16_t NOX_STD_INITIAL = 50; + +// Raw parameter block for the VOC/NOx algorithm tuning commands +struct GasTuning { + uint16_t index_offset; + uint16_t learning_time_offset_hours; + uint16_t learning_time_gain_hours; + uint16_t gating_max_duration_minutes; + uint16_t std_initial; + uint16_t gain_factor; +}; + class SEN6XComponent final : public PollingComponent, public sensirion_common::SensirionI2CDevice { SUB_SENSOR(pm_1_0) SUB_SENSOR(pm_2_5) @@ -27,22 +41,46 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S enum Sen6xType { SEN62, SEN63C, SEN65, SEN66, SEN68, SEN69C, UNKNOWN }; void set_type(const std::string &type) { sen6x_type_ = infer_type_from_product_name_(type); } + void set_voc_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours, + uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes, + uint16_t std_initial, uint16_t gain_factor) { + this->voc_tuning_params_ = GasTuning{ + index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, std_initial, + gain_factor}; + } + void set_nox_algorithm_tuning(uint16_t index_offset, uint16_t learning_time_offset_hours, + uint16_t learning_time_gain_hours, uint16_t gating_max_duration_minutes, + uint16_t gain_factor) { + this->nox_tuning_params_ = GasTuning{index_offset, + learning_time_offset_hours, + learning_time_gain_hours, + gating_max_duration_minutes, + NOX_STD_INITIAL, + gain_factor}; + } protected: Sen6xType infer_type_from_product_name_(const std::string &product_name); + void run_next_setup_step_(); + void finish_setup_(); + bool write_config_words_(uint16_t i2c_command, const uint16_t *data, uint8_t len); + bool write_tuning_parameters_(uint16_t i2c_command, const GasTuning &tuning); void poll_data_ready_(); void read_measurements_(); void parse_and_publish_measurements_(); - bool initialized_{false}; std::string product_name_; - Sen6xType sen6x_type_{UNKNOWN}; std::string serial_number_; + optional voc_tuning_params_; + optional nox_tuning_params_; + Sen6xType sen6x_type_{UNKNOWN}; uint16_t read_cmd_{0}; + uint8_t setup_step_index_{0}; uint8_t firmware_version_major_{0}; uint8_t firmware_version_minor_{0}; uint8_t poll_retries_remaining_{0}; uint8_t read_words_{0}; + bool initialized_{false}; bool startup_complete_{false}; }; diff --git a/esphome/components/sen6x/sensor.py b/esphome/components/sen6x/sensor.py index b0ffdc53a4..4c0242f2e3 100644 --- a/esphome/components/sen6x/sensor.py +++ b/esphome/components/sen6x/sensor.py @@ -3,15 +3,22 @@ from esphome.components import i2c, sensirion_common, sensor from esphome.components.const import CONF_NOX_INDEX, CONF_VOC_INDEX import esphome.config_validation as cv from esphome.const import ( + CONF_ALGORITHM_TUNING, CONF_CO2, CONF_FORMALDEHYDE, + CONF_GAIN_FACTOR, + CONF_GATING_MAX_DURATION_MINUTES, CONF_HUMIDITY, CONF_ID, + CONF_INDEX_OFFSET, + CONF_LEARNING_TIME_GAIN_HOURS, + CONF_LEARNING_TIME_OFFSET_HOURS, CONF_NOX, CONF_PM_1_0, CONF_PM_2_5, CONF_PM_4_0, CONF_PM_10_0, + CONF_STD_INITIAL, CONF_TEMPERATURE, CONF_TYPE, CONF_VOC, @@ -44,6 +51,42 @@ SEN6XComponent = sen6x_ns.class_( ) +def _gas_index_schema( + *, + index_offset: int, + gating_max_duration: int, + std_initial: int | None, +) -> cv.Schema: + """Sensor schema for a gas index sensor with optional algorithm tuning. + + std_initial is only configurable for VOC; the NOx algorithm requires 50. + """ + tuning_schema = { + cv.Optional(CONF_INDEX_OFFSET, default=index_offset): cv.int_range( + min=1, max=250 + ), + cv.Optional(CONF_LEARNING_TIME_OFFSET_HOURS, default=12): cv.int_range( + min=1, max=1000 + ), + cv.Optional(CONF_LEARNING_TIME_GAIN_HOURS, default=12): cv.int_range( + min=1, max=1000 + ), + cv.Optional( + CONF_GATING_MAX_DURATION_MINUTES, default=gating_max_duration + ): cv.int_range(min=0, max=3000), + cv.Optional(CONF_GAIN_FACTOR, default=230): cv.int_range(min=1, max=1000), + } + if std_initial is not None: + tuning_schema[cv.Optional(CONF_STD_INITIAL, default=std_initial)] = ( + cv.int_range(min=10, max=5000) + ) + return sensor.sensor_schema( + icon=ICON_RADIATOR, + accuracy_decimals=0, + state_class=STATE_CLASS_MEASUREMENT, + ).extend({cv.Optional(CONF_ALGORITHM_TUNING): cv.Schema(tuning_schema)}) + + CONFIG_SCHEMA = cv.All( cv.rename_key(CONF_VOC, CONF_VOC_INDEX, removed_in="2027.2.0", component="sen6x"), cv.rename_key(CONF_NOX, CONF_NOX_INDEX, removed_in="2027.2.0", component="sen6x"), @@ -94,15 +137,15 @@ CONFIG_SCHEMA = cv.All( device_class=DEVICE_CLASS_HUMIDITY, state_class=STATE_CLASS_MEASUREMENT, ), - cv.Optional(CONF_VOC_INDEX): sensor.sensor_schema( - icon=ICON_RADIATOR, - accuracy_decimals=0, - state_class=STATE_CLASS_MEASUREMENT, + cv.Optional(CONF_VOC_INDEX): _gas_index_schema( + index_offset=100, + gating_max_duration=180, + std_initial=50, ), - cv.Optional(CONF_NOX_INDEX): sensor.sensor_schema( - icon=ICON_RADIATOR, - accuracy_decimals=0, - state_class=STATE_CLASS_MEASUREMENT, + cv.Optional(CONF_NOX_INDEX): _gas_index_schema( + index_offset=1, + gating_max_duration=720, + std_initial=None, ), cv.Optional(CONF_CO2): sensor.sensor_schema( unit_of_measurement=UNIT_PARTS_PER_MILLION, @@ -149,3 +192,20 @@ async def to_code(config: ConfigType) -> None: if cfg := config.get(key): sens = await sensor.new_sensor(cfg) cg.add(getattr(var, func_name)(sens)) + + for key, setter in ( + (CONF_VOC_INDEX, "set_voc_algorithm_tuning"), + (CONF_NOX_INDEX, "set_nox_algorithm_tuning"), + ): + if (tuning := config.get(key, {}).get(CONF_ALGORITHM_TUNING)) is not None: + args = [ + tuning[CONF_INDEX_OFFSET], + tuning[CONF_LEARNING_TIME_OFFSET_HOURS], + tuning[CONF_LEARNING_TIME_GAIN_HOURS], + tuning[CONF_GATING_MAX_DURATION_MINUTES], + ] + # std_initial is in the schema for VOC only + if (std_initial := tuning.get(CONF_STD_INITIAL)) is not None: + args.append(std_initial) + args.append(tuning[CONF_GAIN_FACTOR]) + cg.add(getattr(var, setter)(*args)) diff --git a/esphome/components/senseair/senseair.cpp b/esphome/components/senseair/senseair.cpp index 0e8e4cef97..f5017cff75 100644 --- a/esphome/components/senseair/senseair.cpp +++ b/esphome/components/senseair/senseair.cpp @@ -89,8 +89,9 @@ void SenseAirComponent::background_calibration_result() { } // Check if 5th bit (register CI6) is set - ESP_LOGI(TAG, "SenseAir Result=%s (%02x%02x%02x %02x%02x %02x%02x)", (response[4] & 0b100000) != 0 ? "OK" : "NOT_OK", - response[0], response[1], response[2], response[3], response[4], response[5], response[6]); + ESP_LOGI(TAG, "SenseAir Result=%s (%02x%02x%02x %02x%02x %02x%02x)", + (response[4] & 0b100000) != 0 ? LOG_STR_LITERAL("OK") : LOG_STR_LITERAL("NOT_OK"), response[0], response[1], + response[2], response[3], response[4], response[5], response[6]); } void SenseAirComponent::abc_enable() { diff --git a/esphome/components/serial_proxy/serial_proxy.cpp b/esphome/components/serial_proxy/serial_proxy.cpp index 94cefc8700..2ab0d4ebb4 100644 --- a/esphome/components/serial_proxy/serial_proxy.cpp +++ b/esphome/components/serial_proxy/serial_proxy.cpp @@ -82,11 +82,11 @@ void SerialProxy::dump_config() { " RTS Pin: %s\n" " DTR Pin: %s", this->instance_index_, this->name_ != nullptr ? this->name_ : "", - this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS485 ? "RS485" - : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS232 ? "RS232" - : "TTL", - this->rts_pin_ != nullptr ? "configured" : "not configured", - this->dtr_pin_ != nullptr ? "configured" : "not configured"); + this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS485 ? LOG_STR_LITERAL("RS485") + : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS232 ? LOG_STR_LITERAL("RS232") + : LOG_STR_LITERAL("TTL"), + this->rts_pin_ != nullptr ? LOG_STR_LITERAL("configured") : LOG_STR_LITERAL("not configured"), + this->dtr_pin_ != nullptr ? LOG_STR_LITERAL("configured") : LOG_STR_LITERAL("not configured")); } SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uint32_t baudrate, bool flow_control, diff --git a/esphome/components/sgp4x/sgp4x.cpp b/esphome/components/sgp4x/sgp4x.cpp index bc6fe794a0..0cf5c31483 100644 --- a/esphome/components/sgp4x/sgp4x.cpp +++ b/esphome/components/sgp4x/sgp4x.cpp @@ -284,7 +284,7 @@ void SGP4xComponent::dump_config() { " Type: %s\n" " Serial number: %" PRIu64 "\n" " Minimum Samples: %f", - this->sgp_type_ == SGP41 ? "SGP41" : "SGP40", this->serial_number_, + this->sgp_type_ == SGP41 ? LOG_STR_LITERAL("SGP41") : LOG_STR_LITERAL("SGP40"), this->serial_number_, GasIndexAlgorithm_INITIAL_BLACKOUT); } LOG_UPDATE_INTERVAL(this); diff --git a/esphome/components/shelly_dimmer/stm32flash.cpp b/esphome/components/shelly_dimmer/stm32flash.cpp index c758b0a312..beb015851e 100644 --- a/esphome/components/shelly_dimmer/stm32flash.cpp +++ b/esphome/components/shelly_dimmer/stm32flash.cpp @@ -629,8 +629,9 @@ stm32_unique_ptr stm32_init(uart::UARTDevice *stream, const uint8_t flags, const stm->pid = (buf[1] << 8) | buf[2]; if (returned > 2) { ESP_LOGD(TAG, "This bootloader returns %d extra bytes in PID:", returned); - for (auto i = 2; i <= returned; i++) + for (auto i = 2; i <= returned; i++) { ESP_LOGD(TAG, " %02x", buf[i]); + } } if (stm32_get_ack(stm) != STM32_ERR_OK) { return make_stm32_with_deletor(nullptr); diff --git a/esphome/components/spi/__init__.py b/esphome/components/spi/__init__.py index d7b85ee20d..dd2dce01c5 100644 --- a/esphome/components/spi/__init__.py +++ b/esphome/components/spi/__init__.py @@ -15,6 +15,7 @@ from esphome.components.esp32 import ( VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3, + VARIANT_ESP32S31, only_on_variant, ) from esphome.config_helpers import filter_source_files_from_platform @@ -126,6 +127,7 @@ CONF_FORCE_SW = "force_sw" CONF_INTERFACE = "interface" CONF_INTERFACE_INDEX = "interface_index" CONF_RELEASE_DEVICE = "release_device" +CONF_PSRAM_DMA = "psram_dma" TYPE_SINGLE = "single" TYPE_QUAD = "quad" TYPE_OCTAL = "octal" @@ -136,6 +138,29 @@ TYPE_CLASS = { TYPE_OCTAL: OctalSPIComponent, } + +def _validate_psram_dma(value: Any) -> bool: + value = cv.boolean(value) + if not value: + return value + return cv.All( + cv.only_on_esp32, + cv.only_with_framework("esp-idf"), + only_on_variant( + supported=[ + VARIANT_ESP32C5, + VARIANT_ESP32C61, + VARIANT_ESP32P4, + VARIANT_ESP32S31, + VARIANT_ESP32S3, + ], + msg_prefix="PSRAM DMA", + ), + cv.require_framework_version(esp_idf=cv.Version(5, 5, 3)), + cv.requires_component("psram"), + )(value) + + # RP2040 SPI pin assignments are complicated; # refer to GPIO function select table in https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf @@ -450,6 +475,7 @@ def spi_device_schema( SPI_MODE_OPTIONS, upper=True ), cv.Optional(CONF_RELEASE_DEVICE): cv.All(cv.boolean, cv.only_on_esp32), + cv.Optional(CONF_PSRAM_DMA): _validate_psram_dma, cs_pin_option(CONF_CS_PIN): pins.gpio_output_pin_schema, } ) @@ -471,6 +497,9 @@ async def register_spi_device( cg.add(var.set_mode(spi_mode)) if release_device := config.get(CONF_RELEASE_DEVICE): cg.add(var.set_release_device(release_device)) + if psram_dma := config.get(CONF_PSRAM_DMA): + cg.add_define("USE_SPI_PSRAM_DMA") + cg.add(var.set_psram_dma(psram_dma)) def final_validate_device_schema( @@ -498,6 +527,36 @@ def final_validate_device_schema( ) +def _walk_config(value: Any, path: tuple[Any, ...] = ()): + if isinstance(value, dict): + yield value, path + for key, child in value.items(): + yield from _walk_config(child, (*path, key)) + elif isinstance(value, list): + for index, child in enumerate(value): + yield from _walk_config(child, (*path, index)) + + +def _final_validate(config: Any) -> Any: + buses = config if isinstance(config, list) else [config] + software_bus_ids = { + bus[CONF_ID] for bus in buses if CONF_INTERFACE_INDEX not in bus + } + if not software_bus_ids: + return config + for candidate, path in _walk_config(fv.full_config.get()): + if ( + candidate.get(CONF_PSRAM_DMA) + and candidate.get(CONF_SPI_ID) in software_bus_ids + ): + with cv.prepend_path([cv.ROOT_CONFIG_PATH, *path, CONF_PSRAM_DMA]): + raise cv.Invalid("psram_dma requires a hardware SPI interface") + return config + + +FINAL_VALIDATE_SCHEMA = _final_validate + + FILTER_SOURCE_FILES = filter_source_files_from_platform( { "spi_arduino.cpp": { diff --git a/esphome/components/spi/spi.h b/esphome/components/spi/spi.h index 17c59c895a..2dfb3c75a8 100644 --- a/esphome/components/spi/spi.h +++ b/esphome/components/spi/spi.h @@ -253,11 +253,18 @@ class SPIDelegate { // check if device is ready virtual bool is_ready(); +#ifdef USE_SPI_PSRAM_DMA + void set_psram_dma(bool enable) { this->psram_dma_ = enable; } +#endif + protected: SPIBitOrder bit_order_{BIT_ORDER_MSB_FIRST}; uint32_t data_rate_{1000000}; SPIMode mode_{MODE0}; GPIOPin *cs_pin_{NullPin::NULL_PIN}; +#ifdef USE_SPI_PSRAM_DMA + bool psram_dma_{false}; +#endif static SPIDelegate *const NULL_DELEGATE; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) }; @@ -397,6 +404,12 @@ class SPIClient { esph_log_d("spi_device", "mode %u, data_rate %ukHz", (unsigned) this->mode_, (unsigned) (this->data_rate_ / 1000)); this->delegate_ = this->parent_->register_device(this, this->mode_, this->bit_order_, this->data_rate_, this->cs_, this->release_device_, this->write_only_); +#ifdef USE_SPI_PSRAM_DMA + this->delegate_->set_psram_dma(this->psram_dma_); + if (this->psram_dma_) { + esph_log_config("spi_device", "PSRAM DMA: enabled"); + } +#endif } virtual void spi_teardown() { @@ -407,6 +420,9 @@ class SPIClient { bool spi_is_ready() { return this->delegate_->is_ready(); } void set_release_device(bool release) { this->release_device_ = release; } void set_write_only(bool write_only) { this->write_only_ = write_only; } +#ifdef USE_SPI_PSRAM_DMA + void set_psram_dma(bool enable) { this->psram_dma_ = enable; } +#endif protected: SPIBitOrder bit_order_{BIT_ORDER_MSB_FIRST}; @@ -416,6 +432,9 @@ class SPIClient { GPIOPin *cs_{nullptr}; bool release_device_{false}; bool write_only_{false}; +#ifdef USE_SPI_PSRAM_DMA + bool psram_dma_{false}; +#endif SPIDelegate *delegate_{SPIDelegate::NULL_DELEGATE}; }; diff --git a/esphome/components/spi/spi_esp_idf.cpp b/esphome/components/spi/spi_esp_idf.cpp index d5d5053117..95b5e4f14b 100644 --- a/esphome/components/spi/spi_esp_idf.cpp +++ b/esphome/components/spi/spi_esp_idf.cpp @@ -1,12 +1,24 @@ #include "spi.h" #include +#ifdef USE_SPI_PSRAM_DMA +#include +#endif + namespace esphome::spi { #ifdef USE_ESP32 static const char *const TAG = "spi"; static const size_t MAX_TRANSFER_SIZE = 4092; // dictated by ESP-IDF API. +#ifdef USE_SPI_PSRAM_DMA +static uint32_t get_psram_dma_flags(bool enabled, const void *tx_buffer) { + if (enabled && tx_buffer != nullptr && esp_ptr_dma_ext_capable(tx_buffer)) + return SPI_TRANS_DMA_USE_PSRAM; + return 0; +} +#endif + class SPIDelegateHw : public SPIDelegate { public: SPIDelegateHw(SPIInterface channel, uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin, @@ -30,8 +42,9 @@ class SPIDelegateHw : public SPIDelegate { if (this->release_device_) this->add_device_(); if (this->is_ready()) { - if (spi_device_acquire_bus(this->handle_, portMAX_DELAY) != ESP_OK) + if (spi_device_acquire_bus(this->handle_, portMAX_DELAY) != ESP_OK) { ESP_LOGE(TAG, "Failed to acquire SPI bus"); + } SPIDelegate::begin_transaction(); } else { ESP_LOGW(TAG, "SPI device not ready, cannot begin transaction"); @@ -51,8 +64,9 @@ class SPIDelegateHw : public SPIDelegate { ~SPIDelegateHw() override { esp_err_t const err = spi_bus_remove_device(this->handle_); - if (err != ESP_OK) + if (err != ESP_OK) { ESP_LOGE(TAG, "Remove device failed - err %X", err); + } } // do a transfer. either txbuf or rxbuf (but not both) may be null. @@ -65,8 +79,13 @@ class SPIDelegateHw : public SPIDelegate { return; } spi_transaction_t desc = {}; - desc.flags = 0; +#ifdef USE_SPI_PSRAM_DMA + const uint32_t psram_flags = rxbuf == nullptr ? get_psram_dma_flags(this->psram_dma_, txbuf) : 0; +#endif while (length != 0) { +#ifdef USE_SPI_PSRAM_DMA + desc.flags = psram_flags; +#endif size_t const partial = std::min(length, MAX_TRANSFER_SIZE); desc.length = partial * 8; desc.rxlength = this->write_only_ ? 0 : partial * 8; @@ -81,6 +100,12 @@ class SPIDelegateHw : public SPIDelegate { ESP_LOGE(TAG, "Transmit failed - err %X", err); break; } +#ifdef USE_SPI_PSRAM_DMA + if ((desc.flags & SPI_TRANS_DMA_TX_FAIL) != 0) { + ESP_LOGE(TAG, "PSRAM DMA TX underflow"); + break; + } +#endif length -= partial; if (txbuf != nullptr) txbuf += partial; @@ -133,7 +158,13 @@ class SPIDelegateHw : public SPIDelegate { desc.base.rxlength = 0; desc.base.cmd = cmd; desc.base.addr = address; +#ifdef USE_SPI_PSRAM_DMA + const uint32_t transaction_flags = desc.base.flags | get_psram_dma_flags(this->psram_dma_, data); +#endif do { +#ifdef USE_SPI_PSRAM_DMA + desc.base.flags = transaction_flags; +#endif size_t chunk_size = std::min(length, MAX_TRANSFER_SIZE); if (data != nullptr && chunk_size != 0) { desc.base.length = chunk_size * 8; @@ -152,6 +183,12 @@ class SPIDelegateHw : public SPIDelegate { ESP_LOGE(TAG, "Transmit failed - err %X", err); return; } +#ifdef USE_SPI_PSRAM_DMA + if ((desc.base.flags & SPI_TRANS_DMA_TX_FAIL) != 0) { + ESP_LOGE(TAG, "PSRAM DMA TX underflow"); + return; + } +#endif // if more data is to be sent, skip the command and address phases. desc.command_bits = 0; desc.address_bits = 0; @@ -249,8 +286,9 @@ class SPIBusHw : public SPIBus { } buscfg.max_transfer_sz = MAX_TRANSFER_SIZE; auto err = spi_bus_initialize(channel, &buscfg, SPI_DMA_CH_AUTO); - if (err != ESP_OK) + if (err != ESP_OK) { ESP_LOGE(TAG, "Bus init failed - err %X", err); + } } SPIDelegate *get_delegate(uint32_t data_rate, SPIBitOrder bit_order, SPIMode mode, GPIOPin *cs_pin, diff --git a/esphome/components/sprinkler/sprinkler.cpp b/esphome/components/sprinkler/sprinkler.cpp index 2edceb76a5..9fd0d9208b 100644 --- a/esphome/components/sprinkler/sprinkler.cpp +++ b/esphome/components/sprinkler/sprinkler.cpp @@ -1335,7 +1335,7 @@ void Sprinkler::all_valves_off_(const bool include_pump) { this->set_pump_state(this->valve_pump_switch(valve_index), false); } } - ESP_LOGD(TAG, "All valves stopped%s", include_pump ? ", including pumps" : ""); + ESP_LOGD(TAG, "All valves stopped%s", include_pump ? LOG_STR_LITERAL(", including pumps") : ""); } void Sprinkler::prep_full_cycle_() { diff --git a/esphome/components/st7701s/st7701s.cpp b/esphome/components/st7701s/st7701s.cpp index 3ffef86f3e..83f7bc9ce5 100644 --- a/esphome/components/st7701s/st7701s.cpp +++ b/esphome/components/st7701s/st7701s.cpp @@ -78,8 +78,9 @@ void ST7701S::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8 break; } } - if (err != ESP_OK) + if (err != ESP_OK) { esph_log_e(TAG, "lcd_lcd_panel_draw_bitmap failed: %s", esp_err_to_name(err)); + } } void ST7701S::draw_pixel_at(int x, int y, Color color) { diff --git a/esphome/components/switch/switch.cpp b/esphome/components/switch/switch.cpp index 101a0b9ffa..8413c7b493 100644 --- a/esphome/components/switch/switch.cpp +++ b/esphome/components/switch/switch.cpp @@ -26,7 +26,8 @@ void Switch::turn_off() { this->write_state(this->inverted_); } void Switch::toggle() { - ESP_LOGV(TAG, "'%s' Toggling %s.", this->get_name().c_str(), this->state ? "OFF" : "ON"); + ESP_LOGV(TAG, "'%s' Toggling %s.", this->get_name().c_str(), + this->state ? LOG_STR_LITERAL("OFF") : LOG_STR_LITERAL("ON")); this->write_state(this->inverted_ == this->state); } optional Switch::get_initial_state() { diff --git a/esphome/components/sx127x/sx127x.cpp b/esphome/components/sx127x/sx127x.cpp index 040a3064bc..cd81f08914 100644 --- a/esphome/components/sx127x/sx127x.cpp +++ b/esphome/components/sx127x/sx127x.cpp @@ -479,8 +479,9 @@ void SX127x::dump_config() { " Rx Start: %s\n" " Rx Floor: %.1f dBm\n" " Packet Mode: %s", - shaping, this->modulation_ == MOD_FSK ? "FSK" : "OOK", this->bitrate_, TRUEFALSE(this->bitsync_), - TRUEFALSE(this->rx_start_), this->rx_floor_, TRUEFALSE(this->packet_mode_)); + shaping, this->modulation_ == MOD_FSK ? LOG_STR_LITERAL("FSK") : LOG_STR_LITERAL("OOK"), + this->bitrate_, TRUEFALSE(this->bitsync_), TRUEFALSE(this->rx_start_), this->rx_floor_, + TRUEFALSE(this->packet_mode_)); if (this->packet_mode_) { ESP_LOGCONFIG(TAG, " CRC Enable: %s", TRUEFALSE(this->crc_enable_)); } diff --git a/esphome/components/sx1509/__init__.py b/esphome/components/sx1509/__init__.py index c1e4e11d54..7694b8f732 100644 --- a/esphome/components/sx1509/__init__.py +++ b/esphome/components/sx1509/__init__.py @@ -1,6 +1,7 @@ from esphome import automation, pins import esphome.codegen as cg from esphome.components import i2c, key_provider +from esphome.components.const import CONF_KEYS import esphome.config_validation as cv from esphome.const import ( CONF_ID, @@ -19,7 +20,6 @@ from esphome.cpp_generator import MockObj from esphome.types import ConfigType CONF_KEYPAD = "keypad" -CONF_KEYS = "keys" CONF_KEY_ROWS = "key_rows" CONF_KEY_COLUMNS = "key_columns" CONF_SLEEP_TIME = "sleep_time" diff --git a/esphome/components/thermostat/thermostat_climate.cpp b/esphome/components/thermostat/thermostat_climate.cpp index c10eb5b9f5..e830d359c6 100644 --- a/esphome/components/thermostat/thermostat_climate.cpp +++ b/esphome/components/thermostat/thermostat_climate.cpp @@ -1432,7 +1432,8 @@ void ThermostatClimate::dump_config() { ESP_LOGCONFIG(TAG, " On boot, restore from: %s\n" " Use Start-up Delay: %s", - this->on_boot_restore_from_ == thermostat::DEFAULT_PRESET ? "DEFAULT_PRESET" : "MEMORY", + this->on_boot_restore_from_ == thermostat::DEFAULT_PRESET ? LOG_STR_LITERAL("DEFAULT_PRESET") + : LOG_STR_LITERAL("MEMORY"), YESNO(this->use_startup_delay_)); if (this->supports_two_points_) { ESP_LOGCONFIG(TAG, " Minimum Set Point Differential: %.1f°C", this->set_point_minimum_differential_); @@ -1550,7 +1551,8 @@ void ThermostatClimate::dump_config() { ESP_LOGCONFIG(TAG, " Supported PRESETS:"); for (const auto &entry : this->preset_config_) { const auto *preset_name = LOG_STR_ARG(climate::climate_preset_to_string(entry.preset)); - ESP_LOGCONFIG(TAG, " %s:%s", preset_name, entry.preset == this->default_preset_ ? " (default)" : ""); + ESP_LOGCONFIG(TAG, " %s:%s", preset_name, + entry.preset == this->default_preset_ ? LOG_STR_LITERAL(" (default)") : ""); this->dump_preset_config_(preset_name, entry.config); } } @@ -1561,7 +1563,7 @@ void ThermostatClimate::dump_config() { const auto *preset_name = entry.name; ESP_LOGCONFIG(TAG, " %s:%s", preset_name, (this->default_custom_preset_ != nullptr && strcmp(entry.name, this->default_custom_preset_) == 0) - ? " (default)" + ? LOG_STR_LITERAL(" (default)") : ""); this->dump_preset_config_(preset_name, entry.config); } diff --git a/esphome/components/tsl2591/tsl2591.cpp b/esphome/components/tsl2591/tsl2591.cpp index fb34dd833d..2a5d6a4ee4 100644 --- a/esphome/components/tsl2591/tsl2591.cpp +++ b/esphome/components/tsl2591/tsl2591.cpp @@ -269,7 +269,7 @@ uint32_t TSL2591Component::get_combined_illuminance() { break; } // we only log this if we need any delay, since normally we don't - ESP_LOGD(TAG, " after %3d ms: ADC valid? %s", d, avalid ? "true" : "false"); + ESP_LOGD(TAG, " after %3d ms: ADC valid? %s", d, avalid ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false")); delay(mini_delay); } if (!avalid) { diff --git a/esphome/components/tuya/select/tuya_select.cpp b/esphome/components/tuya/select/tuya_select.cpp index f0fc47f504..057f7f8ea6 100644 --- a/esphome/components/tuya/select/tuya_select.cpp +++ b/esphome/components/tuya/select/tuya_select.cpp @@ -39,7 +39,7 @@ void TuyaSelect::dump_config() { " Select has datapoint ID %u\n" " Data type: %s\n" " Options are:", - this->select_id_, this->is_int_ ? "int" : "enum"); + this->select_id_, this->is_int_ ? LOG_STR_LITERAL("int") : LOG_STR_LITERAL("enum")); const auto &options = this->traits.get_options(); for (size_t i = 0; i < this->mappings_.size(); i++) { ESP_LOGCONFIG(TAG, " %i: %s", this->mappings_.at(i), options.at(i)); diff --git a/esphome/components/tuya/tuya.cpp b/esphome/components/tuya/tuya.cpp index 15ab4b6dc3..82fb96d787 100644 --- a/esphome/components/tuya/tuya.cpp +++ b/esphome/components/tuya/tuya.cpp @@ -259,7 +259,7 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff st.payload[0] = 0x04; this->send_command_(st); ESP_LOGI(TAG, "%s received (%s), replied with WIFI_STATE confirming connection established", - is_select ? "WIFI_SELECT" : "WIFI_RESET", mode_str); + is_select ? LOG_STR_LITERAL("WIFI_SELECT") : LOG_STR_LITERAL("WIFI_RESET"), mode_str); break; } case TuyaCommandType::DATAPOINT_DELIVER: diff --git a/esphome/components/tuya/water_heater/__init__.py b/esphome/components/tuya/water_heater/__init__.py new file mode 100644 index 0000000000..7d1af791b4 --- /dev/null +++ b/esphome/components/tuya/water_heater/__init__.py @@ -0,0 +1,120 @@ +import esphome.codegen as cg +from esphome.components import water_heater +import esphome.config_validation as cv +from esphome.const import CONF_SUPPORTED_MODES, CONF_SWITCH_DATAPOINT +from esphome.types import ConfigType + +from .. import CONF_TUYA_ID, Tuya, tuya_ns + +DEPENDENCIES = ["tuya"] +CODEOWNERS = ["@iago-veiga"] + +CONF_TARGET_TEMPERATURE_DATAPOINT = "target_temperature_datapoint" +CONF_CURRENT_TEMPERATURE_DATAPOINT = "current_temperature_datapoint" +CONF_TARGET_TEMPERATURE_MULTIPLIER = "target_temperature_multiplier" +CONF_CURRENT_TEMPERATURE_MULTIPLIER = "current_temperature_multiplier" +CONF_MODE_DATAPOINT = "mode_datapoint" + +# Optional enum values that map a Tuya mode datapoint value to a WaterHeaterMode. +# Mirrors the "*_value" style used by the tuya climate fan modes. +CONF_ECO_VALUE = "eco_value" +CONF_ELECTRIC_VALUE = "electric_value" +CONF_PERFORMANCE_VALUE = "performance_value" +CONF_HIGH_DEMAND_VALUE = "high_demand_value" +CONF_HEAT_PUMP_VALUE = "heat_pump_value" +CONF_GAS_VALUE = "gas_value" + +# Map of config key -> C++ setter name, one per non-OFF WaterHeaterMode. OFF is not an enum +# value: it is represented by the switch datapoint being off, just like the tuya climate. +MODE_VALUES = { + CONF_ECO_VALUE: "set_eco_value", + CONF_ELECTRIC_VALUE: "set_electric_value", + CONF_PERFORMANCE_VALUE: "set_performance_value", + CONF_HIGH_DEMAND_VALUE: "set_high_demand_value", + CONF_HEAT_PUMP_VALUE: "set_heat_pump_value", + CONF_GAS_VALUE: "set_gas_value", +} + +TuyaWaterHeater = tuya_ns.class_( + "TuyaWaterHeater", water_heater.WaterHeater, cg.Component +) + + +def _validate(config: ConfigType) -> ConfigType: + # A mode datapoint is only useful if at least one mode value is mapped, and mode values + # only make sense together with a mode datapoint. + has_mode_values = any(key in config for key in MODE_VALUES) + if CONF_MODE_DATAPOINT in config and not has_mode_values: + raise cv.Invalid( + f"'{CONF_MODE_DATAPOINT}' requires at least one mode value " + f"(e.g. '{CONF_ECO_VALUE}' or '{CONF_ELECTRIC_VALUE}')" + ) + if has_mode_values and CONF_MODE_DATAPOINT not in config: + raise cv.Invalid(f"Mode values require '{CONF_MODE_DATAPOINT}' to be set") + return config + + +CONFIG_SCHEMA = cv.All( + water_heater.water_heater_schema(TuyaWaterHeater) + .extend( + { + cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya), + cv.Required(CONF_SWITCH_DATAPOINT): cv.uint8_t, + cv.Optional(CONF_TARGET_TEMPERATURE_DATAPOINT): cv.uint8_t, + cv.Optional(CONF_CURRENT_TEMPERATURE_DATAPOINT): cv.uint8_t, + cv.Optional( + CONF_TARGET_TEMPERATURE_MULTIPLIER, default=1.0 + ): cv.positive_float, + cv.Optional( + CONF_CURRENT_TEMPERATURE_MULTIPLIER, default=1.0 + ): cv.positive_float, + cv.Optional(CONF_MODE_DATAPOINT): cv.uint8_t, + cv.Optional(CONF_ECO_VALUE): cv.uint8_t, + cv.Optional(CONF_ELECTRIC_VALUE): cv.uint8_t, + cv.Optional(CONF_PERFORMANCE_VALUE): cv.uint8_t, + cv.Optional(CONF_HIGH_DEMAND_VALUE): cv.uint8_t, + cv.Optional(CONF_HEAT_PUMP_VALUE): cv.uint8_t, + cv.Optional(CONF_GAS_VALUE): cv.uint8_t, + cv.Optional(CONF_SUPPORTED_MODES): cv.ensure_list( + water_heater.validate_water_heater_mode + ), + } + ) + .extend(cv.COMPONENT_SCHEMA), + _validate, +) + + +async def to_code(config: ConfigType) -> None: + var = await water_heater.new_water_heater(config) + await cg.register_component(var, config) + + paren = await cg.get_variable(config[CONF_TUYA_ID]) + cg.add(var.set_tuya_parent(paren)) + + cg.add(var.set_switch_id(config[CONF_SWITCH_DATAPOINT])) + + if (target_temp_dp := config.get(CONF_TARGET_TEMPERATURE_DATAPOINT)) is not None: + cg.add(var.set_target_temperature_id(target_temp_dp)) + if (current_temp_dp := config.get(CONF_CURRENT_TEMPERATURE_DATAPOINT)) is not None: + cg.add(var.set_current_temperature_id(current_temp_dp)) + + cg.add( + var.set_target_temperature_multiplier( + config[CONF_TARGET_TEMPERATURE_MULTIPLIER] + ) + ) + cg.add( + var.set_current_temperature_multiplier( + config[CONF_CURRENT_TEMPERATURE_MULTIPLIER] + ) + ) + + if (mode_dp := config.get(CONF_MODE_DATAPOINT)) is not None: + cg.add(var.set_mode_id(mode_dp)) + for key, setter in MODE_VALUES.items(): + if (value := config.get(key)) is not None: + cg.add(getattr(var, setter)(value)) + + if (supported_modes := config.get(CONF_SUPPORTED_MODES)) is not None: + cg.add(var.set_supported_modes(supported_modes)) diff --git a/esphome/components/tuya/water_heater/tuya_water_heater.cpp b/esphome/components/tuya/water_heater/tuya_water_heater.cpp new file mode 100644 index 0000000000..e1c78530e3 --- /dev/null +++ b/esphome/components/tuya/water_heater/tuya_water_heater.cpp @@ -0,0 +1,194 @@ +#include "tuya_water_heater.h" +#include "esphome/core/log.h" + +namespace esphome::tuya { + +static const char *const TAG = "tuya.water_heater"; + +void TuyaWaterHeater::setup() { + if (this->switch_id_.has_value()) { + this->parent_->register_listener(*this->switch_id_, [this](const TuyaDatapoint &datapoint) { + ESP_LOGV(TAG, "MCU reported switch is: %s", ONOFF(datapoint.value_bool)); + this->is_on_ = datapoint.value_bool; + this->set_state_flag_(water_heater::WATER_HEATER_STATE_ON, this->is_on_); + if (!this->is_on_) { + this->set_mode_(water_heater::WATER_HEATER_MODE_OFF); + } else { + // Turned on: use the last mode reported by the mode datapoint if we have one, otherwise + // fall back to a supported mode. Datapoints can arrive in any order, so the mode enum may + // have been reported before this switch update. + this->set_mode_(this->last_reported_mode_.value_or(this->default_on_mode_())); + } + this->publish_state(); + }); + } + + if (this->mode_id_.has_value()) { + this->parent_->register_listener(*this->mode_id_, [this](const TuyaDatapoint &datapoint) { + ESP_LOGV(TAG, "MCU reported mode value is: %u", datapoint.value_enum); + water_heater::WaterHeaterMode mode; + if (!this->mode_from_value_(datapoint.value_enum, mode)) { + return; + } + // Always remember the reported mode; only surface it while the heater is on (OFF is driven + // by the switch datapoint, not the mode enum). + this->last_reported_mode_ = mode; + if (this->is_on_ && this->mode_ != mode) { + this->set_mode_(mode); + this->publish_state(); + } + }); + } + + if (this->target_temperature_id_.has_value()) { + this->parent_->register_listener(*this->target_temperature_id_, [this](const TuyaDatapoint &datapoint) { + float value = datapoint.value_int * this->target_temperature_multiplier_; + ESP_LOGV(TAG, "MCU reported target temperature is: %.1f", value); + this->set_target_temperature_(value); + this->publish_state(); + }); + } + + if (this->current_temperature_id_.has_value()) { + this->parent_->register_listener(*this->current_temperature_id_, [this](const TuyaDatapoint &datapoint) { + float value = datapoint.value_int * this->current_temperature_multiplier_; + ESP_LOGV(TAG, "MCU reported current temperature is: %.1f", value); + this->set_current_temperature(value); + this->publish_state(); + }); + } +} + +water_heater::WaterHeaterCallInternal TuyaWaterHeater::make_call() { + return water_heater::WaterHeaterCallInternal(this); +} + +void TuyaWaterHeater::control(const water_heater::WaterHeaterCall &call) { + auto mode_val = call.get_mode(); + auto on_val = call.get_on(); + + // Determine the desired on/off state. An explicit on/off request wins; otherwise a mode of + // OFF means off and any other mode means on. + optional want_on = on_val; + if (mode_val.has_value() && !want_on.has_value()) { + want_on = *mode_val != water_heater::WATER_HEATER_MODE_OFF; + } + + if (want_on.has_value() && this->switch_id_.has_value()) { + ESP_LOGV(TAG, "Setting switch: %s", ONOFF(*want_on)); + this->parent_->set_boolean_datapoint_value(*this->switch_id_, *want_on); + } + + if (mode_val.has_value() && *mode_val != water_heater::WATER_HEATER_MODE_OFF && this->mode_id_.has_value()) { + uint8_t value; + if (this->value_from_mode_(*mode_val, value)) { + ESP_LOGV(TAG, "Setting mode value: %u", value); + this->parent_->set_enum_datapoint_value(*this->mode_id_, value); + } else { + ESP_LOGW(TAG, "No mode value configured for requested mode"); + } + } + + auto target_temp = call.get_target_temperature(); + if (!std::isnan(target_temp) && this->target_temperature_id_.has_value()) { + ESP_LOGV(TAG, "Setting target temperature: %.1f", target_temp); + this->parent_->set_integer_datapoint_value(*this->target_temperature_id_, + (int) (target_temp / this->target_temperature_multiplier_)); + } +} + +water_heater::WaterHeaterTraits TuyaWaterHeater::traits() { + water_heater::WaterHeaterTraits traits; + + traits.add_feature_flags(water_heater::WATER_HEATER_SUPPORTS_ON_OFF); + if (this->current_temperature_id_.has_value()) { + traits.add_feature_flags(water_heater::WATER_HEATER_SUPPORTS_CURRENT_TEMPERATURE); + } + if (this->target_temperature_id_.has_value()) { + traits.add_feature_flags(water_heater::WATER_HEATER_SUPPORTS_TARGET_TEMPERATURE); + } + if (!this->supported_modes_.empty()) { + traits.set_supported_modes(this->supported_modes_); + traits.add_feature_flags(water_heater::WATER_HEATER_SUPPORTS_OPERATION_MODE); + } + return traits; +} + +bool TuyaWaterHeater::mode_from_value_(uint8_t value, water_heater::WaterHeaterMode &mode) const { + if (this->eco_value_ == value) { + mode = water_heater::WATER_HEATER_MODE_ECO; + } else if (this->electric_value_ == value) { + mode = water_heater::WATER_HEATER_MODE_ELECTRIC; + } else if (this->performance_value_ == value) { + mode = water_heater::WATER_HEATER_MODE_PERFORMANCE; + } else if (this->high_demand_value_ == value) { + mode = water_heater::WATER_HEATER_MODE_HIGH_DEMAND; + } else if (this->heat_pump_value_ == value) { + mode = water_heater::WATER_HEATER_MODE_HEAT_PUMP; + } else if (this->gas_value_ == value) { + mode = water_heater::WATER_HEATER_MODE_GAS; + } else { + return false; + } + return true; +} + +bool TuyaWaterHeater::value_from_mode_(water_heater::WaterHeaterMode mode, uint8_t &value) const { + optional mapped; + switch (mode) { + case water_heater::WATER_HEATER_MODE_ECO: + mapped = this->eco_value_; + break; + case water_heater::WATER_HEATER_MODE_ELECTRIC: + mapped = this->electric_value_; + break; + case water_heater::WATER_HEATER_MODE_PERFORMANCE: + mapped = this->performance_value_; + break; + case water_heater::WATER_HEATER_MODE_HIGH_DEMAND: + mapped = this->high_demand_value_; + break; + case water_heater::WATER_HEATER_MODE_HEAT_PUMP: + mapped = this->heat_pump_value_; + break; + case water_heater::WATER_HEATER_MODE_GAS: + mapped = this->gas_value_; + break; + default: + break; + } + if (mapped.has_value()) { + value = *mapped; + return true; + } + return false; +} + +water_heater::WaterHeaterMode TuyaWaterHeater::default_on_mode_() const { + // Prefer the first configured supported non-OFF mode so we never surface a mode the user + // cannot control. Fall back to ELECTRIC when no supported modes are configured. + for (water_heater::WaterHeaterMode mode : this->supported_modes_) { + if (mode != water_heater::WATER_HEATER_MODE_OFF) { + return mode; + } + } + return water_heater::WATER_HEATER_MODE_ELECTRIC; +} + +void TuyaWaterHeater::dump_config() { + LOG_WATER_HEATER("", "Tuya Water Heater", this); + if (this->switch_id_.has_value()) { + ESP_LOGCONFIG(TAG, " Switch has datapoint ID %u", *this->switch_id_); + } + if (this->mode_id_.has_value()) { + ESP_LOGCONFIG(TAG, " Mode has datapoint ID %u", *this->mode_id_); + } + if (this->target_temperature_id_.has_value()) { + ESP_LOGCONFIG(TAG, " Target Temperature has datapoint ID %u", *this->target_temperature_id_); + } + if (this->current_temperature_id_.has_value()) { + ESP_LOGCONFIG(TAG, " Current Temperature has datapoint ID %u", *this->current_temperature_id_); + } +} + +} // namespace esphome::tuya diff --git a/esphome/components/tuya/water_heater/tuya_water_heater.h b/esphome/components/tuya/water_heater/tuya_water_heater.h new file mode 100644 index 0000000000..5ce0ce4dee --- /dev/null +++ b/esphome/components/tuya/water_heater/tuya_water_heater.h @@ -0,0 +1,73 @@ +#pragma once + +#include "esphome/core/component.h" +#include "esphome/components/tuya/tuya.h" +#include "esphome/components/water_heater/water_heater.h" + +namespace esphome::tuya { + +class TuyaWaterHeater final : public water_heater::WaterHeater, public Component { + public: + void setup() override; + void dump_config() override; + + void set_tuya_parent(Tuya *parent) { this->parent_ = parent; } + + void set_switch_id(uint8_t switch_id) { this->switch_id_ = switch_id; } + void set_target_temperature_id(uint8_t target_temperature_id) { + this->target_temperature_id_ = target_temperature_id; + } + void set_current_temperature_id(uint8_t current_temperature_id) { + this->current_temperature_id_ = current_temperature_id; + } + void set_target_temperature_multiplier(float multiplier) { this->target_temperature_multiplier_ = multiplier; } + void set_current_temperature_multiplier(float multiplier) { this->current_temperature_multiplier_ = multiplier; } + + void set_mode_id(uint8_t mode_id) { this->mode_id_ = mode_id; } + void set_eco_value(uint8_t value) { this->eco_value_ = value; } + void set_electric_value(uint8_t value) { this->electric_value_ = value; } + void set_performance_value(uint8_t value) { this->performance_value_ = value; } + void set_high_demand_value(uint8_t value) { this->high_demand_value_ = value; } + void set_heat_pump_value(uint8_t value) { this->heat_pump_value_ = value; } + void set_gas_value(uint8_t value) { this->gas_value_ = value; } + + void set_supported_modes(const std::initializer_list &modes) { + this->supported_modes_ = modes; + } + + water_heater::WaterHeaterCallInternal make_call() override; + + protected: + void control(const water_heater::WaterHeaterCall &call) override; + water_heater::WaterHeaterTraits traits() override; + + /// Map a Tuya mode datapoint enum value to a WaterHeaterMode. Returns true when a mapping + /// exists, writing the result to \p mode. + bool mode_from_value_(uint8_t value, water_heater::WaterHeaterMode &mode) const; + /// Map a WaterHeaterMode to its configured Tuya enum value. Returns true when a mapping exists. + bool value_from_mode_(water_heater::WaterHeaterMode mode, uint8_t &value) const; + + Tuya *parent_{nullptr}; + optional switch_id_{}; + optional target_temperature_id_{}; + optional current_temperature_id_{}; + optional mode_id_{}; + optional eco_value_{}; + optional electric_value_{}; + optional performance_value_{}; + optional high_demand_value_{}; + optional heat_pump_value_{}; + optional gas_value_{}; + float target_temperature_multiplier_{1.0f}; + float current_temperature_multiplier_{1.0f}; + water_heater::WaterHeaterModeMask supported_modes_; + /// Last non-OFF mode reported by the mode datapoint, applied when the heater turns on. + optional last_reported_mode_{}; + bool is_on_{false}; + + /// The mode to show when the heater is on but no mode datapoint value is known yet: the last + /// reported mode, else the first configured supported non-OFF mode, else ELECTRIC. + water_heater::WaterHeaterMode default_on_mode_() const; +}; + +} // namespace esphome::tuya diff --git a/esphome/components/udp/udp_component.cpp b/esphome/components/udp/udp_component.cpp index c144212ecf..858516c746 100644 --- a/esphome/components/udp/udp_component.cpp +++ b/esphome/components/udp/udp_component.cpp @@ -129,8 +129,9 @@ void UDPComponent::dump_config() { " Listen Port: %u\n" " Broadcast Port: %u", this->listen_port_, this->broadcast_port_); - for (const char *address : this->addresses_) + for (const char *address : this->addresses_) { ESP_LOGCONFIG(TAG, " Address: %s", address); + } if (this->listen_address_.has_value()) { char addr_buf[network::IP_ADDRESS_BUFFER_SIZE]; ESP_LOGCONFIG(TAG, " Listen address: %s", this->listen_address_.value().str_to(addr_buf)); @@ -145,8 +146,9 @@ void UDPComponent::send_packet(const uint8_t *data, size_t size) { #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS) for (const auto &saddr : this->sockaddrs_) { auto result = this->broadcast_socket_->sendto(data, size, 0, &saddr, sizeof(saddr)); - if (result < 0) + if (result < 0) { ESP_LOGW(TAG, "sendto() error %d", errno); + } } #endif #ifdef USE_SOCKET_IMPL_LWIP_TCP @@ -155,8 +157,9 @@ void UDPComponent::send_packet(const uint8_t *data, size_t size) { if (this->udp_client_.beginPacketMulticast(saddr, this->broadcast_port_, iface, 128) != 0) { this->udp_client_.write(data, size); auto result = this->udp_client_.endPacket(); - if (result == 0) + if (result == 0) { ESP_LOGW(TAG, "udp.write() error"); + } } } #endif diff --git a/esphome/components/uponor_smatrix/uponor_smatrix.cpp b/esphome/components/uponor_smatrix/uponor_smatrix.cpp index 0ba19f5cd7..c77f3468c7 100644 --- a/esphome/components/uponor_smatrix/uponor_smatrix.cpp +++ b/esphome/components/uponor_smatrix/uponor_smatrix.cpp @@ -110,8 +110,9 @@ bool UponorSmatrixComponent::parse_byte_(uint8_t byte) { // Handle packet size_t data_len = (packet_len - 6) / 3; if (data_len == 0) { - if (packet[4] == UPONOR_ID_REQUEST) + if (packet[4] == UPONOR_ID_REQUEST) { ESP_LOGVV(TAG, "Ignoring request packet for device 0x%08" PRIX32 "", device_address); + } return true; } diff --git a/esphome/components/usb_uart/pl2303.cpp b/esphome/components/usb_uart/pl2303.cpp index a9f7348331..db177fd308 100644 --- a/esphome/components/usb_uart/pl2303.cpp +++ b/esphome/components/usb_uart/pl2303.cpp @@ -194,8 +194,9 @@ std::vector USBUartTypePL2303::parse_descriptors(usb_device_handle_t dev } } - if (cdc_devs.empty()) + if (cdc_devs.empty()) { ESP_LOGE(TAG, "PL2303: failed to find bulk IN+OUT endpoints"); + } return cdc_devs; } diff --git a/esphome/components/veml7700/veml7700.cpp b/esphome/components/veml7700/veml7700.cpp index 594c9da170..6c609f4fe7 100644 --- a/esphome/components/veml7700/veml7700.cpp +++ b/esphome/components/veml7700/veml7700.cpp @@ -259,7 +259,7 @@ ErrorCode VEML7700Component::configure_() { ErrorCode VEML7700Component::reconfigure_time_and_gain_(IntegrationTime time, Gain gain, bool shutdown) { ESP_LOGV(TAG, "Reconfigure time and gain (%d ms, %s) %s", get_itime_ms(time), get_gain_str(gain), - shutdown ? "Shutting down" : "Turning back on"); + shutdown ? LOG_STR_LITERAL("Shutting down") : LOG_STR_LITERAL("Turning back on")); ConfigurationRegister als_conf{0}; als_conf.raw = 0; @@ -272,7 +272,7 @@ ErrorCode VEML7700Component::reconfigure_time_and_gain_(IntegrationTime time, Ga als_conf.ALS_GAIN = gain; auto err = this->write_register((uint8_t) CommandRegisters::ALS_CONF_0, als_conf.raw_bytes, VEML_REG_SIZE); if (err != i2c::ERROR_OK) { - ESP_LOGW(TAG, "%s failed", shutdown ? "Shutdown" : "Turn on"); + ESP_LOGW(TAG, "%s failed", shutdown ? LOG_STR_LITERAL("Shutdown") : LOG_STR_LITERAL("Turn on")); } return err; @@ -363,8 +363,8 @@ void VEML7700Component::apply_lux_calculation_(Readings &data) { data.fake_infrared_lux = reduce_to_zero(data.white_lux, data.als_lux); ESP_LOGV(TAG, "%s mode - ALS = %.1f lx, WHITE = %.1f lx, FAKE_IR = %.1f lx", - this->automatic_mode_enabled_ ? "Automatic" : "Manual", data.als_lux, data.white_lux, - data.fake_infrared_lux); + this->automatic_mode_enabled_ ? LOG_STR_LITERAL("Automatic") : LOG_STR_LITERAL("Manual"), data.als_lux, + data.white_lux, data.fake_infrared_lux); } void VEML7700Component::apply_lux_compensation_(Readings &data) { diff --git a/esphome/components/vl53l0x/vl53l0x_sensor.cpp b/esphome/components/vl53l0x/vl53l0x_sensor.cpp index df7929f676..49eb3d00a1 100644 --- a/esphome/components/vl53l0x/vl53l0x_sensor.cpp +++ b/esphome/components/vl53l0x/vl53l0x_sensor.cpp @@ -31,7 +31,8 @@ void VL53L0XSensor::dump_config() { ESP_LOGCONFIG(TAG, " Timeout: %" PRIu32 "%s\n" " Timing Budget %" PRIu32 "us ", - this->timeout_us_, this->timeout_us_ > 0 ? "us" : " (no timeout)", this->measurement_timing_budget_us_); + this->timeout_us_, this->timeout_us_ > 0 ? LOG_STR_LITERAL("us") : LOG_STR_LITERAL(" (no timeout)"), + this->measurement_timing_budget_us_); } void VL53L0XSensor::setup() { diff --git a/esphome/components/wake_on_lan/wake_on_lan.cpp b/esphome/components/wake_on_lan/wake_on_lan.cpp index a514a55d80..e46b96c86a 100644 --- a/esphome/components/wake_on_lan/wake_on_lan.cpp +++ b/esphome/components/wake_on_lan/wake_on_lan.cpp @@ -40,8 +40,9 @@ void WakeOnLanButton::press_action() { memcpy(buffer + i * sizeof(this->macaddr_) + sizeof(PREFIX), this->macaddr_, sizeof(this->macaddr_)); } if (this->broadcast_socket_->sendto(buffer, sizeof(buffer), 0, reinterpret_cast(&saddr), - addr_len) <= 0) + addr_len) <= 0) { ESP_LOGW(TAG, "sendto() error %d", errno); + } #else IPAddress broadcast = IPAddress(255, 255, 255, 255); for (auto ip : esphome::network::get_ip_addresses()) { diff --git a/esphome/components/water_heater/water_heater.cpp b/esphome/components/water_heater/water_heater.cpp index 9862253ad9..1dc2d008a1 100644 --- a/esphome/components/water_heater/water_heater.cpp +++ b/esphome/components/water_heater/water_heater.cpp @@ -100,10 +100,11 @@ void WaterHeaterCall::perform() { ESP_LOGV(TAG, " Target Temperature High: %.2f", this->target_temperature_high_); } if (this->state_mask_ & WATER_HEATER_STATE_AWAY) { - ESP_LOGV(TAG, " Away: %s", (this->state_ & WATER_HEATER_STATE_AWAY) ? "YES" : "NO"); + ESP_LOGV(TAG, " Away: %s", + (this->state_ & WATER_HEATER_STATE_AWAY) ? LOG_STR_LITERAL("YES") : LOG_STR_LITERAL("NO")); } if (this->state_mask_ & WATER_HEATER_STATE_ON) { - ESP_LOGV(TAG, " On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? "YES" : "NO"); + ESP_LOGV(TAG, " On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? LOG_STR_LITERAL("YES") : LOG_STR_LITERAL("NO")); } this->parent_->control(*this); } @@ -178,7 +179,7 @@ void WaterHeater::publish_state() { ESP_LOGV(TAG, " Away: YES"); } if (traits.has_feature_flags(WATER_HEATER_SUPPORTS_ON_OFF)) { - ESP_LOGV(TAG, " On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? "YES" : "NO"); + ESP_LOGV(TAG, " On: %s", (this->state_ & WATER_HEATER_STATE_ON) ? LOG_STR_LITERAL("YES") : LOG_STR_LITERAL("NO")); } #if defined(USE_WATER_HEATER) && defined(USE_CONTROLLER_REGISTRY) diff --git a/esphome/components/web_server/server_index_v2.h b/esphome/components/web_server/server_index_v2.h index 0c1a6c7f79..83684b1d88 100644 --- a/esphome/components/web_server/server_index_v2.h +++ b/esphome/components/web_server/server_index_v2.h @@ -10,1310 +10,1289 @@ namespace esphome::web_server { #ifdef USE_WEBSERVER_GZIP constexpr uint8_t INDEX_GZ[] PROGMEM = { - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xed, 0x7d, 0xdb, 0x72, 0xdb, 0xc6, 0xb6, 0xe0, 0xf3, - 0xe4, 0x2b, 0x20, 0x44, 0x5b, 0x46, 0x87, 0x4d, 0xf0, 0x22, 0xc9, 0x96, 0x41, 0x35, 0xb9, 0x65, 0xd9, 0xd9, 0xf6, - 0x8e, 0x6f, 0xdb, 0xb2, 0x73, 0x53, 0xb8, 0x25, 0x08, 0x68, 0x12, 0x1d, 0x83, 0x00, 0x03, 0x34, 0x45, 0x29, 0x24, - 0x4e, 0xcd, 0x07, 0x4c, 0xd5, 0x54, 0xcd, 0xd3, 0xbc, 0x4c, 0xcd, 0x79, 0x98, 0x8f, 0x98, 0xe7, 0xf3, 0x29, 0xe7, - 0x07, 0x66, 0x3e, 0x61, 0x6a, 0xf5, 0x05, 0x68, 0xf0, 0x22, 0xcb, 0x49, 0xf6, 0x39, 0xe7, 0x61, 0x2a, 0x15, 0x99, - 0x68, 0xf4, 0x65, 0xf5, 0xea, 0xd5, 0xeb, 0xde, 0x8d, 0xe3, 0x9d, 0x30, 0x0d, 0xf8, 0xed, 0x94, 0x5a, 0x11, 0x9f, - 0xc4, 0xfd, 0x63, 0xf5, 0x97, 0xfa, 0x61, 0xff, 0x38, 0x66, 0xc9, 0x47, 0x2b, 0xa3, 0x31, 0x61, 0x41, 0x9a, 0x58, - 0x51, 0x46, 0x47, 0x24, 0xf4, 0xb9, 0xef, 0xb1, 0x89, 0x3f, 0xa6, 0x56, 0xab, 0x7f, 0x3c, 0xa1, 0xdc, 0xb7, 0x82, - 0xc8, 0xcf, 0x72, 0xca, 0xc9, 0x87, 0xf7, 0x5f, 0x37, 0x8f, 0xfa, 0xc7, 0x79, 0x90, 0xb1, 0x29, 0xb7, 0xa0, 0x4b, - 0x32, 0x49, 0xc3, 0x59, 0x4c, 0xfb, 0xad, 0xd6, 0x7c, 0x3e, 0x77, 0x7f, 0xce, 0xbf, 0x08, 0xd2, 0x24, 0xe7, 0xd6, - 0x53, 0x32, 0x67, 0x49, 0x98, 0xce, 0x71, 0xc2, 0xc9, 0x53, 0xf7, 0x2c, 0xf2, 0xc3, 0x74, 0xfe, 0x2e, 0x4d, 0xf9, - 0xde, 0x9e, 0x23, 0x1f, 0x6f, 0x4f, 0xcf, 0xce, 0x08, 0x21, 0xd7, 0x29, 0x0b, 0xad, 0xf6, 0x72, 0x59, 0x15, 0xba, - 0x89, 0xcf, 0xd9, 0x35, 0x95, 0x4d, 0xd0, 0xde, 0x9e, 0xed, 0x87, 0xe9, 0x94, 0xd3, 0xf0, 0x8c, 0xdf, 0xc6, 0xf4, - 0x2c, 0xa2, 0x94, 0xe7, 0x36, 0x4b, 0xac, 0xa7, 0x69, 0x30, 0x9b, 0xd0, 0x84, 0xbb, 0xd3, 0x2c, 0xe5, 0x29, 0x40, - 0xb2, 0xb7, 0x67, 0x67, 0x74, 0x1a, 0xfb, 0x01, 0x85, 0xf7, 0xa7, 0x67, 0x67, 0x55, 0x8b, 0xaa, 0x12, 0xce, 0x39, - 0x39, 0xbb, 0x9d, 0x5c, 0xa5, 0xb1, 0x83, 0x70, 0xc4, 0x49, 0x42, 0xe7, 0xd6, 0x77, 0xd4, 0xff, 0xf8, 0xca, 0x9f, - 0xf6, 0x82, 0xd8, 0xcf, 0x73, 0xeb, 0x84, 0x2f, 0xc4, 0x14, 0xb2, 0x59, 0xc0, 0xd3, 0xcc, 0xe1, 0x98, 0x62, 0x86, - 0x16, 0x6c, 0xe4, 0xf0, 0x88, 0xe5, 0xee, 0xc5, 0x6e, 0x90, 0xe7, 0xef, 0x68, 0x3e, 0x8b, 0xf9, 0x2e, 0xd9, 0x69, - 0x63, 0xb6, 0x43, 0x48, 0xce, 0x11, 0x8f, 0xb2, 0x74, 0x6e, 0x3d, 0xcb, 0xb2, 0x34, 0x73, 0xec, 0xd3, 0xb3, 0x33, - 0x59, 0xc3, 0x62, 0xb9, 0x95, 0xa4, 0xdc, 0x2a, 0xfb, 0xf3, 0xaf, 0x62, 0xea, 0x5a, 0x1f, 0x72, 0x6a, 0x5d, 0xce, - 0x92, 0xdc, 0x1f, 0xd1, 0xd3, 0xb3, 0xb3, 0x4b, 0x2b, 0xcd, 0xac, 0xcb, 0x20, 0xcf, 0x2f, 0x2d, 0x96, 0xe4, 0x9c, - 0xfa, 0xa1, 0x6b, 0xa3, 0x9e, 0x18, 0x2c, 0xc8, 0xf3, 0xf7, 0xf4, 0x86, 0x13, 0x8e, 0xc5, 0x23, 0x27, 0xb4, 0x18, - 0x53, 0x6e, 0xe5, 0xe5, 0xbc, 0x1c, 0xb4, 0x88, 0x29, 0xb7, 0x38, 0x11, 0xef, 0xd3, 0x9e, 0xc4, 0x3d, 0x95, 0x8f, - 0xbc, 0xc7, 0x46, 0x4e, 0xc2, 0xf7, 0xf6, 0x78, 0x89, 0x67, 0x24, 0xa7, 0x66, 0x31, 0x42, 0x77, 0x74, 0xd9, 0xde, - 0x1e, 0x75, 0x63, 0x9a, 0x8c, 0x79, 0x44, 0x08, 0xe9, 0xf4, 0xd8, 0xde, 0x9e, 0xc3, 0x49, 0xc4, 0xdd, 0x31, 0xe5, - 0x0e, 0x45, 0x08, 0x57, 0xad, 0xf7, 0xf6, 0x1c, 0x89, 0x84, 0x94, 0x48, 0xc4, 0xd5, 0x70, 0x8c, 0x5c, 0x85, 0xfd, - 0xb3, 0xdb, 0x24, 0x70, 0x4c, 0xf8, 0x11, 0x66, 0x7b, 0x7b, 0x11, 0x77, 0x73, 0xe8, 0x11, 0x73, 0x84, 0x8a, 0x8c, - 0xf2, 0x59, 0x96, 0x58, 0xbc, 0xe0, 0xe9, 0x19, 0xcf, 0x58, 0x32, 0x76, 0xd0, 0x42, 0x97, 0x19, 0x0d, 0x8b, 0x42, - 0x82, 0xfb, 0x8e, 0x93, 0x9c, 0xf4, 0x61, 0xc4, 0x13, 0xee, 0xc0, 0x2a, 0xa6, 0x23, 0x2b, 0x27, 0xc4, 0xce, 0x45, - 0x5b, 0x7b, 0x90, 0x7b, 0x79, 0xc3, 0xb6, 0xb1, 0x84, 0x12, 0xe7, 0x1c, 0xe1, 0x8f, 0xc4, 0xc9, 0xb1, 0xeb, 0xba, - 0x1c, 0x91, 0xfe, 0x42, 0x63, 0x25, 0x37, 0xe6, 0x39, 0xc8, 0xcf, 0xdb, 0x43, 0x8f, 0xbb, 0x19, 0x0d, 0x67, 0x01, - 0x75, 0x1c, 0x86, 0x13, 0x9c, 0x21, 0xd2, 0x67, 0x0d, 0x27, 0x25, 0x7d, 0x58, 0xee, 0xb4, 0xbe, 0xd6, 0x84, 0xec, - 0xb4, 0x91, 0x82, 0x31, 0xd5, 0x00, 0x02, 0x86, 0x15, 0x3c, 0x29, 0x21, 0x76, 0x32, 0x9b, 0x5c, 0xd1, 0xcc, 0x2e, - 0xab, 0xf5, 0x6a, 0x64, 0x31, 0xcb, 0xa9, 0x15, 0xe4, 0xb9, 0x35, 0x9a, 0x25, 0x01, 0x67, 0x69, 0x62, 0xd9, 0x8d, - 0xb4, 0x61, 0x4b, 0x72, 0x28, 0xa9, 0xc1, 0x46, 0x05, 0x72, 0x12, 0xd4, 0xc8, 0xcf, 0xb3, 0x46, 0x67, 0x88, 0x01, - 0x4a, 0xd4, 0x53, 0xfd, 0x29, 0x04, 0x50, 0x9c, 0xc3, 0x1c, 0x0b, 0xfc, 0x84, 0xc3, 0x2c, 0xc5, 0x14, 0x13, 0x3e, - 0xc8, 0xdd, 0xf5, 0x8d, 0x42, 0xb8, 0x3b, 0xf1, 0xa7, 0x0e, 0x25, 0x7d, 0x2a, 0x88, 0xcb, 0x4f, 0x02, 0x80, 0xb5, - 0xb6, 0x6e, 0x03, 0xea, 0x51, 0xb7, 0x22, 0x29, 0xe4, 0x71, 0x77, 0x94, 0x66, 0xcf, 0xfc, 0x20, 0x82, 0x76, 0x25, - 0xc1, 0x84, 0x7a, 0xbf, 0x05, 0x19, 0xf5, 0x39, 0x7d, 0x16, 0x53, 0x78, 0x72, 0x6c, 0xd1, 0xd2, 0x46, 0x38, 0x21, - 0x4f, 0xdd, 0x98, 0xf1, 0xd7, 0x69, 0x12, 0xd0, 0x5e, 0x62, 0x50, 0x17, 0x83, 0x75, 0x3f, 0xe1, 0x3c, 0x63, 0x57, - 0x33, 0x4e, 0x1d, 0x3b, 0x81, 0x1a, 0x36, 0x4e, 0x10, 0x66, 0x2e, 0xa7, 0x37, 0xfc, 0x34, 0x4d, 0x38, 0x4d, 0x38, - 0xa1, 0x1a, 0xa9, 0x38, 0x77, 0xfd, 0xe9, 0x94, 0x26, 0xe1, 0x69, 0xc4, 0xe2, 0xd0, 0x61, 0xa8, 0x40, 0x05, 0x0e, - 0x38, 0x81, 0x39, 0x92, 0x7e, 0xee, 0xc1, 0x9f, 0xed, 0xb3, 0x71, 0x38, 0xe9, 0x8b, 0x4d, 0x41, 0x89, 0x6d, 0xf7, - 0x46, 0x69, 0xe6, 0xa8, 0x19, 0x58, 0xe9, 0xc8, 0xe2, 0x30, 0xc6, 0xbb, 0x59, 0x4c, 0x73, 0x44, 0x1b, 0x84, 0x95, - 0xcb, 0xa8, 0x10, 0xfc, 0x0e, 0x28, 0xbe, 0x40, 0x4e, 0x8e, 0xbc, 0xbc, 0x77, 0xed, 0x67, 0xd6, 0x8f, 0x6a, 0x47, - 0xfd, 0xac, 0xb9, 0x59, 0xc8, 0xc9, 0xcf, 0x2e, 0xcf, 0x66, 0x39, 0xa7, 0xe1, 0xfb, 0xdb, 0x29, 0xcd, 0xf1, 0x73, - 0x4e, 0x42, 0x3e, 0x08, 0xb9, 0x4b, 0x27, 0x53, 0x7e, 0x7b, 0x26, 0x18, 0xa3, 0x67, 0xdb, 0x78, 0x06, 0x35, 0x33, - 0xea, 0x07, 0xc0, 0xcc, 0x14, 0xb6, 0xde, 0xa6, 0xf1, 0xed, 0x88, 0xc5, 0xf1, 0xd9, 0x6c, 0x3a, 0x4d, 0x33, 0x8e, - 0x39, 0x27, 0x0b, 0x9e, 0x56, 0xb8, 0x81, 0xc5, 0x5c, 0xe4, 0x73, 0xc6, 0x83, 0xc8, 0xe1, 0x68, 0x11, 0xf8, 0x39, - 0xb5, 0x9e, 0xa4, 0x69, 0x4c, 0xfd, 0xc4, 0xcb, 0x49, 0x3e, 0x78, 0xce, 0xbd, 0x64, 0x16, 0xc7, 0xbd, 0xab, 0x8c, - 0xfa, 0x1f, 0x7b, 0xe2, 0xf5, 0x9b, 0xab, 0x9f, 0x69, 0xc0, 0x3d, 0xf1, 0xfb, 0x24, 0xcb, 0xfc, 0x5b, 0xa8, 0x48, - 0x08, 0x54, 0x1b, 0xe4, 0xde, 0x5f, 0xcf, 0xde, 0xbc, 0x76, 0xe5, 0x2e, 0x61, 0xa3, 0x5b, 0x27, 0x2f, 0x77, 0x5e, - 0x5e, 0xe0, 0x51, 0x96, 0x4e, 0x56, 0x86, 0x96, 0x68, 0xcb, 0x7b, 0x5b, 0x40, 0xa0, 0x24, 0xdf, 0x91, 0x5d, 0x9b, - 0x10, 0xbc, 0x16, 0x44, 0x0f, 0x2f, 0x89, 0x1a, 0x17, 0xfe, 0x78, 0xb2, 0xd8, 0xc9, 0xd1, 0xdd, 0xd0, 0xf2, 0xec, - 0x76, 0x41, 0x89, 0x80, 0x73, 0x0a, 0x22, 0x06, 0x60, 0x0c, 0x7c, 0x1e, 0x44, 0x0b, 0x2a, 0x3a, 0x2b, 0x34, 0xc4, - 0xb4, 0x28, 0xf0, 0xb3, 0x92, 0xe0, 0x39, 0xb0, 0x5d, 0xc1, 0xa9, 0x08, 0x5f, 0x2e, 0x73, 0x42, 0x72, 0x84, 0xff, - 0x4a, 0x16, 0xbe, 0x9e, 0x8f, 0xb7, 0xd3, 0xc6, 0xb0, 0x31, 0x3d, 0xc9, 0x5e, 0x70, 0x90, 0x26, 0xd7, 0x34, 0xe3, - 0x34, 0xf3, 0x38, 0xc7, 0x19, 0x1d, 0xc5, 0x00, 0xc6, 0x4e, 0x07, 0x47, 0x7e, 0x7e, 0x1a, 0xf9, 0xc9, 0x98, 0x86, - 0xde, 0x33, 0x5e, 0x60, 0xca, 0x89, 0x3d, 0x62, 0x89, 0x1f, 0xb3, 0x5f, 0x69, 0x68, 0x2b, 0x81, 0xf0, 0xcc, 0xa2, - 0x37, 0x9c, 0x26, 0x61, 0x6e, 0x3d, 0x7f, 0xff, 0xea, 0xa5, 0x5a, 0xca, 0x9a, 0x8c, 0x40, 0x8b, 0x7c, 0x36, 0xa5, - 0x99, 0x83, 0xb0, 0x92, 0x11, 0xcf, 0x98, 0xe0, 0x8f, 0xaf, 0xfc, 0xa9, 0x2c, 0x61, 0xf9, 0x87, 0x69, 0xe8, 0x73, - 0xfa, 0x96, 0x26, 0x21, 0x4b, 0xc6, 0x64, 0xa7, 0x23, 0xcb, 0x23, 0x5f, 0xbd, 0x08, 0xcb, 0xa2, 0x8b, 0xdd, 0x67, - 0xb1, 0x98, 0x79, 0xf9, 0x38, 0x73, 0x50, 0x91, 0x73, 0x9f, 0xb3, 0xc0, 0xf2, 0xc3, 0xf0, 0x45, 0xc2, 0x38, 0x13, - 0x00, 0x66, 0xb0, 0x40, 0x40, 0xa5, 0x54, 0x4a, 0x0b, 0x0d, 0xb8, 0x83, 0xb0, 0xe3, 0x28, 0x19, 0x10, 0x21, 0xb5, - 0x62, 0x7b, 0x7b, 0x15, 0xc7, 0x1f, 0x50, 0x4f, 0xbe, 0x24, 0xe7, 0x43, 0xe4, 0x4e, 0x67, 0x39, 0x2c, 0xb5, 0x1e, - 0x02, 0x04, 0x4c, 0x7a, 0x95, 0xd3, 0xec, 0x9a, 0x86, 0x25, 0x79, 0xe4, 0x0e, 0x5a, 0xac, 0x8c, 0xa1, 0x76, 0x06, - 0x27, 0xe7, 0xc3, 0x9e, 0xc9, 0xba, 0xa9, 0x22, 0xf5, 0x2c, 0x9d, 0xd2, 0x8c, 0x33, 0x9a, 0x97, 0xdc, 0xc4, 0x01, - 0x41, 0x5a, 0x72, 0x94, 0x84, 0xe8, 0xf9, 0x4d, 0x1d, 0x86, 0x29, 0xaa, 0xf1, 0x0c, 0x2d, 0x6b, 0x9f, 0x5d, 0x0b, - 0xa1, 0x91, 0x60, 0x86, 0x30, 0x97, 0x90, 0x26, 0x08, 0x15, 0x08, 0x73, 0x0d, 0xae, 0xe4, 0x46, 0x6a, 0xb4, 0x5b, - 0x90, 0xd6, 0xe4, 0xaf, 0x42, 0x5a, 0x03, 0x4f, 0xf3, 0x39, 0xdd, 0xdb, 0x73, 0xa8, 0x5b, 0x92, 0x05, 0xd9, 0xe9, - 0xa8, 0x35, 0x32, 0x90, 0xb5, 0x05, 0x6c, 0x18, 0x98, 0x63, 0x8a, 0xf0, 0x0e, 0x75, 0x93, 0xf4, 0x24, 0x08, 0x68, - 0x9e, 0xa7, 0xd9, 0xde, 0xde, 0x8e, 0xa8, 0x5f, 0x2a, 0x14, 0xb0, 0x86, 0x6f, 0xe6, 0x49, 0x05, 0x01, 0xaa, 0x84, - 0xac, 0x12, 0x0d, 0x1c, 0x44, 0x95, 0xd0, 0x39, 0xec, 0x81, 0xd6, 0x3d, 0x3c, 0xfb, 0xe2, 0xc2, 0x6e, 0x70, 0xac, - 0xd0, 0x30, 0xa6, 0x7a, 0xe8, 0xdb, 0xa7, 0x54, 0x6a, 0x57, 0x42, 0xf7, 0x58, 0xc3, 0x8c, 0xdc, 0x41, 0x6e, 0x48, - 0x47, 0x2c, 0x31, 0xa6, 0x5d, 0x03, 0x09, 0x73, 0x9c, 0xa0, 0xc2, 0x58, 0xd0, 0x8d, 0x5d, 0x0b, 0xb5, 0x46, 0xae, - 0xdc, 0x62, 0x2c, 0x54, 0x09, 0x63, 0x19, 0xcf, 0xe9, 0xb0, 0xc0, 0x02, 0xf5, 0x7a, 0x36, 0x99, 0x00, 0xf4, 0x9c, - 0x0f, 0x7b, 0xea, 0x3d, 0x49, 0x24, 0xe6, 0x32, 0xfa, 0xcb, 0x8c, 0xe6, 0x5c, 0xd2, 0xb1, 0xc3, 0x71, 0x86, 0x19, - 0xf0, 0xeb, 0x34, 0x19, 0xb1, 0xf1, 0x2c, 0x03, 0x8d, 0x07, 0x36, 0x23, 0x4d, 0x66, 0x13, 0xaa, 0x9f, 0x36, 0xc1, - 0xf6, 0x66, 0x0a, 0x32, 0x31, 0x07, 0x9a, 0xbe, 0x9b, 0x9c, 0x00, 0x56, 0x8e, 0x96, 0xcb, 0xbf, 0xea, 0x4e, 0xaa, - 0xa5, 0x2c, 0xb5, 0xb4, 0x95, 0x35, 0xa1, 0x1c, 0x29, 0x99, 0xbc, 0xd3, 0x51, 0xe0, 0xf3, 0x21, 0xd9, 0x69, 0x97, - 0x34, 0xac, 0xb0, 0x2a, 0xc1, 0x91, 0x48, 0x7c, 0x23, 0xbb, 0x42, 0x42, 0xc4, 0xd7, 0xc8, 0xc5, 0x8d, 0xd6, 0x28, - 0x35, 0x22, 0xe7, 0xa0, 0x6c, 0xb8, 0xd1, 0x70, 0x1b, 0x39, 0x69, 0x7e, 0xe0, 0xf0, 0xf5, 0x77, 0x15, 0xdb, 0xb8, - 0xae, 0xb3, 0x8d, 0x95, 0x69, 0xd8, 0xd3, 0xb2, 0x89, 0x5d, 0x52, 0x99, 0xda, 0xe8, 0xd5, 0x2b, 0xcc, 0x04, 0x30, - 0xd5, 0x94, 0x8c, 0x2e, 0x5e, 0xfb, 0x13, 0x9a, 0x3b, 0x14, 0xe1, 0x6d, 0x15, 0x24, 0x79, 0x42, 0x95, 0xa1, 0x21, - 0x3b, 0x13, 0x90, 0x9d, 0x0c, 0x49, 0xd5, 0xac, 0xbe, 0xe1, 0x12, 0x4c, 0xcf, 0x93, 0x61, 0xa5, 0xd1, 0x19, 0x93, - 0x17, 0x42, 0x39, 0x27, 0xb5, 0xed, 0x26, 0xcb, 0x24, 0xd2, 0x84, 0xe6, 0x90, 0x23, 0xbc, 0xd3, 0x5e, 0x5d, 0x49, - 0x5d, 0xab, 0x9a, 0xe3, 0xf9, 0x10, 0xd6, 0x41, 0x88, 0x0c, 0x97, 0xe5, 0xe2, 0xdf, 0xda, 0x4e, 0x03, 0xb4, 0x9d, - 0x01, 0x61, 0xb8, 0xa3, 0xd8, 0xe7, 0x4e, 0xa7, 0xd5, 0x06, 0x75, 0xf4, 0x9a, 0x82, 0x44, 0x41, 0x68, 0x7d, 0x2a, - 0xd4, 0x9d, 0x25, 0x79, 0xc4, 0x46, 0xdc, 0x09, 0xb8, 0x60, 0x29, 0x34, 0xce, 0xa9, 0xc5, 0x6b, 0x4a, 0xb1, 0x60, - 0x37, 0x01, 0x10, 0x5b, 0xa9, 0x81, 0x51, 0x0d, 0xa9, 0x60, 0x5b, 0xc0, 0x1d, 0x2a, 0x85, 0xba, 0xe2, 0x32, 0xba, - 0x36, 0x03, 0xa5, 0xb1, 0x33, 0x90, 0x3d, 0x7a, 0x8a, 0x19, 0x30, 0x43, 0x6f, 0x65, 0x9e, 0xc9, 0x21, 0x54, 0x21, - 0x77, 0x79, 0xfa, 0x32, 0x9d, 0xd3, 0xec, 0xd4, 0x07, 0xe0, 0x3d, 0xd9, 0xbc, 0x90, 0x82, 0x40, 0xf0, 0x7b, 0xde, - 0xd3, 0xf4, 0x72, 0x21, 0x26, 0xfe, 0x36, 0x4b, 0x27, 0x2c, 0xa7, 0xa0, 0xae, 0x49, 0xfc, 0x27, 0xb0, 0xcf, 0xc4, - 0x86, 0x04, 0x61, 0x43, 0x4b, 0xfa, 0x3a, 0x79, 0x59, 0xa7, 0xaf, 0x8b, 0xdd, 0x67, 0x63, 0xcd, 0x00, 0xeb, 0xdb, - 0x18, 0x61, 0x47, 0x19, 0x15, 0x86, 0x9c, 0x73, 0x23, 0xa4, 0x44, 0xfc, 0x72, 0xc9, 0x0d, 0xdb, 0xad, 0xa6, 0x30, - 0x52, 0xb9, 0x6d, 0x50, 0xe1, 0x87, 0x21, 0xa8, 0x76, 0x59, 0x1a, 0xc7, 0x86, 0xa8, 0xc2, 0xac, 0x57, 0x0a, 0xa7, - 0x8b, 0xdd, 0x67, 0x67, 0x77, 0xc9, 0x27, 0x78, 0x6f, 0x8a, 0x28, 0x0d, 0x68, 0x12, 0xd2, 0x0c, 0x6c, 0x49, 0x63, - 0xb5, 0x94, 0x94, 0x3d, 0x4d, 0x93, 0x84, 0x06, 0x9c, 0x86, 0x60, 0xaa, 0x30, 0xc2, 0xdd, 0x28, 0xcd, 0x79, 0x59, - 0x58, 0x41, 0xcf, 0x0c, 0xe8, 0x99, 0x1b, 0xf8, 0x71, 0xec, 0x48, 0xb3, 0x64, 0x92, 0x5e, 0xd3, 0x0d, 0x50, 0xf7, - 0x6a, 0x20, 0x97, 0xdd, 0x50, 0xa3, 0x1b, 0xea, 0xe6, 0xd3, 0x98, 0x05, 0xb4, 0x14, 0x5d, 0x67, 0x2e, 0x4b, 0x42, - 0x7a, 0x03, 0x7c, 0x04, 0xf5, 0xfb, 0xfd, 0x36, 0xee, 0xa0, 0x42, 0x22, 0x7c, 0xb1, 0x86, 0xd8, 0x3b, 0x84, 0x26, - 0x10, 0x19, 0xe9, 0x2f, 0x36, 0xb2, 0x35, 0x64, 0x48, 0x4a, 0xa6, 0xcd, 0x2b, 0xc9, 0x9d, 0x11, 0x0e, 0x69, 0x4c, - 0x39, 0xd5, 0xdc, 0x1c, 0x94, 0x68, 0xb9, 0x75, 0xdf, 0x95, 0xf8, 0x2b, 0xc9, 0x49, 0xef, 0x32, 0xbd, 0xe6, 0x79, - 0x69, 0xae, 0x57, 0xcb, 0x53, 0x61, 0x7b, 0xc0, 0xe5, 0xf2, 0xf8, 0x9c, 0xfb, 0x41, 0x24, 0xed, 0x74, 0x67, 0x6d, - 0x4a, 0x55, 0x1f, 0x8a, 0xb3, 0x97, 0x9b, 0xe8, 0x89, 0x06, 0x73, 0x13, 0x0a, 0xce, 0x14, 0x53, 0xa0, 0x60, 0xfa, - 0xc9, 0x65, 0x3b, 0xf5, 0xe3, 0xf8, 0xca, 0x0f, 0x3e, 0xd6, 0xa9, 0xbf, 0x22, 0x03, 0xb2, 0xca, 0x8d, 0x8d, 0x57, - 0x06, 0xcb, 0x32, 0xe7, 0xad, 0xb9, 0x74, 0x6d, 0xa3, 0x38, 0x3b, 0xed, 0x8a, 0xec, 0xeb, 0x0b, 0xbd, 0x95, 0xda, - 0x05, 0x44, 0x4c, 0xcd, 0xcc, 0x01, 0x2e, 0xf0, 0x49, 0x8a, 0xd3, 0xfc, 0x40, 0xd1, 0x1d, 0x18, 0x1c, 0xc5, 0x0a, - 0x20, 0x1c, 0x2d, 0x8a, 0x90, 0xe5, 0xdb, 0x31, 0xf0, 0x87, 0x40, 0xf9, 0xd4, 0x18, 0xe1, 0xbe, 0x80, 0x96, 0x3c, - 0x4e, 0x69, 0xcd, 0x25, 0x64, 0x4a, 0x9f, 0xd0, 0x8c, 0xe6, 0x1b, 0xd0, 0x5d, 0x04, 0xbd, 0xbf, 0x91, 0xaf, 0x40, - 0x2b, 0x03, 0x28, 0x92, 0x9e, 0xa9, 0x4e, 0xd4, 0x28, 0x40, 0xf1, 0x54, 0x26, 0x44, 0x6e, 0x56, 0xb3, 0x20, 0x95, - 0xc6, 0x2e, 0x8d, 0x70, 0xc5, 0x72, 0x53, 0xe2, 0x38, 0x4e, 0x02, 0x46, 0x9c, 0xd6, 0xed, 0xab, 0x49, 0x24, 0x6b, - 0x93, 0x48, 0x5c, 0xc3, 0xd0, 0x42, 0x15, 0x2d, 0x1b, 0xcd, 0x3d, 0xce, 0x91, 0x59, 0x0b, 0xf4, 0x55, 0x17, 0x18, - 0x34, 0x2a, 0xf9, 0x6d, 0x4c, 0x38, 0x4e, 0x95, 0x95, 0xa3, 0x48, 0x0d, 0x38, 0x46, 0xd5, 0x24, 0x43, 0x72, 0x6f, - 0xd4, 0x4c, 0xde, 0x0c, 0xa7, 0x68, 0x45, 0xb9, 0x2f, 0x0a, 0x85, 0x24, 0x8a, 0xd4, 0xe2, 0xd4, 0xb4, 0x62, 0x03, - 0x2d, 0x38, 0x23, 0x89, 0xd4, 0x84, 0xa5, 0xe2, 0xb3, 0x8a, 0x9c, 0xb2, 0xdf, 0x1d, 0x42, 0xb2, 0x0a, 0x37, 0x89, - 0xbb, 0x41, 0xb7, 0xca, 0x10, 0x8e, 0xb4, 0x52, 0x9a, 0x56, 0x13, 0x27, 0xc4, 0xd6, 0x3e, 0x09, 0x7b, 0xb0, 0xa8, - 0xd9, 0x85, 0x9e, 0x51, 0xad, 0xf0, 0x80, 0xa7, 0xa6, 0x9b, 0xf0, 0xbd, 0x89, 0x68, 0x6a, 0xfd, 0x18, 0x18, 0x4f, - 0x6b, 0x18, 0x37, 0x50, 0x9b, 0x49, 0xde, 0x95, 0x0d, 0x49, 0x54, 0x6f, 0xec, 0x50, 0x9c, 0xca, 0x85, 0x58, 0xc3, - 0xe2, 0xaa, 0xf2, 0x29, 0x88, 0x10, 0xcc, 0xd8, 0x04, 0xd4, 0x3b, 0x53, 0x42, 0x38, 0x00, 0x3c, 0x5b, 0x2e, 0xd7, - 0xc8, 0x6e, 0xa3, 0x0e, 0x8a, 0xdc, 0xca, 0x32, 0x5c, 0x2e, 0x9f, 0x71, 0xe4, 0x28, 0xed, 0x17, 0x53, 0x34, 0xd0, - 0x3c, 0xf7, 0xe4, 0x25, 0xd4, 0x12, 0xca, 0x68, 0x55, 0x52, 0x9a, 0x0d, 0x75, 0xaa, 0xad, 0x2f, 0x14, 0x37, 0x18, - 0xf7, 0xe9, 0x1a, 0xff, 0x12, 0x85, 0x4a, 0x50, 0x57, 0x53, 0x3e, 0x55, 0x5d, 0x33, 0x84, 0x90, 0x97, 0x08, 0x4b, - 0x66, 0x67, 0x93, 0x71, 0xb9, 0xb7, 0x97, 0x18, 0x1d, 0x5d, 0x94, 0x8c, 0xe2, 0x67, 0x07, 0x84, 0x72, 0x7e, 0x9b, - 0x08, 0xed, 0xe5, 0x67, 0x2d, 0x86, 0xd6, 0x4c, 0xd3, 0x76, 0x0f, 0x6c, 0x72, 0x7f, 0xee, 0x33, 0x6e, 0x95, 0xbd, - 0x48, 0x9b, 0xdc, 0xa1, 0x68, 0xa1, 0x94, 0x0d, 0x37, 0xa3, 0xa0, 0x3e, 0x02, 0x57, 0xd0, 0x4a, 0xb4, 0x24, 0xfc, - 0x20, 0xa2, 0xe0, 0x0f, 0xd6, 0x7a, 0x44, 0x69, 0x1b, 0xee, 0x28, 0x39, 0xa2, 0x3a, 0xde, 0x0c, 0x7b, 0xb1, 0xda, - 0xbc, 0x66, 0x0b, 0x4c, 0x69, 0x36, 0x4a, 0xb3, 0x89, 0x7e, 0x57, 0xac, 0x3c, 0x2b, 0xde, 0xc8, 0x46, 0xce, 0xc6, - 0xbe, 0x95, 0x05, 0xd0, 0x5b, 0x31, 0xbc, 0x2b, 0x93, 0xbd, 0x26, 0x4c, 0x4b, 0xf9, 0x2b, 0xdd, 0x82, 0x9a, 0x32, - 0x13, 0xd3, 0xc4, 0x57, 0x3e, 0xd5, 0x9e, 0x74, 0x9b, 0xec, 0x74, 0x7a, 0xa5, 0xdd, 0xa7, 0xa9, 0xa1, 0x27, 0xdd, - 0x1b, 0x4a, 0xa8, 0xa6, 0xb3, 0x38, 0x54, 0xc0, 0x32, 0x84, 0xa9, 0xa2, 0xa3, 0x39, 0x8b, 0xe3, 0xaa, 0xf4, 0x73, - 0x38, 0x7b, 0xa2, 0x38, 0x7b, 0xa6, 0x39, 0x3b, 0xb0, 0x0a, 0xe0, 0xec, 0xb2, 0xbb, 0xaa, 0x79, 0xb6, 0xb6, 0x3d, - 0x33, 0xc9, 0xd3, 0x13, 0x61, 0x4b, 0xc3, 0x78, 0x33, 0x0d, 0x01, 0x2a, 0x75, 0xaf, 0x8f, 0x8e, 0x72, 0xc5, 0x80, - 0x11, 0x28, 0x3d, 0x99, 0xd4, 0x74, 0x53, 0x7c, 0x74, 0x10, 0x4e, 0x0a, 0x5a, 0x52, 0xf6, 0xc9, 0x33, 0xf0, 0xd5, - 0x19, 0xd3, 0x01, 0x31, 0x26, 0x8a, 0x3f, 0x4b, 0x8d, 0xd2, 0xb3, 0x63, 0x6a, 0x76, 0x89, 0x9e, 0x1d, 0xf0, 0xfa, - 0x6a, 0x76, 0xe1, 0xdd, 0xdc, 0x5e, 0x4c, 0x8f, 0x95, 0xd3, 0xab, 0xd6, 0x7b, 0xb9, 0x74, 0x56, 0x4a, 0xc0, 0x8d, - 0xaf, 0x8c, 0x94, 0xac, 0xec, 0x1d, 0x78, 0x80, 0x89, 0x19, 0x28, 0x28, 0xe4, 0xa4, 0x4b, 0x21, 0xf7, 0xf2, 0x53, - 0x4e, 0x1e, 0xe1, 0xad, 0x97, 0xed, 0x4f, 0xd3, 0xc9, 0x14, 0xf4, 0xb1, 0x15, 0x92, 0x1e, 0x53, 0x35, 0x60, 0xf5, - 0xbe, 0xd8, 0x50, 0x56, 0x6b, 0x23, 0xf6, 0x63, 0x8d, 0x9a, 0x4a, 0x9b, 0x79, 0xa7, 0x5d, 0xcc, 0xca, 0xa2, 0x92, - 0x71, 0x6c, 0x72, 0xac, 0x9c, 0xae, 0xba, 0x65, 0xf4, 0x8b, 0x37, 0x0e, 0x93, 0x7c, 0x98, 0x01, 0xaf, 0x33, 0xd8, - 0x8f, 0x26, 0x77, 0x73, 0xfd, 0x8b, 0x0a, 0x39, 0x8b, 0x62, 0x05, 0x7d, 0x8b, 0xa2, 0x78, 0xa6, 0xec, 0x6c, 0xfc, - 0x6c, 0xbb, 0x41, 0x5c, 0xbd, 0x53, 0xf6, 0xe2, 0xf9, 0x10, 0x3f, 0x5b, 0xd7, 0x1e, 0xc9, 0x62, 0x92, 0x86, 0xd4, - 0xb3, 0xd3, 0x29, 0x4d, 0xec, 0x02, 0xbc, 0xab, 0x6a, 0xf1, 0x67, 0xdc, 0x59, 0xbc, 0xab, 0xbb, 0x59, 0xbd, 0x67, - 0x05, 0xb8, 0xc0, 0x7e, 0x5c, 0x77, 0xc0, 0x7e, 0x4b, 0xb3, 0x5c, 0xe8, 0xa2, 0xa5, 0x5a, 0xfb, 0x63, 0x25, 0x98, - 0x7e, 0xf4, 0xb6, 0xd6, 0xaf, 0xac, 0x10, 0xbb, 0xe3, 0x3e, 0x74, 0xf7, 0x6d, 0x24, 0xdc, 0xc3, 0xdf, 0xa8, 0x1d, - 0xff, 0x8b, 0x76, 0x0f, 0x9f, 0x91, 0x5f, 0xea, 0xde, 0xe1, 0x29, 0x27, 0x67, 0x83, 0x33, 0x6d, 0x34, 0xa7, 0x31, - 0x0b, 0x6e, 0x1d, 0x3b, 0x66, 0xbc, 0x09, 0x21, 0x38, 0x1b, 0x2f, 0xe4, 0x0b, 0xf0, 0x2b, 0x0a, 0xb7, 0x76, 0xa1, - 0xcd, 0x3d, 0xcc, 0x38, 0xb1, 0x77, 0x63, 0xc6, 0x77, 0x6d, 0xbc, 0x4b, 0x2e, 0xe1, 0xc7, 0xee, 0xc2, 0x79, 0xe5, - 0xf3, 0xc8, 0xcd, 0xfc, 0x24, 0x4c, 0x27, 0x0e, 0x6a, 0xd8, 0x36, 0x72, 0x73, 0x61, 0x72, 0x3c, 0x46, 0xc5, 0xee, - 0x25, 0x3e, 0xe3, 0xc4, 0x1e, 0xd8, 0x8d, 0x5d, 0xfc, 0x8a, 0x93, 0xcb, 0xe3, 0xdd, 0xc5, 0x19, 0x2f, 0xfa, 0x97, - 0xf8, 0xa4, 0xf4, 0xdc, 0xe3, 0xd7, 0xc4, 0x41, 0xa4, 0x7f, 0xa2, 0xa0, 0x39, 0x4d, 0x27, 0xd2, 0x83, 0x6f, 0x23, - 0xfc, 0x0e, 0xe2, 0x2b, 0x79, 0xc5, 0x6e, 0x54, 0x88, 0x65, 0x87, 0xd8, 0xa9, 0xf0, 0x12, 0xd8, 0x7b, 0x7b, 0x46, - 0x59, 0xa9, 0x2c, 0xe0, 0x53, 0x4e, 0x6a, 0x36, 0x39, 0x7e, 0x29, 0x22, 0x35, 0xa7, 0xdc, 0xc9, 0x91, 0xee, 0xc6, - 0xd1, 0xee, 0x68, 0xb5, 0x37, 0xf3, 0x73, 0xe9, 0x64, 0x70, 0x19, 0xa7, 0x99, 0xcf, 0xd3, 0x6c, 0x88, 0x4c, 0x05, - 0x04, 0xff, 0x8d, 0x5c, 0x9e, 0x5b, 0xff, 0xe9, 0x8b, 0x9f, 0x46, 0x3f, 0x65, 0xc3, 0x4b, 0xfc, 0x81, 0xb4, 0x8e, - 0x9d, 0x81, 0xe7, 0xec, 0x34, 0x9b, 0xcb, 0x9f, 0x5a, 0xe7, 0x7f, 0xf7, 0x9b, 0xbf, 0x9e, 0x34, 0x7f, 0x1c, 0xa2, - 0xa5, 0xf3, 0x53, 0x6b, 0x70, 0xae, 0x9e, 0xce, 0xff, 0xde, 0xff, 0x29, 0x1f, 0x7e, 0x25, 0x0b, 0x77, 0x11, 0x6a, - 0x8d, 0xf1, 0x98, 0x93, 0x56, 0xb3, 0xd9, 0x6f, 0x8d, 0xf1, 0x84, 0x93, 0x16, 0xfc, 0x3b, 0x27, 0xef, 0xe8, 0xf8, - 0xd9, 0xcd, 0xd4, 0xb9, 0xec, 0x2f, 0x77, 0x17, 0x7f, 0x2b, 0xa0, 0xd7, 0xf3, 0xbf, 0xff, 0xf4, 0x53, 0x6e, 0x3f, - 0xe8, 0x93, 0xd6, 0xb0, 0x81, 0x1c, 0x28, 0xfd, 0x8a, 0x88, 0xbf, 0xce, 0xc0, 0x3b, 0xff, 0xbb, 0x82, 0xc2, 0x7e, - 0xf0, 0xd3, 0xe5, 0x71, 0x9f, 0x0c, 0x97, 0x8e, 0xbd, 0x7c, 0x80, 0x96, 0x08, 0x2d, 0x77, 0xd1, 0x25, 0xb6, 0xc7, - 0x36, 0xc2, 0x17, 0x9c, 0xb4, 0x1e, 0xb4, 0xc6, 0x78, 0xc4, 0x49, 0xcb, 0x6e, 0x8d, 0xf1, 0x1b, 0x4e, 0x5a, 0x7f, - 0x77, 0x06, 0x9e, 0x74, 0xb3, 0x2d, 0x85, 0x87, 0x63, 0x09, 0x41, 0x0e, 0x3f, 0xa3, 0xfe, 0x92, 0x33, 0x1e, 0x53, - 0xb4, 0xdb, 0x62, 0xf8, 0xa3, 0x40, 0x93, 0xc3, 0xc1, 0x0f, 0x03, 0xe6, 0x9d, 0xb3, 0xb8, 0x80, 0xc5, 0x06, 0x9a, - 0xd9, 0xf5, 0x20, 0xba, 0x03, 0xae, 0x80, 0xdc, 0xe3, 0xf8, 0xda, 0x8f, 0x67, 0x34, 0xf7, 0x68, 0x81, 0x70, 0x4c, - 0x3e, 0x72, 0xa7, 0x83, 0xf0, 0x0b, 0x0e, 0x3f, 0xba, 0x08, 0x9f, 0xaa, 0x40, 0x26, 0xec, 0x64, 0x49, 0x54, 0x49, - 0x2a, 0x55, 0x16, 0x1b, 0xe1, 0xf1, 0x86, 0x97, 0x3c, 0x02, 0x07, 0x03, 0xc2, 0xd7, 0xb5, 0xb0, 0x27, 0xbe, 0x21, - 0x9a, 0x24, 0xde, 0x67, 0x94, 0x7e, 0xe7, 0xc7, 0x1f, 0x69, 0xe6, 0x9c, 0xe0, 0x4e, 0xf7, 0x31, 0x16, 0x7e, 0xe8, - 0x9d, 0x0e, 0xea, 0x95, 0x31, 0xab, 0xb7, 0x5c, 0x86, 0x0a, 0x40, 0xca, 0xd6, 0xdd, 0x31, 0xb0, 0xe2, 0x3b, 0xeb, - 0x3e, 0xab, 0xcc, 0x9f, 0xdb, 0xa8, 0x1e, 0x1f, 0x65, 0xc9, 0xb5, 0x1f, 0xb3, 0xd0, 0xe2, 0x74, 0x32, 0x8d, 0x7d, - 0x4e, 0x2d, 0x35, 0x5f, 0xcb, 0x87, 0x8e, 0xec, 0x52, 0x67, 0x98, 0x1a, 0x36, 0xe7, 0x54, 0x07, 0x9e, 0x60, 0xaf, - 0x38, 0x10, 0xa5, 0x52, 0x7a, 0xc7, 0xd3, 0x2a, 0x08, 0xb6, 0x1a, 0xe7, 0x6b, 0x76, 0xc0, 0x17, 0x36, 0x14, 0xf2, - 0x39, 0xc1, 0x19, 0x01, 0x29, 0xda, 0x1d, 0xd8, 0xc7, 0xf9, 0xf5, 0xb8, 0x6f, 0x43, 0x8c, 0x26, 0x25, 0x1f, 0x84, - 0x6b, 0x08, 0x2a, 0x44, 0xa4, 0xdd, 0x8b, 0x8e, 0x69, 0x2f, 0x6a, 0x34, 0xb4, 0x16, 0xed, 0x93, 0xfc, 0x3c, 0x92, - 0xcd, 0x03, 0x1c, 0xe2, 0x19, 0x69, 0x76, 0xf0, 0x94, 0xb4, 0x45, 0x93, 0xde, 0xf4, 0xd8, 0x57, 0xc3, 0xec, 0xed, - 0x39, 0xa9, 0x1b, 0xfb, 0x39, 0x7f, 0x01, 0xf6, 0x3e, 0x99, 0xe2, 0x90, 0xa4, 0x2e, 0xbd, 0xa1, 0x81, 0xe3, 0x23, - 0x1c, 0x2a, 0x4e, 0x83, 0x7a, 0x68, 0x4a, 0x8c, 0x6a, 0x60, 0x46, 0x90, 0x0f, 0x83, 0xf0, 0xbc, 0x33, 0x24, 0x84, - 0xd8, 0x3b, 0xcd, 0xa6, 0x3d, 0x48, 0xc9, 0x98, 0x7b, 0x50, 0x62, 0x28, 0xcb, 0x64, 0x02, 0x45, 0x5d, 0xa3, 0xc8, - 0x79, 0xc3, 0x5d, 0x4e, 0x73, 0xee, 0x40, 0x31, 0x78, 0x00, 0x12, 0x4d, 0xd8, 0xf6, 0x71, 0xcb, 0x6e, 0x40, 0xa9, - 0x20, 0x4e, 0x84, 0x53, 0x32, 0x47, 0x5e, 0x78, 0xbe, 0x3f, 0x34, 0x05, 0x80, 0x28, 0x84, 0xc1, 0xe7, 0x83, 0xf0, - 0xbc, 0x2d, 0x06, 0xef, 0xdb, 0x03, 0x27, 0x25, 0xc9, 0x8e, 0x8a, 0xde, 0x78, 0x1f, 0xc4, 0x54, 0x91, 0xa7, 0x80, - 0x53, 0xe3, 0xce, 0x48, 0xb3, 0xeb, 0x39, 0x33, 0x73, 0x12, 0x4d, 0x18, 0x4c, 0x61, 0x01, 0x07, 0x04, 0xea, 0xe3, - 0x94, 0xc0, 0x88, 0x55, 0xb3, 0xb9, 0xa7, 0x9e, 0x1f, 0xd8, 0x0f, 0x06, 0x23, 0xee, 0x5d, 0x70, 0x39, 0xfc, 0x88, - 0x2f, 0x97, 0xf0, 0xef, 0x05, 0x1f, 0xa4, 0x64, 0x2e, 0x8a, 0xc6, 0xaa, 0x68, 0x02, 0x45, 0x1f, 0x3c, 0x00, 0x15, - 0x27, 0xa5, 0x96, 0x25, 0xd7, 0x64, 0x42, 0x04, 0xec, 0x7b, 0x7b, 0xf9, 0x79, 0xd4, 0xe8, 0x0c, 0xc1, 0xc9, 0x9f, - 0xf1, 0xfc, 0x3b, 0xc6, 0x23, 0xc7, 0x6e, 0xf5, 0x6d, 0x34, 0xb0, 0x2d, 0x58, 0xda, 0x5e, 0xd6, 0x20, 0x12, 0xc3, - 0x7e, 0xe3, 0x15, 0xf7, 0x66, 0x7d, 0xd2, 0x1e, 0x38, 0x4c, 0xb9, 0xf4, 0x10, 0xf6, 0x15, 0xe3, 0x6c, 0xe3, 0x19, - 0x6a, 0x30, 0xde, 0xd0, 0xcf, 0x33, 0xd4, 0xd8, 0x6d, 0x4c, 0x90, 0xe7, 0x37, 0x76, 0x1b, 0xce, 0x8c, 0x10, 0xd2, - 0xec, 0x96, 0xcd, 0xb4, 0xf8, 0x8b, 0x90, 0x37, 0xd1, 0xfe, 0xce, 0x73, 0xb1, 0x1d, 0xb2, 0x86, 0x03, 0x2e, 0x96, - 0xe5, 0xd2, 0x3e, 0x1e, 0xf4, 0x6d, 0xd4, 0x70, 0x34, 0xa1, 0xb5, 0x34, 0xa5, 0x21, 0x84, 0xd9, 0xb0, 0x50, 0xf1, - 0xa4, 0x27, 0xb5, 0xd8, 0xd1, 0xa2, 0xda, 0xec, 0x06, 0x0f, 0xa0, 0x45, 0x69, 0xc8, 0x48, 0x85, 0x75, 0x0a, 0xd3, - 0xd4, 0xc4, 0x9c, 0x91, 0x36, 0x4e, 0x89, 0x76, 0x5f, 0x47, 0x84, 0x57, 0x04, 0xef, 0x93, 0xaa, 0x3a, 0x3e, 0x0f, - 0x70, 0x38, 0x24, 0x4f, 0xa5, 0x41, 0xd2, 0xd3, 0xce, 0x71, 0x1a, 0x93, 0x27, 0x2b, 0x51, 0xdc, 0x00, 0x02, 0x2c, - 0x37, 0x6e, 0x30, 0xcb, 0x32, 0x9a, 0xf0, 0xd7, 0x69, 0xa8, 0xf4, 0x34, 0x1a, 0x83, 0xa9, 0x04, 0xe1, 0x59, 0x0c, - 0x4a, 0x5a, 0x57, 0xef, 0x8c, 0xd9, 0xda, 0xeb, 0x29, 0x99, 0x49, 0xfd, 0x49, 0x04, 0x6d, 0x7b, 0x53, 0x65, 0x19, - 0x3b, 0x08, 0xcf, 0x54, 0x34, 0xd7, 0x71, 0x5d, 0x77, 0xea, 0x06, 0xf0, 0x1a, 0x06, 0xc8, 0x51, 0x21, 0xf6, 0x91, - 0x93, 0x90, 0x1b, 0x37, 0xa1, 0x37, 0x62, 0x54, 0x07, 0x55, 0x92, 0x59, 0x6f, 0xaf, 0xe3, 0xa8, 0x27, 0xd8, 0x4d, - 0xe2, 0x26, 0x69, 0x48, 0x01, 0x3d, 0x10, 0xbf, 0x57, 0x45, 0x91, 0x9f, 0x9b, 0x41, 0xaa, 0x0a, 0xbe, 0x73, 0xd3, - 0x7f, 0x3d, 0x05, 0xa7, 0xaf, 0xb0, 0x88, 0xcb, 0xca, 0xd2, 0x13, 0x8e, 0x10, 0x1b, 0x39, 0x53, 0x17, 0x82, 0x7b, - 0x82, 0x84, 0x18, 0xd8, 0x72, 0x53, 0x93, 0xa8, 0x76, 0xcb, 0x3e, 0x27, 0x24, 0x3c, 0x4f, 0x1b, 0x0d, 0xe1, 0x88, - 0x9e, 0x49, 0x92, 0x98, 0x22, 0x3c, 0x29, 0xf7, 0x96, 0xae, 0xf7, 0x96, 0xd4, 0x47, 0x72, 0x26, 0x75, 0x87, 0x6e, - 0x83, 0x71, 0x24, 0x7c, 0x85, 0xdc, 0xd9, 0x45, 0xf8, 0x82, 0xb4, 0x9c, 0x73, 0x77, 0xf0, 0xe7, 0x21, 0x1a, 0x38, - 0xee, 0x57, 0xa8, 0x25, 0x19, 0xc7, 0x04, 0xf5, 0x7c, 0x39, 0xc4, 0x42, 0x44, 0x31, 0x3b, 0x58, 0xf8, 0x12, 0xbd, - 0x0c, 0x27, 0xfe, 0x84, 0x7a, 0x17, 0xb0, 0xc7, 0x35, 0xdd, 0xbc, 0xc5, 0x40, 0x47, 0xde, 0x85, 0xe2, 0x24, 0xae, - 0x3d, 0xf8, 0x85, 0x97, 0x4f, 0x03, 0x7b, 0xf0, 0x75, 0xf5, 0xf4, 0x67, 0x7b, 0xf0, 0x2d, 0xf7, 0xbe, 0x2d, 0x94, - 0xbb, 0xbb, 0x36, 0xc4, 0x43, 0x3d, 0x44, 0x21, 0x17, 0xc6, 0xc0, 0xdc, 0x0c, 0x25, 0x6b, 0x8e, 0x8e, 0x29, 0x2a, - 0xd8, 0xa8, 0x64, 0x45, 0x89, 0xcb, 0xfd, 0x31, 0xa0, 0xd4, 0x58, 0x81, 0xc4, 0x8c, 0xee, 0x57, 0x13, 0x06, 0x42, - 0xd1, 0xd4, 0x0a, 0xa8, 0x9c, 0xf6, 0xdb, 0x68, 0x51, 0xab, 0x2b, 0x34, 0xa6, 0x7a, 0x34, 0xbd, 0xe4, 0xd2, 0x13, - 0xd2, 0xee, 0x4d, 0x8e, 0xa7, 0xbd, 0x49, 0xa3, 0x81, 0x12, 0x4d, 0x58, 0xb3, 0xf3, 0xc9, 0x10, 0xbf, 0x06, 0xaf, - 0x9e, 0x49, 0x49, 0xb8, 0x36, 0xbd, 0xae, 0x9a, 0x5e, 0xa3, 0x91, 0x15, 0xa8, 0x67, 0x34, 0x9d, 0xca, 0xa6, 0x45, - 0x21, 0x71, 0xb2, 0x4a, 0x68, 0x47, 0x48, 0x94, 0x40, 0x4a, 0x14, 0x21, 0xe4, 0x8c, 0xa3, 0x8d, 0xbd, 0x42, 0x9f, - 0xd0, 0x5c, 0xec, 0x58, 0x60, 0x9e, 0x52, 0x46, 0x38, 0x80, 0x05, 0x68, 0x5a, 0xba, 0x82, 0x77, 0xf1, 0xac, 0xd1, - 0x11, 0x44, 0xde, 0xec, 0xf4, 0xea, 0x7d, 0x3d, 0xaa, 0xfa, 0xc2, 0xb3, 0x06, 0xd9, 0x2d, 0xb1, 0x54, 0x64, 0x8d, - 0x46, 0x51, 0x8f, 0x77, 0xea, 0x7d, 0x5b, 0x8b, 0x40, 0x9c, 0xac, 0xa6, 0x66, 0x68, 0xf9, 0x5a, 0x49, 0x54, 0xe6, - 0xb2, 0x24, 0xa1, 0x19, 0xc8, 0x50, 0xc2, 0x31, 0x2b, 0x8a, 0x52, 0xae, 0xbf, 0x01, 0x21, 0x8a, 0x29, 0xc9, 0x81, - 0xef, 0x08, 0xb3, 0x0b, 0x67, 0x38, 0xc5, 0x91, 0xe0, 0x1a, 0x84, 0x90, 0x53, 0x9d, 0xd4, 0xc2, 0x05, 0x07, 0xf2, - 0x09, 0x33, 0x24, 0x52, 0x42, 0xa8, 0x7b, 0xb1, 0x7b, 0x9a, 0xde, 0x69, 0x92, 0x9d, 0xb3, 0xa1, 0x27, 0xaa, 0xc5, - 0x8a, 0x6f, 0x05, 0xe4, 0x9d, 0xc3, 0x51, 0x19, 0x1e, 0x71, 0x05, 0xfb, 0x7b, 0xca, 0x32, 0x2a, 0x34, 0xf0, 0x5d, - 0x6d, 0xf6, 0xf9, 0x75, 0xf5, 0xd1, 0x37, 0x9d, 0x37, 0x80, 0xc8, 0x00, 0x7c, 0x3b, 0x19, 0x59, 0xab, 0x76, 0xb1, - 0x7b, 0xf2, 0x66, 0x93, 0x09, 0xbc, 0x5c, 0x2a, 0xe3, 0xd7, 0x07, 0xcd, 0x06, 0x07, 0x15, 0xa4, 0xbe, 0xfa, 0xe1, - 0x39, 0xbe, 0x50, 0x90, 0x02, 0x27, 0x07, 0x2a, 0xba, 0xd8, 0x3d, 0x79, 0xef, 0xe4, 0xc2, 0xb5, 0x84, 0xb0, 0x39, - 0x6d, 0x27, 0x25, 0x4e, 0x44, 0x28, 0x92, 0x73, 0x2f, 0x19, 0x57, 0x6a, 0x88, 0x6f, 0x2f, 0x12, 0x2f, 0xc1, 0x7e, - 0x38, 0x67, 0x43, 0xe2, 0x2b, 0x0c, 0x10, 0x1f, 0x61, 0xbf, 0x66, 0x96, 0x11, 0x58, 0x00, 0x31, 0xd6, 0x19, 0xac, - 0x84, 0x2b, 0x15, 0x3f, 0x84, 0x7d, 0x31, 0x2a, 0x2f, 0xa4, 0xe8, 0xf8, 0x79, 0x2d, 0x37, 0xad, 0xb2, 0x46, 0xbf, - 0x05, 0xcb, 0x49, 0x3f, 0xbc, 0x56, 0x5d, 0x97, 0x05, 0x4f, 0x75, 0x12, 0xd9, 0xc5, 0xee, 0xc9, 0x2b, 0x95, 0x47, - 0x36, 0xf5, 0x35, 0xb7, 0x5f, 0xb3, 0x30, 0x4f, 0x5e, 0xb9, 0xd5, 0x5b, 0x51, 0xf9, 0x62, 0xf7, 0xe4, 0xc3, 0xa6, - 0x6a, 0x50, 0x5e, 0xcc, 0x2a, 0x13, 0x5f, 0xc0, 0xb7, 0xa0, 0xb1, 0xb7, 0x50, 0xa2, 0xc1, 0x63, 0x05, 0x16, 0xe2, - 0xc8, 0x4b, 0x8a, 0xd2, 0x33, 0xf2, 0x14, 0x67, 0x44, 0xc4, 0x81, 0xea, 0xab, 0xa6, 0x94, 0x3c, 0x96, 0x26, 0x67, - 0x41, 0x3a, 0xa5, 0x5b, 0x82, 0x43, 0x27, 0xc8, 0x65, 0x13, 0x48, 0xa0, 0x11, 0xa0, 0x33, 0xbc, 0xd3, 0x46, 0xbd, - 0xba, 0xf0, 0xca, 0x04, 0x91, 0xa6, 0x35, 0xc9, 0x82, 0x23, 0xd2, 0xc6, 0x3e, 0x69, 0xe3, 0x80, 0x24, 0xe7, 0x6d, - 0x29, 0x1e, 0x7a, 0x41, 0xd9, 0xaf, 0x14, 0x32, 0x90, 0x1b, 0x16, 0xc8, 0xdd, 0x2a, 0xc5, 0x6f, 0xd8, 0x0b, 0x84, - 0xeb, 0x51, 0x48, 0xf4, 0x50, 0x1a, 0xad, 0x4e, 0x8a, 0x53, 0xd1, 0xf1, 0x19, 0xbb, 0x8a, 0x21, 0xbb, 0x04, 0x66, - 0x85, 0x39, 0xf2, 0xca, 0xaa, 0x1d, 0x55, 0x35, 0x70, 0xc5, 0x3a, 0xa5, 0x38, 0x70, 0x81, 0x71, 0xe3, 0x40, 0x25, - 0xe3, 0xe4, 0xeb, 0x4d, 0x1e, 0xee, 0xed, 0x39, 0xb2, 0xd1, 0x77, 0xdc, 0x49, 0xf5, 0xfb, 0x2a, 0x74, 0xf7, 0xad, - 0xe4, 0x15, 0x21, 0x12, 0xf0, 0x37, 0x1a, 0xfe, 0xb0, 0x80, 0x38, 0xb4, 0x13, 0xd4, 0x31, 0xa8, 0x81, 0x17, 0x9a, - 0x5e, 0x7d, 0xfa, 0x8d, 0x46, 0x19, 0xa6, 0xad, 0x63, 0xeb, 0x04, 0x67, 0xc5, 0xb5, 0x53, 0xe6, 0xff, 0xb4, 0xd7, - 0xb2, 0xa6, 0x34, 0x08, 0x88, 0x99, 0x34, 0xcb, 0xf4, 0x64, 0x8c, 0x2d, 0xc1, 0xa0, 0xde, 0x0b, 0x95, 0xb8, 0x80, - 0x45, 0x8e, 0x95, 0xaa, 0xa4, 0xd9, 0x59, 0x17, 0x79, 0xba, 0x12, 0x84, 0xa5, 0xa0, 0x52, 0xa3, 0x50, 0xe4, 0xfd, - 0x6a, 0x3d, 0xf3, 0x12, 0x27, 0x48, 0xf9, 0xb8, 0x04, 0x14, 0x02, 0x59, 0xdd, 0x12, 0x29, 0xcf, 0xc9, 0x78, 0x3b, - 0xc9, 0x9f, 0x18, 0x24, 0xff, 0x84, 0x50, 0x83, 0xfc, 0xa5, 0x87, 0xc3, 0x4d, 0x95, 0x6b, 0x21, 0xd1, 0xaf, 0x4e, - 0xa7, 0x04, 0x7c, 0x68, 0x75, 0x8c, 0x26, 0x66, 0x5c, 0x71, 0x0b, 0x43, 0x31, 0x77, 0x88, 0xf0, 0x42, 0x62, 0x1d, - 0x04, 0x76, 0xaa, 0xa8, 0x1a, 0x0c, 0xbd, 0xc9, 0xa5, 0x67, 0x72, 0xc0, 0x93, 0x0f, 0x77, 0x07, 0x44, 0x4f, 0xa7, - 0xeb, 0x3b, 0xd7, 0xc8, 0x00, 0x85, 0x59, 0x1b, 0x1b, 0xb7, 0x9e, 0x0f, 0x0a, 0xe3, 0x97, 0x81, 0xec, 0x3a, 0xf3, - 0x59, 0xd9, 0x84, 0x5a, 0xfe, 0x01, 0xb4, 0x9d, 0x8e, 0xa8, 0x41, 0x8d, 0x6e, 0x81, 0x1f, 0xc9, 0x3c, 0x54, 0x3f, - 0xdb, 0xc2, 0x3e, 0x4e, 0x44, 0x05, 0x9a, 0x84, 0x9b, 0x5f, 0x3f, 0x29, 0x14, 0x99, 0x48, 0xd0, 0xd0, 0x02, 0xf8, - 0x9f, 0x24, 0x79, 0xa0, 0x1b, 0x21, 0x17, 0x00, 0x41, 0x63, 0x81, 0xa7, 0x0a, 0x61, 0xb6, 0x5d, 0x39, 0xdf, 0x9f, - 0xef, 0x10, 0x32, 0xae, 0x9c, 0x8f, 0xef, 0xaa, 0xec, 0x2b, 0x20, 0x0b, 0xe4, 0x81, 0xf1, 0x58, 0x16, 0xc8, 0xf8, - 0xe5, 0xa9, 0xae, 0x2e, 0x0c, 0x48, 0xb7, 0xd2, 0xb7, 0x8d, 0xd8, 0xa6, 0xf0, 0xca, 0xc9, 0xf7, 0x1a, 0x0d, 0x2b, - 0x6f, 0x77, 0xe1, 0xed, 0x4b, 0x2e, 0x60, 0x84, 0xe7, 0xf7, 0xa2, 0xb6, 0xee, 0xb7, 0xf8, 0xb8, 0x9a, 0xc2, 0xb2, - 0xb2, 0x28, 0x2e, 0x4b, 0x72, 0x9a, 0xf1, 0x27, 0x74, 0x94, 0x66, 0x10, 0xb2, 0x28, 0x71, 0x82, 0x8a, 0x5d, 0xc3, - 0x6d, 0x27, 0xe6, 0x67, 0xc4, 0x09, 0x56, 0x26, 0x28, 0x7e, 0x7d, 0x14, 0x51, 0xeb, 0x8b, 0xd5, 0x56, 0xe3, 0xbd, - 0xbd, 0x77, 0x15, 0x9a, 0x14, 0x94, 0x02, 0x0a, 0x83, 0x69, 0x49, 0x95, 0x46, 0x85, 0x72, 0x77, 0x9d, 0xd2, 0x05, - 0xa0, 0x19, 0x86, 0xc9, 0x7b, 0x9e, 0x13, 0x5e, 0x8c, 0x57, 0x59, 0xbc, 0x72, 0x4d, 0x30, 0xd3, 0x6c, 0x01, 0x0e, - 0x0f, 0x86, 0xb6, 0xf4, 0x15, 0x25, 0x55, 0x4a, 0x6c, 0x09, 0xc3, 0x29, 0x20, 0xcb, 0x49, 0xc0, 0x08, 0x31, 0x28, - 0x30, 0xd9, 0x64, 0x94, 0xbc, 0x05, 0xbd, 0x32, 0xc2, 0x89, 0x1b, 0x41, 0x12, 0x6c, 0x6d, 0xcb, 0x22, 0x84, 0x13, - 0x61, 0xd0, 0x18, 0xb9, 0x04, 0x27, 0xcf, 0x37, 0x79, 0x94, 0x35, 0x51, 0x53, 0x21, 0x75, 0xa0, 0x46, 0x86, 0xca, - 0x06, 0xee, 0xb5, 0xc3, 0x94, 0xe2, 0x56, 0xc6, 0xcd, 0xe8, 0xdc, 0xfa, 0x99, 0x3b, 0x32, 0x16, 0x05, 0x32, 0x23, - 0x75, 0x67, 0x4e, 0x6d, 0xe8, 0x5e, 0x2a, 0x9a, 0x61, 0x85, 0xb8, 0xc8, 0x44, 0x53, 0x2a, 0xe2, 0x7a, 0xa7, 0x15, - 0x2f, 0xbd, 0x96, 0x79, 0xd4, 0x5c, 0x73, 0xc1, 0x2a, 0x93, 0xc4, 0x98, 0xfe, 0xb5, 0x4c, 0x8d, 0x2e, 0x2b, 0x61, - 0x2a, 0xc0, 0x78, 0x22, 0xd6, 0x80, 0x16, 0x40, 0x5f, 0x8b, 0x53, 0x6e, 0xac, 0xa8, 0xf6, 0x61, 0x8b, 0x31, 0x0d, - 0xa9, 0xff, 0x0e, 0x72, 0x5d, 0x56, 0xf7, 0xfc, 0x73, 0x21, 0x0b, 0x19, 0x4e, 0x6a, 0x8c, 0x3d, 0x13, 0x8c, 0x1d, - 0x81, 0x9e, 0xa6, 0xd3, 0xbf, 0x07, 0x2a, 0xe5, 0x45, 0xe5, 0x2e, 0x3a, 0x8a, 0xc4, 0x5e, 0x97, 0xe1, 0x72, 0xe3, - 0xf7, 0xca, 0x6a, 0x78, 0x8c, 0x40, 0x1a, 0x10, 0x56, 0x9c, 0x3d, 0x43, 0x38, 0x69, 0x34, 0x7a, 0xc9, 0x31, 0xad, - 0x5c, 0x24, 0x15, 0x8c, 0x0c, 0x22, 0xba, 0x40, 0xf0, 0x35, 0x19, 0x9a, 0x20, 0x5c, 0xe6, 0xa1, 0x27, 0xe0, 0x6a, - 0x3f, 0x79, 0xe7, 0x98, 0x5c, 0xcd, 0xac, 0x5b, 0x06, 0x4d, 0x61, 0x3e, 0x4e, 0x15, 0x6f, 0x79, 0x7b, 0x77, 0x86, - 0x07, 0xc0, 0xbd, 0xd3, 0xc1, 0x90, 0x8d, 0x86, 0x7a, 0x5c, 0xb2, 0x84, 0x72, 0xf7, 0xf5, 0x50, 0x95, 0x98, 0x68, - 0x0e, 0xd6, 0xe3, 0x95, 0x29, 0xcb, 0x49, 0x52, 0x14, 0x39, 0xad, 0xe2, 0xfb, 0x2b, 0x19, 0x98, 0x42, 0xb8, 0xac, - 0x3b, 0xdb, 0x4f, 0xa7, 0x84, 0x63, 0x83, 0x50, 0xdf, 0x6e, 0x0b, 0x7d, 0x54, 0x60, 0xc2, 0xbe, 0x56, 0x42, 0xf1, - 0xdb, 0x4d, 0x42, 0x11, 0x67, 0x6a, 0xcb, 0x0b, 0x81, 0xd8, 0xb9, 0x87, 0x40, 0x54, 0x4e, 0x76, 0x2d, 0x13, 0x41, - 0x1d, 0xa9, 0xc9, 0xc4, 0xa4, 0x2e, 0x13, 0x33, 0xcc, 0xd4, 0x6a, 0xf4, 0xbb, 0xcb, 0x25, 0x3b, 0x6f, 0x83, 0x13, - 0xc9, 0xb6, 0xe1, 0x67, 0x47, 0xfe, 0x34, 0x38, 0xb1, 0x74, 0x02, 0x3b, 0xac, 0x34, 0x59, 0x90, 0x0b, 0x69, 0xce, - 0x8e, 0xc8, 0xca, 0x12, 0x34, 0xad, 0x28, 0x48, 0x11, 0x38, 0x61, 0x65, 0x94, 0x09, 0x20, 0x16, 0xb2, 0x42, 0x19, - 0x90, 0xce, 0xc6, 0xf4, 0x3f, 0x6d, 0x5e, 0x7e, 0x5a, 0x13, 0xad, 0xc9, 0x15, 0xa9, 0x3e, 0xd4, 0x12, 0x0e, 0x14, - 0x04, 0x4a, 0x3f, 0xdc, 0x11, 0x26, 0x68, 0x25, 0xca, 0x91, 0x29, 0x87, 0x70, 0x1b, 0x5c, 0x68, 0x3b, 0xef, 0x64, - 0x80, 0x77, 0x83, 0x34, 0xc1, 0xa9, 0x41, 0xd7, 0xcf, 0x09, 0xaf, 0xb1, 0x92, 0x88, 0x28, 0x4b, 0x09, 0x07, 0x82, - 0x4c, 0x39, 0xc9, 0xce, 0xdb, 0x43, 0x50, 0x40, 0x7b, 0xfe, 0x71, 0x56, 0x99, 0xc0, 0x7e, 0xa3, 0x81, 0x02, 0x3d, - 0x6a, 0x74, 0xce, 0x1a, 0xfe, 0x10, 0x53, 0xec, 0x4b, 0xc3, 0xe4, 0x74, 0x6f, 0xcf, 0x09, 0xaa, 0x71, 0xcf, 0xfd, - 0x21, 0xc2, 0xe9, 0x72, 0xe9, 0x08, 0xb0, 0x02, 0xb4, 0x5c, 0x06, 0x26, 0x58, 0xe2, 0x35, 0x34, 0x1b, 0x0f, 0x38, - 0x19, 0x0b, 0x01, 0x38, 0x06, 0x08, 0x1b, 0xc4, 0x09, 0x94, 0x73, 0x2f, 0x00, 0x67, 0x54, 0x23, 0x3b, 0xf7, 0x1b, - 0x9d, 0xa1, 0xc1, 0xb8, 0xce, 0xfd, 0x21, 0x09, 0x8a, 0x74, 0x6f, 0x6f, 0x27, 0x51, 0x22, 0xf2, 0x67, 0x10, 0x65, - 0x3f, 0x0b, 0xc9, 0x22, 0x3b, 0x34, 0x57, 0x63, 0xd5, 0x19, 0x50, 0x52, 0x94, 0x5a, 0x56, 0x5d, 0xaf, 0x96, 0x05, - 0x51, 0x56, 0xc2, 0x2a, 0x16, 0x3c, 0x00, 0xcb, 0xbe, 0x24, 0xf3, 0x5f, 0x78, 0x99, 0x66, 0xfd, 0xed, 0xc6, 0xe4, - 0x6a, 0xd7, 0x75, 0xfd, 0x6c, 0x2c, 0x22, 0x19, 0x3a, 0x63, 0x52, 0x10, 0xff, 0xbe, 0x02, 0xd3, 0x18, 0xf8, 0xbc, - 0x1c, 0x6b, 0x48, 0x24, 0xf8, 0x5a, 0xb5, 0xd1, 0x27, 0x4a, 0x7e, 0xdd, 0xe8, 0x65, 0x90, 0x90, 0x7c, 0xfd, 0x5b, - 0x21, 0x39, 0x50, 0x90, 0x48, 0xf2, 0x58, 0xc1, 0xd9, 0x16, 0x5c, 0xfc, 0xca, 0x57, 0x70, 0xb6, 0x1d, 0xb7, 0x25, - 0x43, 0xd8, 0x06, 0x9f, 0xc1, 0x1b, 0x24, 0xa0, 0x55, 0x81, 0x01, 0xe5, 0xe1, 0xaa, 0xee, 0x25, 0x59, 0x29, 0x08, - 0x53, 0x4e, 0x1c, 0x56, 0xdf, 0x00, 0x95, 0x36, 0x6a, 0x18, 0xbe, 0xcc, 0x1b, 0x23, 0xc3, 0x25, 0x50, 0x4f, 0x5d, - 0x01, 0x72, 0x52, 0xbe, 0x76, 0x48, 0x45, 0xd8, 0x91, 0x4a, 0x9c, 0x1b, 0xf8, 0x53, 0x3e, 0xcb, 0x40, 0x95, 0x4a, - 0xf4, 0x6f, 0x28, 0x86, 0xb3, 0x20, 0xa2, 0x0c, 0x7e, 0x40, 0xc1, 0xd4, 0xcf, 0x73, 0x76, 0x2d, 0xcb, 0xd4, 0x6f, - 0x9c, 0x12, 0x4d, 0xca, 0x89, 0xd4, 0x09, 0x33, 0xd4, 0xcb, 0x14, 0x9d, 0xd6, 0xd1, 0xf6, 0xec, 0x9a, 0x26, 0xfc, - 0x25, 0xcb, 0x39, 0x4d, 0x60, 0xfa, 0x15, 0xc5, 0xc1, 0x8c, 0x12, 0x04, 0x1b, 0xb6, 0xd6, 0xca, 0x0f, 0xc3, 0x3b, - 0x9b, 0xf0, 0xba, 0x0e, 0x14, 0xf9, 0x49, 0x18, 0xcb, 0x41, 0xcc, 0x84, 0x46, 0x9d, 0xc4, 0x59, 0xd6, 0x34, 0xf3, - 0x69, 0x2a, 0x65, 0x43, 0x70, 0x77, 0x87, 0x11, 0x2d, 0x09, 0xb4, 0xf4, 0xbc, 0x53, 0x6b, 0x81, 0x80, 0xf7, 0x96, - 0x45, 0x30, 0x67, 0x82, 0xb9, 0xc1, 0x51, 0xdd, 0x3a, 0x9c, 0x9a, 0x6e, 0xbe, 0xdb, 0x78, 0xb0, 0x6d, 0x93, 0x70, - 0x10, 0x74, 0xf2, 0x70, 0xbb, 0x65, 0xf5, 0x4a, 0x4b, 0x0e, 0x2d, 0x2d, 0xd8, 0x7d, 0x19, 0x33, 0x5a, 0x68, 0xf2, - 0x42, 0x7a, 0x2b, 0xde, 0x72, 0xf2, 0x0b, 0x9c, 0x1c, 0x7a, 0xce, 0x27, 0xf1, 0xca, 0x01, 0x99, 0xde, 0x6d, 0xa9, - 0xfd, 0xdf, 0x72, 0xe7, 0x09, 0x7e, 0x05, 0x61, 0xdd, 0x6f, 0xaa, 0xea, 0xeb, 0xe1, 0xdc, 0x6f, 0x2a, 0x04, 0x7d, - 0xe3, 0xad, 0xd5, 0x33, 0xc2, 0xb8, 0x5d, 0xf7, 0xc8, 0x6d, 0xdb, 0x5a, 0x5b, 0xfa, 0x51, 0x06, 0x91, 0x64, 0xaa, - 0xa5, 0xd8, 0x0f, 0xb8, 0x4a, 0x54, 0x83, 0x84, 0xb9, 0xba, 0x85, 0x44, 0x55, 0x8a, 0xa1, 0xd4, 0xe1, 0xb7, 0x2d, - 0x8f, 0x92, 0x31, 0x99, 0xb4, 0x33, 0xde, 0xfa, 0x19, 0xdf, 0x85, 0x5d, 0x96, 0xae, 0x9d, 0xc6, 0x8b, 0x08, 0x78, - 0xd0, 0xee, 0x37, 0x44, 0x75, 0x16, 0x60, 0x90, 0xc8, 0xc3, 0x40, 0x66, 0xff, 0x24, 0xd5, 0xba, 0x5b, 0xdd, 0xca, - 0x78, 0x0d, 0xf6, 0x3f, 0xc2, 0x91, 0x3e, 0x22, 0x47, 0x15, 0x07, 0xa6, 0xde, 0xa2, 0x28, 0x9d, 0x02, 0xa9, 0x54, - 0xde, 0x72, 0x84, 0xd3, 0x42, 0x84, 0xb7, 0xbf, 0xc7, 0x3f, 0x28, 0x96, 0x38, 0x2a, 0x39, 0xce, 0xb3, 0xfb, 0x72, - 0x44, 0x09, 0x7e, 0x19, 0xbd, 0x07, 0x3a, 0x16, 0x14, 0x5a, 0x68, 0x2a, 0x7a, 0x9a, 0xaa, 0x89, 0x6c, 0xcd, 0x4b, - 0xc5, 0xb4, 0xcc, 0xa8, 0x11, 0xc3, 0x6c, 0x48, 0xe4, 0xd4, 0x56, 0x36, 0x2f, 0x77, 0x55, 0x6d, 0x5c, 0xb4, 0x05, - 0x8b, 0x55, 0x60, 0x71, 0xb9, 0x74, 0xea, 0xa8, 0x26, 0xcc, 0x88, 0x63, 0x20, 0xcc, 0x8c, 0x84, 0x8a, 0x9a, 0x66, - 0x2d, 0xdb, 0x38, 0x68, 0x35, 0x9f, 0x48, 0xeb, 0xe6, 0x35, 0x38, 0x4c, 0x17, 0x82, 0x6c, 0x6e, 0xfa, 0x14, 0xb0, - 0x9c, 0x5d, 0x39, 0x90, 0x81, 0xa1, 0x1f, 0xcb, 0x5c, 0xd9, 0x2a, 0xa9, 0x75, 0x03, 0x7e, 0xd1, 0x1d, 0xd9, 0xb2, - 0x0a, 0x75, 0xeb, 0xef, 0x8d, 0x5c, 0xa3, 0xa7, 0xe9, 0xb6, 0x5c, 0xa3, 0x9a, 0xb6, 0xbb, 0xd3, 0x46, 0x77, 0xe7, - 0xa5, 0xca, 0xb1, 0x36, 0x57, 0xf9, 0x0d, 0xc3, 0x75, 0x80, 0x36, 0x25, 0x9a, 0x35, 0x57, 0x39, 0x2d, 0x8a, 0x51, - 0x79, 0x9a, 0x40, 0xa4, 0xee, 0x8c, 0x24, 0xfd, 0x2b, 0xab, 0x51, 0x1c, 0xca, 0x75, 0xbe, 0x27, 0xe3, 0x38, 0xbd, - 0xf2, 0xe3, 0xf7, 0x30, 0x5e, 0xf5, 0xf2, 0xf9, 0x6d, 0x98, 0xf9, 0x9c, 0x2a, 0xee, 0x52, 0xc1, 0xf0, 0xbd, 0x01, - 0xc3, 0xf7, 0x92, 0x4f, 0x57, 0xed, 0xf1, 0xe2, 0x65, 0xd9, 0x81, 0x37, 0x2a, 0x34, 0xcb, 0xd8, 0xe5, 0x9b, 0xc7, - 0x58, 0x65, 0x61, 0xbb, 0x25, 0x0b, 0xdb, 0xe5, 0xce, 0x6a, 0x57, 0x8e, 0xf3, 0xc3, 0xe6, 0x5e, 0xd6, 0x39, 0xdb, - 0x0f, 0xd5, 0xc6, 0xff, 0xc1, 0xbb, 0xb3, 0x8d, 0xc1, 0xe5, 0xf6, 0xdd, 0x7d, 0x91, 0xac, 0x22, 0x41, 0x7e, 0x09, - 0x49, 0x07, 0x9c, 0xf4, 0x8d, 0x43, 0x07, 0x95, 0x9c, 0xd2, 0x79, 0x40, 0x4e, 0x30, 0xcb, 0x79, 0x3a, 0x51, 0x7d, - 0xe6, 0xea, 0xa4, 0x91, 0x78, 0x09, 0xae, 0x68, 0x11, 0x6b, 0xf7, 0xea, 0x67, 0xb9, 0x16, 0x1f, 0x59, 0x12, 0x7a, - 0x09, 0x56, 0x52, 0x24, 0xf7, 0xb2, 0x82, 0xe8, 0x6c, 0xe3, 0xf5, 0x77, 0x78, 0xc4, 0x12, 0x96, 0x47, 0x34, 0x73, - 0x52, 0xb4, 0xd8, 0x36, 0x58, 0x0a, 0x01, 0x19, 0x39, 0x18, 0xfe, 0x6b, 0x75, 0xea, 0xcf, 0x85, 0xde, 0xc0, 0x0f, - 0x34, 0xa1, 0x3c, 0x4a, 0x43, 0x48, 0x4b, 0x71, 0xc3, 0xf2, 0x50, 0xd3, 0xde, 0xde, 0x8e, 0x63, 0x0b, 0xb7, 0x04, - 0x1c, 0x00, 0x37, 0xdf, 0xa0, 0xc1, 0x02, 0xce, 0xe7, 0x54, 0x43, 0x53, 0xb4, 0xa0, 0xab, 0x47, 0x59, 0xb8, 0xfb, - 0x91, 0xde, 0xe2, 0x1c, 0x15, 0x85, 0x27, 0xa1, 0xb6, 0x47, 0x8c, 0xc6, 0xa1, 0x8d, 0x3f, 0xd2, 0x5b, 0xaf, 0x3c, - 0x33, 0x2e, 0x8e, 0x38, 0x8b, 0x05, 0xb4, 0xd3, 0x79, 0x62, 0xe3, 0x6a, 0x10, 0x6f, 0x51, 0xe0, 0x34, 0x63, 0x63, - 0x20, 0xce, 0x6f, 0xe8, 0xad, 0x27, 0xfb, 0x63, 0xc6, 0x79, 0x3d, 0xb4, 0xd0, 0xa8, 0x77, 0x8d, 0x62, 0x73, 0x19, - 0x94, 0x41, 0x71, 0x2e, 0xda, 0x0e, 0x49, 0xad, 0x5e, 0x65, 0x1e, 0x22, 0x54, 0xdc, 0x77, 0x2a, 0xf8, 0x1b, 0x53, - 0xb4, 0xf1, 0x5a, 0xe6, 0xeb, 0x4a, 0x23, 0x0a, 0x0d, 0xaa, 0x4c, 0x0f, 0xc8, 0xe8, 0x58, 0x68, 0xf6, 0x2a, 0x9a, - 0x1b, 0x8e, 0xb0, 0x6f, 0xb8, 0xea, 0xd4, 0xfb, 0xab, 0x4c, 0x08, 0xa9, 0x22, 0x49, 0x2f, 0xaa, 0x76, 0xd6, 0xad, - 0x03, 0x78, 0x87, 0x84, 0x16, 0x5f, 0x9c, 0xc9, 0x2c, 0x74, 0xb6, 0xe8, 0xdf, 0x38, 0x71, 0x16, 0x7a, 0x0a, 0x5e, - 0x6e, 0x62, 0x91, 0x17, 0x40, 0x85, 0x8a, 0xbe, 0x64, 0x02, 0x20, 0x1b, 0x39, 0x6c, 0x4d, 0x6a, 0x66, 0x42, 0x6a, - 0xba, 0x06, 0xc6, 0xb7, 0x48, 0x49, 0x2a, 0x90, 0x21, 0x94, 0x48, 0x21, 0xf4, 0xd4, 0xe2, 0x2a, 0x12, 0x32, 0x17, - 0xb4, 0x3c, 0x41, 0x27, 0xd7, 0x3c, 0xab, 0x81, 0xe5, 0x88, 0x7e, 0x50, 0xe1, 0xc1, 0x94, 0xa8, 0xac, 0x50, 0x68, - 0x77, 0x4e, 0xae, 0xd3, 0x5b, 0x9d, 0xd4, 0xd5, 0xd3, 0x22, 0x1a, 0x25, 0x4e, 0x84, 0x16, 0xb9, 0x13, 0xe1, 0x0c, - 0xd2, 0x11, 0xd3, 0xa2, 0x84, 0x9f, 0x9a, 0xab, 0x51, 0x4b, 0x56, 0xde, 0x7c, 0xca, 0x0f, 0x94, 0x79, 0x0e, 0x29, - 0x9a, 0x38, 0xd7, 0x3c, 0x25, 0x77, 0xc4, 0x71, 0x3b, 0x63, 0xd9, 0xbe, 0x57, 0x09, 0x3a, 0x0a, 0xb0, 0xbf, 0x71, - 0x67, 0x61, 0xcc, 0xc2, 0x3c, 0xd1, 0xad, 0x4e, 0xfd, 0xa9, 0x60, 0x5f, 0x95, 0x43, 0xea, 0x24, 0x64, 0x45, 0xe2, - 0xdc, 0x9d, 0x6a, 0xf9, 0xcb, 0x8c, 0x66, 0xb7, 0x67, 0x14, 0x52, 0x9d, 0x53, 0x38, 0xf0, 0x5b, 0x2d, 0x43, 0x95, - 0xa7, 0x3e, 0xc8, 0x84, 0xb2, 0x52, 0xd4, 0xcf, 0x01, 0xae, 0x9e, 0x12, 0x2c, 0x44, 0xb4, 0xd1, 0x70, 0xc4, 0xc8, - 0xdd, 0x42, 0xb7, 0x9e, 0x9f, 0xa4, 0x3d, 0x06, 0xfe, 0xb5, 0x0a, 0xd3, 0x2a, 0x58, 0x80, 0x53, 0xf3, 0x4c, 0xea, - 0x79, 0x32, 0x5c, 0xf5, 0xca, 0x40, 0x11, 0x84, 0xef, 0xb2, 0xed, 0x53, 0xdd, 0x94, 0x34, 0xbb, 0x7d, 0xaa, 0xb5, - 0xa0, 0x9f, 0x48, 0xf8, 0xc1, 0x6a, 0x9c, 0xf2, 0x04, 0x33, 0x2b, 0x0a, 0x54, 0x00, 0x78, 0x7f, 0xe9, 0x39, 0xce, - 0x5f, 0x54, 0xca, 0xa0, 0x0b, 0xb1, 0xd8, 0xb3, 0x38, 0xd5, 0x4c, 0xbc, 0x1a, 0xff, 0x2f, 0x6b, 0xe3, 0xff, 0xc5, - 0x38, 0x75, 0x0a, 0xa6, 0xd1, 0x38, 0xa1, 0xa1, 0x66, 0x9d, 0x48, 0x12, 0xa0, 0xd0, 0xdb, 0x32, 0x4e, 0x3e, 0x5e, - 0x7a, 0xa0, 0x71, 0x2d, 0x46, 0x69, 0xc2, 0x9b, 0x23, 0x7f, 0xc2, 0xe2, 0x5b, 0x6f, 0xc6, 0x9a, 0x93, 0x34, 0x49, - 0xf3, 0xa9, 0x1f, 0x50, 0x9c, 0xdf, 0xe6, 0x9c, 0x4e, 0x9a, 0x33, 0x86, 0x9f, 0xd3, 0xf8, 0x9a, 0x72, 0x16, 0xf8, - 0xd8, 0x3e, 0xc9, 0x98, 0x1f, 0x5b, 0xaf, 0xfd, 0x2c, 0x4b, 0xe7, 0x36, 0x7e, 0x97, 0x5e, 0xa5, 0x3c, 0xc5, 0x6f, - 0x6e, 0x6e, 0xc7, 0x34, 0xc1, 0x1f, 0xae, 0x66, 0x09, 0x9f, 0xe1, 0xdc, 0x4f, 0xf2, 0x66, 0x4e, 0x33, 0x36, 0xea, - 0x05, 0x69, 0x9c, 0x66, 0x4d, 0xc8, 0xd8, 0x9e, 0x50, 0x2f, 0x66, 0xe3, 0x88, 0x5b, 0xa1, 0x9f, 0x7d, 0xec, 0x35, - 0x9b, 0xd3, 0x8c, 0x4d, 0xfc, 0xec, 0xb6, 0x29, 0x6a, 0x78, 0x5f, 0xb6, 0xf7, 0xfd, 0xc7, 0xa3, 0x83, 0x1e, 0xcf, - 0xfc, 0x24, 0x67, 0xb0, 0x4c, 0x9e, 0x1f, 0xc7, 0xd6, 0xfe, 0x61, 0x7b, 0x92, 0xef, 0xc8, 0x40, 0x9e, 0x9f, 0xf0, - 0xe2, 0x12, 0xbf, 0x07, 0xb8, 0xdd, 0x2b, 0x9e, 0xe0, 0xab, 0x19, 0xe7, 0x69, 0xb2, 0x08, 0x66, 0x59, 0x9e, 0x66, - 0xde, 0x34, 0x65, 0x09, 0xa7, 0x59, 0xef, 0x2a, 0xcd, 0x42, 0x9a, 0x35, 0x33, 0x3f, 0x64, 0xb3, 0xdc, 0x3b, 0x98, - 0xde, 0xf4, 0x40, 0xb3, 0x18, 0x67, 0xe9, 0x2c, 0x09, 0xd5, 0x58, 0x2c, 0x89, 0x68, 0xc6, 0xb8, 0xf9, 0x42, 0x5c, - 0x64, 0xe2, 0xc5, 0x2c, 0xa1, 0x7e, 0xd6, 0x1c, 0x43, 0x63, 0x30, 0x8b, 0xda, 0x21, 0x1d, 0xe3, 0x6c, 0x7c, 0xe5, - 0x3b, 0x9d, 0xee, 0x23, 0xac, 0xff, 0x77, 0x0f, 0x91, 0xd5, 0xde, 0x5c, 0xdc, 0x69, 0xb7, 0xff, 0x84, 0x7a, 0x2b, - 0xa3, 0x08, 0x80, 0xbc, 0xce, 0xf4, 0xc6, 0xca, 0x53, 0xc8, 0x68, 0xdb, 0xd4, 0xb2, 0x37, 0xf5, 0x43, 0xc8, 0x07, - 0xf6, 0xba, 0xd3, 0x9b, 0x02, 0x66, 0xe7, 0xc9, 0x14, 0x53, 0x35, 0x49, 0xf5, 0xb4, 0xf8, 0xad, 0x10, 0x1f, 0x6d, - 0x86, 0xb8, 0xab, 0x21, 0xae, 0xb0, 0xde, 0x0c, 0x67, 0x99, 0x88, 0xad, 0x7a, 0x9d, 0x5c, 0x02, 0x12, 0xa5, 0xd7, - 0x34, 0xd3, 0x70, 0x88, 0x87, 0xdf, 0x0c, 0x46, 0x77, 0x33, 0x18, 0x47, 0x9f, 0x02, 0x23, 0x4b, 0xc2, 0x45, 0x7d, - 0x5d, 0x3b, 0x19, 0x9d, 0xf4, 0x22, 0x0a, 0xf4, 0xe4, 0x75, 0xe1, 0xf7, 0x9c, 0x85, 0x3c, 0x92, 0x3f, 0x05, 0x39, - 0xcf, 0xe5, 0xbb, 0xc3, 0x76, 0x5b, 0x3e, 0xe7, 0xec, 0x57, 0xea, 0x75, 0x5c, 0xa8, 0x50, 0x5c, 0xe2, 0x1f, 0xca, - 0xd3, 0xbc, 0x75, 0xee, 0x89, 0xff, 0x62, 0x1e, 0xf3, 0x35, 0x52, 0x14, 0xab, 0x43, 0xd1, 0x38, 0xd5, 0xb2, 0x52, - 0x0a, 0x1f, 0x70, 0xdb, 0x09, 0xee, 0x48, 0x58, 0xbf, 0x3c, 0xc6, 0xc9, 0x06, 0x7f, 0x91, 0x79, 0x17, 0x1e, 0x44, - 0x3a, 0x8c, 0x54, 0xc3, 0xb4, 0x97, 0xf5, 0x49, 0xbb, 0x97, 0x35, 0x9b, 0xc8, 0x49, 0x09, 0x9c, 0x16, 0x90, 0xc9, - 0x79, 0x0e, 0x1b, 0xa4, 0xc2, 0xd8, 0x4e, 0x90, 0x97, 0xc2, 0x59, 0xd3, 0xe5, 0x32, 0xa9, 0x12, 0x32, 0xc4, 0x69, - 0x8d, 0x1f, 0xb8, 0xaa, 0x80, 0x13, 0x83, 0x93, 0xfb, 0xfa, 0x7a, 0x97, 0x5c, 0xf3, 0x8a, 0x38, 0x0d, 0x04, 0xe6, - 0xdc, 0xa9, 0xcf, 0x23, 0xf0, 0x52, 0x94, 0xe2, 0xa7, 0x4a, 0x61, 0xb2, 0x5b, 0x36, 0x1a, 0xe4, 0x65, 0x7e, 0x1b, - 0xe4, 0xf1, 0xe5, 0x05, 0xf4, 0x72, 0xc5, 0x09, 0xf4, 0x58, 0xf5, 0xff, 0x81, 0x1b, 0x92, 0x3a, 0x77, 0x59, 0x12, - 0xc4, 0xb3, 0x90, 0xe6, 0xa2, 0x87, 0x4a, 0x9c, 0xc3, 0xdd, 0x10, 0x65, 0x2d, 0xd1, 0x04, 0x7a, 0x17, 0xd9, 0x3c, - 0x50, 0x11, 0x6e, 0x51, 0x29, 0x9f, 0x9b, 0xe2, 0xb9, 0x6a, 0xfb, 0xba, 0x4a, 0x16, 0x85, 0x96, 0xee, 0x2c, 0x61, - 0xbf, 0xcc, 0xe8, 0x05, 0x0b, 0x8d, 0x93, 0xbb, 0x34, 0x09, 0xd2, 0x90, 0x7e, 0x78, 0xf7, 0x02, 0xb2, 0xdd, 0xd3, - 0x04, 0x48, 0x4c, 0xf9, 0xbb, 0x70, 0x42, 0x40, 0x23, 0xbc, 0x66, 0x01, 0x1d, 0x5c, 0xee, 0x2e, 0x36, 0x56, 0x94, - 0xaf, 0x51, 0xd1, 0xba, 0x14, 0x49, 0x7f, 0x02, 0xca, 0xcb, 0xdd, 0xc5, 0x15, 0x2f, 0x5a, 0xbb, 0x8b, 0xdc, 0x0d, - 0xd3, 0x89, 0xcf, 0x12, 0xf8, 0x9d, 0x14, 0xbb, 0x0b, 0x06, 0x3f, 0x78, 0x71, 0x59, 0x54, 0x89, 0xa2, 0x25, 0x44, - 0xc6, 0x14, 0x14, 0xee, 0x3a, 0xc8, 0xfd, 0x39, 0x65, 0x89, 0x28, 0xba, 0xab, 0x67, 0xaa, 0x7b, 0x05, 0x24, 0xff, - 0x4a, 0xa4, 0xc1, 0xac, 0xcd, 0xe5, 0xd1, 0x7d, 0xcd, 0x65, 0x9a, 0x70, 0x26, 0xd2, 0xe2, 0x75, 0x38, 0x27, 0xf2, - 0xf3, 0x8b, 0x40, 0x9e, 0x44, 0xcd, 0xab, 0x53, 0x17, 0xbe, 0x40, 0xac, 0xb4, 0x80, 0x69, 0x26, 0x8c, 0x7d, 0xba, - 0xfd, 0xa8, 0x64, 0x7e, 0x97, 0xf1, 0x57, 0x52, 0x55, 0x9e, 0xce, 0xb2, 0x00, 0x62, 0xbd, 0x4a, 0xa5, 0x58, 0xf7, - 0x8a, 0xd9, 0x42, 0x7f, 0xb3, 0x31, 0x37, 0x92, 0x6c, 0x39, 0x9c, 0xe9, 0xab, 0xae, 0xed, 0xa0, 0x22, 0x9e, 0x08, - 0x6b, 0xc6, 0xc4, 0xea, 0x5d, 0xb0, 0x10, 0x02, 0x2f, 0x2c, 0x54, 0x09, 0x8b, 0xb5, 0x49, 0x82, 0x8a, 0x14, 0x8a, - 0x0c, 0x52, 0xb8, 0x6c, 0x27, 0xad, 0x56, 0x01, 0x84, 0x1f, 0xd2, 0x2e, 0xf9, 0x66, 0x67, 0x6f, 0x2f, 0xa9, 0x4e, - 0xb4, 0x31, 0x85, 0xf3, 0xe5, 0x92, 0x53, 0x27, 0x91, 0xa7, 0x6e, 0x22, 0x02, 0xca, 0x18, 0xc3, 0xf2, 0x8d, 0x97, - 0xe2, 0xb2, 0x27, 0x2f, 0x29, 0x7a, 0x91, 0x40, 0xa2, 0x44, 0x19, 0xd1, 0x48, 0x3d, 0xd1, 0x2a, 0x19, 0x36, 0x5f, - 0x97, 0x07, 0xf9, 0x6b, 0x58, 0x6f, 0xaf, 0x2c, 0x8e, 0xb4, 0xaa, 0xa2, 0xd5, 0xd2, 0x3c, 0xcd, 0xb8, 0xe3, 0xf8, - 0x38, 0x40, 0xa4, 0xef, 0x8b, 0xd9, 0x1f, 0xcb, 0x7c, 0x8f, 0x41, 0xb3, 0xe3, 0x75, 0x4a, 0x7f, 0x48, 0xed, 0x7c, - 0xb5, 0xcc, 0x36, 0x53, 0x67, 0x74, 0x01, 0x4f, 0xb8, 0xfc, 0xad, 0xd0, 0x57, 0x15, 0xc8, 0xd9, 0x55, 0xcf, 0xe5, - 0x24, 0xb1, 0x62, 0x68, 0x52, 0x19, 0x70, 0x6a, 0x50, 0x9d, 0x67, 0x43, 0xcc, 0xb6, 0x8c, 0x8d, 0x8a, 0x0a, 0x11, - 0xe5, 0xe6, 0xbe, 0x94, 0x4a, 0xd0, 0x85, 0x41, 0xdd, 0x97, 0x4c, 0xbb, 0xf1, 0xea, 0x74, 0x57, 0x28, 0x14, 0x19, - 0x9c, 0x61, 0x53, 0x35, 0x09, 0xcb, 0x2d, 0xc9, 0x37, 0x12, 0xaf, 0x2b, 0x1f, 0xa9, 0xa4, 0x8d, 0xcd, 0x55, 0x44, - 0x32, 0xe4, 0x26, 0xc0, 0xc0, 0x31, 0x90, 0x73, 0x3d, 0x05, 0xe0, 0x31, 0x23, 0x0a, 0x27, 0x95, 0x14, 0xc7, 0xc1, - 0x0b, 0xa9, 0xdd, 0x7b, 0xf6, 0xdb, 0x37, 0x67, 0xef, 0x6d, 0x0c, 0x57, 0x9d, 0xd1, 0x2c, 0xf7, 0x16, 0xb6, 0xca, - 0x31, 0x6c, 0x42, 0xbc, 0xda, 0xf6, 0x6c, 0x7f, 0x0a, 0x87, 0xb6, 0x05, 0x53, 0x6d, 0xdd, 0x34, 0xe7, 0xf3, 0x79, - 0x13, 0x4e, 0x94, 0x35, 0x67, 0x59, 0x2c, 0xd9, 0x4d, 0x68, 0x17, 0x05, 0x72, 0x79, 0x44, 0x93, 0xf2, 0x32, 0xa4, - 0x34, 0xa6, 0x6e, 0x9c, 0x8e, 0xe5, 0x79, 0xd8, 0x55, 0xf7, 0x44, 0x7c, 0x79, 0x2c, 0x2e, 0xf9, 0xea, 0x1f, 0x73, - 0x79, 0xbd, 0x1a, 0xcf, 0xe0, 0x67, 0x1f, 0x82, 0x57, 0xc7, 0x2d, 0x1e, 0x89, 0x87, 0x33, 0xd8, 0x4d, 0xe2, 0x69, - 0x77, 0xb1, 0x46, 0x75, 0x03, 0xe8, 0x22, 0xea, 0xcb, 0xa9, 0xe5, 0xa2, 0xd6, 0xa5, 0x17, 0x5f, 0x5e, 0x16, 0xc7, - 0x2d, 0xe8, 0xab, 0xa5, 0xfb, 0xbd, 0x4a, 0xc3, 0x5b, 0xdd, 0xbe, 0xa4, 0x44, 0xb8, 0xec, 0x29, 0x27, 0x7d, 0xe8, - 0x02, 0xc6, 0x0d, 0xfb, 0x02, 0x67, 0x8a, 0x85, 0x9e, 0x57, 0x0f, 0xc5, 0xd0, 0x02, 0x86, 0x59, 0x40, 0x09, 0x90, - 0x1b, 0x74, 0x1e, 0x96, 0x0d, 0xc4, 0x6e, 0x97, 0x45, 0xdb, 0x00, 0x94, 0x15, 0xab, 0xfd, 0x23, 0xdd, 0xdc, 0x15, - 0x59, 0x68, 0x88, 0x43, 0x13, 0xf8, 0x4b, 0x04, 0xff, 0x0a, 0xc0, 0x8f, 0x5b, 0x12, 0x4d, 0x97, 0xe6, 0xb5, 0x33, - 0xf2, 0x42, 0x88, 0x12, 0x99, 0xe7, 0x19, 0xc7, 0xef, 0x39, 0xfe, 0x78, 0x29, 0xaa, 0x6a, 0x2d, 0x01, 0xd4, 0x57, - 0xd0, 0xa6, 0xda, 0x5a, 0x1d, 0x0c, 0xd2, 0x38, 0xf6, 0xa7, 0x39, 0xf5, 0xf4, 0x0f, 0xa5, 0x30, 0x80, 0xde, 0xb1, - 0xae, 0xa1, 0xa9, 0xbc, 0xa7, 0x53, 0xd0, 0xe3, 0xd6, 0xd5, 0xc7, 0x6b, 0x3f, 0x73, 0x9a, 0xcd, 0xa0, 0x79, 0x35, - 0x46, 0x05, 0x8f, 0x16, 0xa6, 0xba, 0xf1, 0xb0, 0xdd, 0xee, 0x41, 0x92, 0x6a, 0xd3, 0x8f, 0xd9, 0x38, 0xf1, 0x62, - 0x3a, 0xe2, 0x05, 0x87, 0xd3, 0x83, 0x0b, 0xad, 0xdf, 0xb9, 0xdd, 0xc3, 0x8c, 0x4e, 0x2c, 0x17, 0xfe, 0xde, 0x3d, - 0x70, 0xc1, 0x43, 0x2f, 0xe1, 0x51, 0x53, 0x24, 0x43, 0xc3, 0x51, 0x0e, 0x1e, 0xd5, 0x9e, 0x17, 0xc6, 0x40, 0x01, - 0x05, 0xdd, 0xb7, 0xe0, 0x99, 0xc5, 0x23, 0xcc, 0x33, 0xb3, 0x5e, 0x82, 0x16, 0x6b, 0x33, 0x58, 0x57, 0xc1, 0xf6, - 0x51, 0x91, 0x0b, 0x8b, 0x65, 0xb1, 0x86, 0x17, 0x43, 0x95, 0x2e, 0x58, 0x32, 0x9d, 0xf1, 0x73, 0xe1, 0xf9, 0xcf, - 0xe0, 0x0c, 0xc9, 0x10, 0x1b, 0x25, 0x00, 0xcf, 0x50, 0xb5, 0x0f, 0xfc, 0x38, 0x70, 0xa0, 0x13, 0xab, 0x69, 0x1d, - 0x65, 0x74, 0x82, 0x7a, 0x13, 0x96, 0x34, 0xe5, 0xbb, 0x43, 0x43, 0x77, 0x73, 0x1f, 0xc1, 0x53, 0xe1, 0x8a, 0xde, - 0xb0, 0x48, 0xf0, 0xdd, 0x30, 0xaf, 0xcb, 0x61, 0x51, 0xf4, 0x52, 0xee, 0x9c, 0xbf, 0x70, 0xd0, 0x10, 0xff, 0x6a, - 0x5c, 0x62, 0x63, 0x6b, 0xaa, 0xb6, 0x71, 0x17, 0x6d, 0xa9, 0x62, 0xd2, 0xa5, 0xa8, 0xf6, 0x2b, 0x81, 0x8a, 0x2f, - 0x1d, 0x9b, 0xe6, 0xd3, 0xa6, 0x64, 0x3f, 0x4d, 0x41, 0x3e, 0x36, 0x34, 0x45, 0xca, 0x9d, 0x4d, 0xe9, 0x42, 0x70, - 0x16, 0x75, 0x8e, 0x45, 0x7a, 0x5c, 0x86, 0xe5, 0xb9, 0x27, 0xf5, 0x6c, 0x9e, 0x74, 0x42, 0xb5, 0xad, 0x7f, 0x79, - 0x52, 0x67, 0x53, 0x20, 0xff, 0xcb, 0xbb, 0xfe, 0xfc, 0x38, 0x86, 0x01, 0x2f, 0xb5, 0xd2, 0x60, 0x5e, 0x8d, 0x72, - 0xce, 0x87, 0x0e, 0x2a, 0xd4, 0x9e, 0x79, 0x22, 0xf4, 0x6e, 0xe3, 0x82, 0xc1, 0x1d, 0xae, 0x23, 0x6a, 0xf2, 0x04, - 0x33, 0x83, 0x9c, 0x80, 0x5a, 0xee, 0x78, 0xaf, 0x62, 0x33, 0x52, 0x6b, 0xb7, 0xc4, 0x84, 0x88, 0x9d, 0x25, 0xa1, - 0x6d, 0xfd, 0x39, 0x88, 0x59, 0xf0, 0x91, 0xd8, 0xbb, 0x0b, 0x07, 0xad, 0x1f, 0x0d, 0x15, 0x3b, 0x54, 0xf3, 0x5c, - 0x54, 0x8f, 0x36, 0x64, 0xae, 0xc1, 0x4e, 0xe5, 0xed, 0x41, 0x76, 0x1f, 0x54, 0x9b, 0xe3, 0x96, 0x1c, 0xa7, 0x7f, - 0x59, 0x5c, 0x54, 0xb7, 0x82, 0x55, 0x50, 0x00, 0x9a, 0x65, 0xb9, 0x25, 0xe8, 0x8f, 0xd8, 0x72, 0x0b, 0xd5, 0x2c, - 0x40, 0x6c, 0xd2, 0x3e, 0xb2, 0x2d, 0xc9, 0x60, 0x00, 0x4e, 0xae, 0x78, 0x8d, 0x6d, 0xfd, 0xb9, 0x2c, 0xa3, 0xa5, - 0xdb, 0x47, 0xe4, 0xad, 0x10, 0x1b, 0xc6, 0x02, 0x5b, 0xdf, 0x0d, 0x29, 0xf7, 0x59, 0x2c, 0x9b, 0xf4, 0xb4, 0x97, - 0x62, 0x65, 0x46, 0xcb, 0x65, 0x52, 0x9f, 0x0b, 0xab, 0x63, 0x50, 0xcc, 0xec, 0xb8, 0x55, 0xc1, 0x2d, 0x66, 0x26, - 0xf6, 0x87, 0x19, 0x3f, 0xad, 0x66, 0x28, 0xdf, 0x59, 0x7f, 0x0e, 0xc4, 0xc9, 0x2a, 0x00, 0x30, 0x55, 0x00, 0x42, - 0x64, 0x5f, 0x2a, 0x21, 0x8e, 0x4f, 0x52, 0x97, 0xfb, 0xd9, 0x98, 0xf2, 0x15, 0xc4, 0xfa, 0x32, 0x91, 0xb7, 0xa7, - 0xa3, 0xf8, 0x6b, 0xd0, 0x06, 0x75, 0x68, 0x41, 0xcf, 0x2d, 0x06, 0xa0, 0xaa, 0x92, 0x8d, 0x1a, 0x6f, 0x84, 0x40, - 0xf6, 0x89, 0xc5, 0x49, 0x04, 0xb7, 0x4f, 0x05, 0xb7, 0x97, 0x71, 0x38, 0x4b, 0x8c, 0x25, 0x40, 0x2c, 0x6c, 0x6b, - 0x20, 0x21, 0xa7, 0xa1, 0x84, 0x99, 0x64, 0xa2, 0x55, 0x5a, 0x1c, 0xb7, 0x64, 0x6d, 0xc9, 0x8e, 0x65, 0x25, 0x40, - 0x82, 0xd8, 0xa7, 0x15, 0x0e, 0x20, 0xf9, 0xdb, 0xc4, 0x43, 0xc8, 0xae, 0x4b, 0x62, 0x13, 0x67, 0xcc, 0xfa, 0xc7, - 0xb1, 0x7f, 0x45, 0xe3, 0xfe, 0xee, 0x22, 0x5b, 0x2e, 0xdb, 0xc5, 0x71, 0x4b, 0x3e, 0x5a, 0xc7, 0x82, 0x6f, 0xc8, - 0xbb, 0x41, 0xc5, 0x12, 0xc3, 0xc1, 0x4d, 0x48, 0x89, 0xd5, 0xb9, 0x60, 0x9e, 0xea, 0xa0, 0xb0, 0x2d, 0x91, 0x85, - 0x22, 0x2a, 0x95, 0x3a, 0x4d, 0x61, 0x5b, 0x2c, 0x5c, 0x2f, 0xcb, 0x39, 0x9d, 0x42, 0x69, 0xb4, 0x5c, 0x76, 0x0a, - 0xdb, 0x9a, 0xb0, 0x04, 0x9e, 0xb2, 0xe5, 0x52, 0x9c, 0x89, 0x9c, 0xb0, 0xc4, 0x69, 0x03, 0xd9, 0xda, 0xd6, 0xc4, - 0xbf, 0x11, 0x13, 0xd6, 0x6f, 0xfc, 0x1b, 0xa7, 0xa3, 0x5e, 0xb9, 0x25, 0x7e, 0x12, 0xa0, 0xb8, 0x6a, 0x45, 0x7d, - 0xb5, 0xa2, 0x21, 0x9e, 0xc9, 0xd3, 0x5e, 0xc4, 0x09, 0x89, 0xbf, 0x79, 0x45, 0x43, 0xbd, 0xa2, 0xb3, 0x2d, 0x2b, - 0x3a, 0xbb, 0x63, 0x45, 0x03, 0xb5, 0x7a, 0x56, 0x89, 0xbb, 0x74, 0xb9, 0xec, 0xb4, 0x2b, 0xec, 0x1d, 0xb7, 0x42, - 0x76, 0x0d, 0xab, 0x01, 0x9a, 0x1a, 0x67, 0x13, 0xba, 0x99, 0x28, 0xeb, 0x28, 0xa6, 0x9f, 0x85, 0xc9, 0x0a, 0x0b, - 0x59, 0x1d, 0x0b, 0x26, 0x5d, 0x97, 0x81, 0xc9, 0x3f, 0x92, 0xb2, 0x19, 0xe0, 0x21, 0x01, 0x3c, 0x44, 0xfa, 0xae, - 0x50, 0xc7, 0x7e, 0x6f, 0x63, 0xdb, 0xb2, 0x35, 0x59, 0x5f, 0x16, 0x17, 0x20, 0x23, 0xc4, 0xfc, 0xee, 0x45, 0x8b, - 0x50, 0xdb, 0xee, 0x6f, 0xa7, 0x39, 0xc8, 0x21, 0x98, 0xa7, 0x59, 0x68, 0x7b, 0xb2, 0xea, 0x67, 0xa1, 0x6a, 0xc2, - 0x12, 0x95, 0x91, 0xb6, 0x95, 0xd6, 0xaa, 0xf7, 0x26, 0xc5, 0x75, 0x0f, 0x0f, 0x65, 0x8d, 0xa9, 0xcf, 0x39, 0xcd, - 0x12, 0x45, 0xb9, 0xb6, 0xfd, 0x1f, 0x82, 0x0a, 0x37, 0xf0, 0x95, 0x40, 0x2f, 0x80, 0x26, 0x40, 0xa5, 0x73, 0x2b, - 0x9e, 0x2f, 0xc5, 0xd3, 0x4e, 0xa5, 0x6c, 0xde, 0x22, 0x53, 0xef, 0x97, 0x45, 0x60, 0x86, 0xcc, 0x26, 0x34, 0xbc, - 0x10, 0x0c, 0x7a, 0x10, 0x5f, 0x2a, 0xe5, 0x71, 0x45, 0xdc, 0x55, 0x0d, 0xb0, 0xfd, 0xd3, 0xac, 0xfb, 0xe8, 0xe0, - 0xd4, 0xc6, 0x92, 0xc7, 0xa7, 0xa3, 0x91, 0x8d, 0x0a, 0xeb, 0x7e, 0xcd, 0x3a, 0x07, 0x3f, 0xcd, 0xbe, 0x7e, 0xd6, - 0xfe, 0xba, 0x6c, 0x9c, 0x00, 0x11, 0xa9, 0x24, 0x08, 0x2d, 0xaa, 0x0c, 0x78, 0xf5, 0x8c, 0x46, 0x7e, 0xb2, 0x7d, - 0x3a, 0xe7, 0xe6, 0x74, 0xf2, 0x29, 0xa5, 0x21, 0x10, 0x27, 0x5e, 0x2b, 0xbd, 0x88, 0xe9, 0x35, 0xd5, 0x37, 0x34, - 0x6e, 0x18, 0x6c, 0x43, 0x8b, 0x20, 0x9d, 0x25, 0x5c, 0x65, 0x83, 0x28, 0x56, 0x6b, 0x4c, 0xe9, 0x52, 0xcc, 0xc1, - 0x54, 0xe7, 0x6f, 0xa5, 0x9c, 0xab, 0x4b, 0xaf, 0xe2, 0x12, 0xdb, 0x06, 0x00, 0x5b, 0x21, 0x1b, 0x6c, 0x29, 0xf7, - 0xda, 0xb8, 0xbd, 0x0d, 0x36, 0xdc, 0x41, 0x9e, 0x6d, 0x0f, 0x35, 0x9e, 0x84, 0x43, 0xb7, 0x76, 0xa9, 0xc6, 0x56, - 0x7c, 0x7d, 0x12, 0x03, 0x57, 0x19, 0x74, 0x96, 0xd0, 0x3c, 0xdf, 0x8a, 0x80, 0x72, 0x11, 0xb1, 0x5d, 0xd5, 0xb6, - 0xb7, 0xf4, 0x82, 0xdb, 0x18, 0x76, 0x98, 0x00, 0xb8, 0x56, 0x45, 0xa8, 0x1b, 0x17, 0x70, 0xee, 0xe9, 0x3e, 0x03, - 0x55, 0xb5, 0xb7, 0xf5, 0x82, 0x3b, 0x87, 0x07, 0x78, 0xff, 0x51, 0x5b, 0x0d, 0xa5, 0x23, 0xd8, 0xaa, 0x1e, 0x1d, - 0x8d, 0x68, 0x50, 0xba, 0xde, 0x21, 0x16, 0x39, 0x62, 0x31, 0x87, 0x90, 0x9c, 0x88, 0x95, 0xd9, 0xaf, 0xd3, 0x84, - 0xda, 0x48, 0x67, 0xd7, 0x2a, 0x54, 0x29, 0x55, 0x63, 0x33, 0x44, 0xb2, 0xc7, 0x3a, 0x34, 0x6a, 0x94, 0xe5, 0x52, - 0x7b, 0x86, 0x6a, 0xe5, 0xf5, 0x35, 0x4b, 0x85, 0xeb, 0x67, 0xdb, 0x5e, 0xbd, 0xdf, 0x8e, 0x5c, 0x74, 0xbe, 0x3e, - 0xec, 0xb4, 0x0b, 0x1b, 0xdb, 0xd0, 0xdd, 0x7d, 0x37, 0xa4, 0x68, 0xb5, 0x0f, 0xad, 0x66, 0xc9, 0xe7, 0xb4, 0xeb, - 0x76, 0x1e, 0x77, 0x6c, 0x2c, 0xaf, 0x75, 0x40, 0x45, 0xc9, 0x77, 0x02, 0x70, 0x46, 0xff, 0xee, 0xa9, 0xd4, 0x3b, - 0xbf, 0x1f, 0x3c, 0x0f, 0x3b, 0x6d, 0x1b, 0xdb, 0x39, 0x4f, 0xa7, 0x9f, 0x31, 0x85, 0x7d, 0xa0, 0xa6, 0x38, 0xcd, - 0xa9, 0x39, 0x07, 0xa9, 0x39, 0xff, 0xfe, 0x49, 0x48, 0x88, 0xa6, 0x19, 0xcd, 0x73, 0xcb, 0xec, 0x5f, 0x91, 0xd2, - 0x27, 0x78, 0xf3, 0x46, 0x8a, 0xcb, 0x29, 0x17, 0x78, 0x91, 0x37, 0x2e, 0x98, 0x54, 0x25, 0xcb, 0xd6, 0x88, 0x4d, - 0x48, 0x9b, 0x92, 0x87, 0x4a, 0x45, 0xee, 0x93, 0x23, 0x6f, 0xd8, 0x7c, 0x72, 0x60, 0x19, 0xa3, 0x5f, 0x1f, 0xa0, - 0x56, 0x32, 0x61, 0xc9, 0xc5, 0x86, 0x52, 0xff, 0x66, 0x43, 0x29, 0x68, 0x87, 0x25, 0x74, 0xea, 0x36, 0xa0, 0x4f, - 0x63, 0xbd, 0xd2, 0xb1, 0x4c, 0x10, 0x43, 0xe1, 0xea, 0xfc, 0x04, 0xa4, 0xc6, 0x32, 0x88, 0x1e, 0x7e, 0xfb, 0x70, - 0x50, 0xf2, 0x39, 0xc3, 0x95, 0xbd, 0xfc, 0xbe, 0x19, 0x42, 0x69, 0x13, 0xe2, 0x09, 0xf1, 0x67, 0xcd, 0x95, 0xde, - 0x7c, 0x9a, 0xe0, 0x0c, 0x05, 0xee, 0x77, 0x2c, 0xbd, 0xba, 0x55, 0x60, 0x75, 0xed, 0x37, 0x14, 0x2b, 0x1d, 0xab, - 0x5c, 0xff, 0x20, 0x66, 0x93, 0x8a, 0x04, 0xd6, 0xc1, 0x14, 0xca, 0x15, 0x24, 0x97, 0x99, 0x9d, 0x48, 0x2d, 0x4b, - 0x30, 0x7d, 0xb8, 0x95, 0x64, 0x96, 0xd1, 0x8b, 0x38, 0x9d, 0xaf, 0xde, 0xb3, 0xb6, 0xbd, 0x72, 0xc4, 0xc6, 0x91, - 0x71, 0x0e, 0x8e, 0x92, 0x72, 0x11, 0xee, 0x1c, 0xa0, 0xf8, 0x97, 0x7f, 0x76, 0xdd, 0x7f, 0xf9, 0xe7, 0x4f, 0x56, - 0x85, 0xee, 0x8b, 0x4b, 0xcc, 0xab, 0x6e, 0xb7, 0xef, 0xae, 0xcd, 0x23, 0xd5, 0x71, 0xbe, 0xb9, 0xce, 0xda, 0x22, - 0x08, 0x19, 0xb8, 0xba, 0x04, 0x6b, 0x85, 0x72, 0xf7, 0x59, 0xbf, 0x05, 0x30, 0x98, 0xd7, 0x27, 0x21, 0x83, 0x4a, - 0xbf, 0x0b, 0xb4, 0x4b, 0xe4, 0xdd, 0x6b, 0x45, 0x7e, 0x3b, 0x86, 0x3f, 0x35, 0x87, 0xdf, 0x09, 0xbe, 0x72, 0x85, - 0xc4, 0x97, 0x97, 0x65, 0xc2, 0xa3, 0xd9, 0x14, 0xae, 0x53, 0x18, 0xac, 0x95, 0x28, 0xc5, 0xc3, 0x6b, 0xa3, 0xbe, - 0x38, 0xae, 0x49, 0xe2, 0xcb, 0x57, 0x70, 0x87, 0xd2, 0xf1, 0x55, 0xa6, 0xfd, 0xba, 0x77, 0x08, 0x07, 0xe8, 0xa2, - 0x3e, 0x2b, 0xd1, 0xe9, 0x9a, 0x64, 0x80, 0x52, 0xb0, 0x6c, 0x00, 0x4c, 0x1c, 0x5f, 0x2a, 0xc3, 0xf6, 0x54, 0x7a, - 0x7c, 0xbc, 0x55, 0xd2, 0x56, 0x9e, 0xa0, 0x1a, 0xd2, 0xb1, 0xf5, 0x5e, 0xe0, 0x4b, 0x54, 0xa6, 0x95, 0x23, 0x41, - 0x78, 0xd5, 0xc0, 0x64, 0x29, 0xd9, 0xcf, 0xb5, 0x1f, 0x5f, 0xdf, 0x8f, 0xf1, 0x6d, 0x17, 0xa8, 0x4b, 0x6b, 0xf9, - 0x8f, 0x56, 0x09, 0x96, 0xcd, 0xe5, 0x26, 0x7d, 0x60, 0xee, 0x73, 0x9a, 0x5d, 0x44, 0x90, 0x73, 0x95, 0x7d, 0x82, - 0x39, 0xc1, 0x4a, 0x63, 0x2a, 0xfe, 0x32, 0xa2, 0xee, 0xac, 0xfe, 0x07, 0x71, 0x2a, 0x06, 0x09, 0x93, 0x30, 0x94, - 0xb1, 0x08, 0xff, 0x9f, 0x6f, 0xfd, 0x87, 0xe1, 0x5b, 0x77, 0x0f, 0x51, 0x3b, 0x8e, 0xfd, 0xd9, 0x0b, 0xf9, 0x1f, - 0x9b, 0xdd, 0x25, 0x82, 0xdd, 0xfd, 0x06, 0x46, 0x97, 0xfc, 0x63, 0x18, 0x9d, 0x30, 0xc7, 0x35, 0xa7, 0x5b, 0x8b, - 0x6a, 0xdf, 0xba, 0xfe, 0xdc, 0xbf, 0xad, 0xf6, 0x55, 0x7c, 0x79, 0x32, 0xf7, 0x6f, 0xab, 0x45, 0xd8, 0xce, 0x2e, - 0x56, 0xfb, 0x18, 0xd8, 0x6f, 0x5e, 0xdb, 0x9e, 0xfd, 0xe6, 0xeb, 0xaf, 0x6d, 0x7c, 0x99, 0x53, 0x3e, 0x80, 0x42, - 0xb2, 0xbb, 0xd8, 0x59, 0xad, 0x08, 0x1e, 0x1b, 0x98, 0xa2, 0x88, 0xb0, 0x41, 0x7e, 0xa3, 0xf1, 0x9e, 0xe5, 0x17, - 0x69, 0x62, 0x42, 0xf3, 0x16, 0x9c, 0x08, 0x9f, 0x0b, 0x8e, 0xe8, 0x65, 0x0d, 0x1e, 0x51, 0xba, 0x0a, 0x90, 0x28, - 0xac, 0x41, 0x54, 0xdd, 0x4e, 0x74, 0x37, 0xff, 0xaf, 0x6e, 0x60, 0x90, 0x17, 0x8b, 0x44, 0x83, 0xf8, 0xf2, 0x73, - 0xc4, 0x87, 0x1c, 0xac, 0x72, 0x0e, 0x6a, 0xcf, 0xaa, 0x5f, 0xec, 0x2e, 0xa2, 0xbd, 0x3d, 0x36, 0xb0, 0xb1, 0xb8, - 0x12, 0xaa, 0xd8, 0x24, 0x5c, 0x12, 0xf8, 0x93, 0xc1, 0x9f, 0xb4, 0x62, 0xd4, 0x2c, 0x19, 0x65, 0x7e, 0x46, 0xc3, - 0xed, 0x4c, 0xba, 0xbc, 0x4a, 0x49, 0x91, 0x86, 0xcc, 0xf5, 0xce, 0x2f, 0x44, 0x96, 0xd3, 0x84, 0x81, 0x3e, 0xba, - 0x63, 0x7e, 0x30, 0x48, 0xdd, 0xbd, 0x56, 0x7e, 0x6f, 0xc0, 0x44, 0x38, 0x25, 0x49, 0x99, 0x56, 0x01, 0x17, 0x78, - 0xaa, 0x44, 0x14, 0x6c, 0x23, 0xe1, 0xe0, 0x0f, 0x49, 0x5f, 0x64, 0x58, 0xbc, 0x48, 0xb8, 0x13, 0xba, 0x3c, 0x63, - 0x13, 0x07, 0xe1, 0x4e, 0x1b, 0x21, 0xed, 0x6c, 0x08, 0x49, 0x7f, 0x87, 0xe5, 0xaf, 0xfd, 0xd7, 0x4e, 0x28, 0xee, - 0xfc, 0x12, 0x5f, 0x09, 0x82, 0xf3, 0x98, 0x4f, 0x66, 0xa3, 0x11, 0xcd, 0x1c, 0x7d, 0xd6, 0xf0, 0xab, 0x03, 0x38, - 0xce, 0x0c, 0x6f, 0x9f, 0xfa, 0xdc, 0xff, 0x96, 0xd1, 0xb9, 0x93, 0xa2, 0x5e, 0x56, 0xdd, 0x03, 0x19, 0xe2, 0x19, - 0x22, 0xfd, 0x08, 0x72, 0xf0, 0x5f, 0x24, 0x7c, 0xbf, 0xeb, 0xcc, 0xbe, 0x3a, 0xc0, 0x21, 0xdc, 0xae, 0xa1, 0x13, - 0xc8, 0xe5, 0xb5, 0x28, 0x1f, 0x58, 0xc2, 0x8f, 0xe4, 0x89, 0xcf, 0x14, 0x29, 0x4f, 0x65, 0x99, 0x7c, 0x63, 0xf9, - 0x65, 0x87, 0x21, 0xe9, 0x07, 0x0d, 0x22, 0xcf, 0x7f, 0x8a, 0x0b, 0x7d, 0x4f, 0x23, 0x3f, 0x3b, 0x85, 0xb3, 0xe5, - 0x00, 0xe8, 0x15, 0x4f, 0x7d, 0x27, 0x28, 0x3f, 0x1a, 0xe5, 0xb4, 0x7e, 0x6a, 0xb4, 0xc6, 0x58, 0xe4, 0xdf, 0x54, - 0x45, 0x2d, 0x28, 0xba, 0x30, 0x8b, 0x48, 0x63, 0xb7, 0x85, 0x61, 0x0f, 0xf6, 0x36, 0xba, 0x83, 0xf5, 0xd2, 0x35, - 0xe7, 0x99, 0x3f, 0x2d, 0x43, 0x14, 0xa7, 0x7e, 0x96, 0x31, 0x9a, 0x59, 0xce, 0xf3, 0x5f, 0x91, 0xf7, 0x2f, 0xff, - 0xbc, 0x39, 0x54, 0xa1, 0xa2, 0x13, 0x16, 0xe4, 0xb1, 0x34, 0x45, 0xe6, 0x37, 0xb1, 0x03, 0xd9, 0xd0, 0xd6, 0x91, - 0x95, 0xfd, 0xa3, 0x76, 0xbb, 0xad, 0xa2, 0x0f, 0x1d, 0xf9, 0x13, 0xc2, 0x0d, 0xf0, 0x13, 0x1e, 0x44, 0x00, 0x9b, - 0xd8, 0x32, 0x16, 0x7a, 0xd4, 0x9e, 0xde, 0xd8, 0x7d, 0xd8, 0x0e, 0x0a, 0x8a, 0x77, 0x74, 0x4a, 0x7d, 0xfe, 0x59, - 0xe3, 0x67, 0xa2, 0x49, 0x39, 0x7c, 0x47, 0x0f, 0x5d, 0x8d, 0xbb, 0x32, 0xe8, 0xe1, 0xea, 0xa0, 0xef, 0xd9, 0x44, - 0xdc, 0x12, 0xb5, 0x6d, 0x54, 0xe1, 0x14, 0xaf, 0x8d, 0xc9, 0x65, 0x0b, 0xdb, 0x12, 0x18, 0x8f, 0xd2, 0x38, 0xa4, - 0x19, 0xb1, 0xa9, 0x3b, 0x76, 0xad, 0xc7, 0xed, 0x76, 0x1b, 0x37, 0x0f, 0x0e, 0xdb, 0x6d, 0x7c, 0xf8, 0xb0, 0x8d, - 0x9b, 0xf0, 0xc7, 0x75, 0xdd, 0x15, 0x18, 0xee, 0x0a, 0x10, 0x77, 0xda, 0x19, 0x9d, 0x28, 0x00, 0xef, 0x8c, 0x60, - 0x56, 0x7b, 0x02, 0xee, 0xb2, 0x56, 0xfb, 0x5e, 0x4a, 0x36, 0x75, 0x97, 0x82, 0xca, 0x7c, 0x15, 0xae, 0xc9, 0xb4, - 0x8a, 0xcf, 0x52, 0x79, 0xc7, 0xe0, 0x0b, 0x45, 0x08, 0x9e, 0x75, 0x0a, 0x17, 0xa5, 0x8a, 0xd0, 0x2c, 0x64, 0x1d, - 0xc1, 0xb7, 0xd8, 0xb8, 0xcf, 0x12, 0xf8, 0x4c, 0x97, 0x0e, 0xd0, 0x6a, 0x46, 0x95, 0xae, 0xe4, 0xf7, 0x3e, 0x90, - 0x11, 0xf0, 0x4d, 0x04, 0x31, 0x7c, 0x80, 0xb0, 0x7f, 0x9f, 0x06, 0x6a, 0x05, 0xa1, 0x7e, 0x70, 0x9f, 0xfa, 0x1a, - 0xfb, 0xc3, 0x07, 0x22, 0x0f, 0x6a, 0x27, 0x5a, 0x2e, 0x77, 0xfc, 0xe5, 0x72, 0x27, 0xb8, 0xff, 0x0c, 0xe5, 0xf2, - 0xea, 0x03, 0x17, 0x70, 0xc9, 0xa8, 0x04, 0xfa, 0x05, 0x94, 0x7b, 0x11, 0x96, 0x20, 0xc9, 0x27, 0x1f, 0xab, 0x01, - 0xe5, 0x63, 0x50, 0xac, 0x20, 0x25, 0x24, 0x91, 0xb4, 0xcf, 0x97, 0x4b, 0x45, 0xfc, 0x78, 0x46, 0xfc, 0xb2, 0xa8, - 0x63, 0xe3, 0x29, 0x09, 0xca, 0x47, 0x5b, 0x80, 0x3c, 0x55, 0x5c, 0xaa, 0x82, 0x78, 0xee, 0x67, 0x89, 0x09, 0xf0, - 0xeb, 0xd4, 0x52, 0xc3, 0x5a, 0xd3, 0x2c, 0xbd, 0x66, 0x90, 0x67, 0xb3, 0x32, 0xf0, 0x84, 0xc0, 0x1d, 0x63, 0x3d, - 0x33, 0xea, 0x6e, 0x74, 0xf0, 0x5e, 0xf3, 0x59, 0xb8, 0xd0, 0xb2, 0x9c, 0xa0, 0x17, 0xaa, 0xb9, 0x79, 0x33, 0x3d, - 0xad, 0x77, 0xfe, 0xdc, 0x9b, 0xea, 0x87, 0x67, 0x32, 0xa5, 0xc7, 0x9b, 0x94, 0x87, 0x78, 0xde, 0x92, 0xd7, 0x10, - 0x66, 0xb2, 0x35, 0xdf, 0x86, 0x2b, 0x3d, 0x25, 0x8f, 0x7b, 0xf7, 0xf2, 0x8c, 0xfa, 0x59, 0x10, 0xbd, 0xf5, 0x33, - 0x7f, 0x92, 0xf7, 0x2e, 0xf4, 0x85, 0x61, 0x9a, 0x02, 0x2e, 0x46, 0x22, 0xa9, 0x2a, 0x09, 0x6e, 0x6d, 0x1c, 0x22, - 0x5c, 0xbd, 0x97, 0x10, 0x48, 0x97, 0xba, 0x8d, 0x67, 0xe6, 0x2b, 0x58, 0x67, 0x1b, 0x4f, 0x10, 0x96, 0xb9, 0x4a, - 0x6f, 0xff, 0xc8, 0x2c, 0x25, 0x0c, 0x69, 0x35, 0xde, 0x85, 0x5b, 0x7d, 0x50, 0x4f, 0xe7, 0x2d, 0xbd, 0x5f, 0xc9, - 0x5b, 0xda, 0x80, 0x46, 0x2b, 0xa3, 0xf9, 0x34, 0x4d, 0x72, 0x6a, 0xe3, 0xf7, 0xd0, 0x4e, 0xde, 0xfa, 0x6c, 0x36, - 0x5c, 0xa3, 0xb9, 0xb2, 0xa9, 0x78, 0x23, 0xdb, 0x41, 0xfc, 0xe8, 0xfd, 0xf7, 0x65, 0xca, 0x80, 0x0e, 0x25, 0x89, - 0x9c, 0x77, 0x46, 0xb7, 0xa4, 0xe5, 0x26, 0xf4, 0x93, 0x69, 0xb9, 0xf1, 0xbd, 0xd2, 0x72, 0x13, 0xfa, 0x47, 0xa7, - 0xe5, 0x32, 0x6a, 0xa4, 0xe5, 0x82, 0x9c, 0xfb, 0xfa, 0x5e, 0xd9, 0x9d, 0x3a, 0xe9, 0x2e, 0x9d, 0xe7, 0xa4, 0xa3, - 0xc2, 0x2d, 0x71, 0x3a, 0x86, 0xd4, 0xce, 0x7f, 0x7c, 0xa6, 0x66, 0x9c, 0x8e, 0xcd, 0x3c, 0x4d, 0xf8, 0x06, 0x0a, - 0x90, 0x1d, 0xce, 0xc8, 0xc2, 0xfe, 0xe9, 0xa6, 0xf3, 0xe4, 0xbc, 0xd3, 0xdb, 0xef, 0x4c, 0x6c, 0xcf, 0x06, 0xa7, - 0xa3, 0x28, 0x68, 0xf7, 0xf6, 0xf7, 0xa1, 0x60, 0x6e, 0x14, 0x74, 0xa1, 0x80, 0x19, 0x05, 0x87, 0x50, 0x10, 0x18, - 0x05, 0x0f, 0xa1, 0x20, 0x34, 0x0a, 0x1e, 0x41, 0xc1, 0xb5, 0x5d, 0x9c, 0xb3, 0x32, 0xf7, 0xf8, 0x11, 0x12, 0x97, - 0x25, 0xee, 0x64, 0xf5, 0x83, 0xe2, 0x11, 0xd1, 0x55, 0x1e, 0x95, 0x97, 0x4c, 0x34, 0x0f, 0xf4, 0x9d, 0x88, 0x97, - 0x5f, 0x5c, 0x02, 0x6b, 0x85, 0x3b, 0x5f, 0x30, 0x84, 0x3f, 0x65, 0xcd, 0x7d, 0xfd, 0xda, 0xf6, 0xca, 0x04, 0xdd, - 0x36, 0xee, 0xea, 0x14, 0x5d, 0xcf, 0x46, 0x82, 0x2f, 0xc9, 0x17, 0x87, 0x8d, 0x50, 0x75, 0x0b, 0xd7, 0x0d, 0x56, - 0x77, 0x7d, 0xee, 0x23, 0x3c, 0xd1, 0x0a, 0x10, 0x75, 0xe0, 0x5b, 0x0f, 0xef, 0xd9, 0x84, 0xea, 0xfd, 0xa2, 0x07, - 0xb0, 0x44, 0x12, 0x73, 0x2f, 0xaa, 0x14, 0xa3, 0xb7, 0xf8, 0xa2, 0xba, 0x5e, 0xf6, 0x3d, 0x91, 0xd7, 0xf5, 0x65, - 0x58, 0x46, 0xd4, 0xa6, 0x98, 0xfb, 0x63, 0x0f, 0xb2, 0x35, 0x21, 0x39, 0xc5, 0xbb, 0x20, 0x84, 0xb4, 0x07, 0x33, - 0xef, 0x2d, 0x9e, 0x47, 0x34, 0xf1, 0x26, 0x45, 0xaf, 0x5c, 0x7f, 0x99, 0x3d, 0xfa, 0xbe, 0xbc, 0x93, 0x5c, 0xd0, - 0x44, 0xf5, 0x56, 0x42, 0xd9, 0x2c, 0x69, 0x67, 0x4b, 0x7a, 0xa1, 0xa1, 0xec, 0x8c, 0xe2, 0x74, 0xde, 0x04, 0x71, - 0xbf, 0x31, 0xe5, 0x10, 0xe6, 0x56, 0xa6, 0x1c, 0xbe, 0x04, 0x58, 0xcb, 0xa7, 0xf7, 0xfe, 0xb8, 0xfc, 0xfd, 0x8a, - 0xe6, 0xb9, 0x3f, 0x56, 0x35, 0xb7, 0xa7, 0x18, 0x0a, 0x10, 0xcd, 0xf4, 0x42, 0x0d, 0x04, 0xe4, 0x01, 0x02, 0x42, - 0x20, 0x76, 0xac, 0xd2, 0x02, 0x61, 0xe6, 0xf5, 0x8c, 0x42, 0x81, 0xaa, 0x7a, 0x11, 0xf7, 0xc7, 0x55, 0xc1, 0xf1, - 0x34, 0xa3, 0x2a, 0x57, 0x11, 0xb0, 0x58, 0x1c, 0xb7, 0xa0, 0x40, 0xbe, 0xde, 0x92, 0x39, 0xa8, 0xb9, 0xcb, 0xf6, - 0xfc, 0x41, 0x4b, 0x67, 0x0e, 0x9a, 0x87, 0x60, 0xca, 0x13, 0x30, 0xeb, 0xc9, 0x7f, 0x5f, 0x76, 0x02, 0xf8, 0x4f, - 0x9d, 0xf1, 0xf8, 0x72, 0x34, 0x1a, 0xdd, 0x99, 0x49, 0xf8, 0x65, 0x38, 0xa2, 0x5d, 0x7a, 0xd8, 0x83, 0x03, 0x12, - 0x4d, 0x95, 0xf3, 0xd6, 0x29, 0x04, 0xee, 0x16, 0xf7, 0xab, 0x0c, 0xe9, 0x71, 0x3c, 0x5a, 0xdc, 0x3f, 0xab, 0xb0, - 0x98, 0x66, 0x74, 0x31, 0xf1, 0xb3, 0x31, 0x4b, 0xbc, 0x76, 0xe1, 0x5e, 0x2f, 0x14, 0xa8, 0x47, 0x47, 0x47, 0x85, - 0x1b, 0xea, 0xa7, 0x76, 0x18, 0x16, 0x6e, 0xb0, 0x28, 0xa7, 0xd1, 0x6e, 0x8f, 0x46, 0x85, 0xcb, 0x74, 0xc1, 0x7e, - 0x37, 0x08, 0xf7, 0xbb, 0x85, 0x3b, 0x37, 0x6a, 0x14, 0x2e, 0x55, 0x4f, 0x19, 0x0d, 0x6b, 0xa7, 0x2c, 0x1e, 0xb5, - 0xdb, 0x85, 0x2b, 0x09, 0x6d, 0x01, 0x31, 0x39, 0xf9, 0xd3, 0xf3, 0x67, 0x1c, 0x0c, 0xa6, 0xa2, 0x17, 0x73, 0xe7, - 0xfc, 0x56, 0xdd, 0x60, 0x29, 0x3f, 0xf9, 0x58, 0xa0, 0x21, 0xfe, 0xda, 0x4c, 0xd2, 0x03, 0x62, 0x16, 0xc9, 0x79, - 0xb1, 0xce, 0xe1, 0xab, 0xbd, 0x06, 0xca, 0x12, 0xaf, 0xbf, 0x26, 0x71, 0x95, 0xbb, 0x07, 0x7c, 0x0c, 0x6a, 0xca, - 0x8b, 0xd6, 0xf3, 0x6d, 0xd2, 0x23, 0xfb, 0xb4, 0xf4, 0xb8, 0xba, 0x8f, 0xf0, 0xc8, 0xfe, 0x70, 0xe1, 0x91, 0x9b, - 0xc2, 0x43, 0xb2, 0x8e, 0x39, 0x27, 0x76, 0x10, 0xd1, 0xe0, 0xe3, 0x55, 0x7a, 0xd3, 0x84, 0x2d, 0x91, 0xd9, 0x42, - 0xac, 0x5c, 0xff, 0xd6, 0x43, 0x03, 0xba, 0x33, 0xe3, 0x7b, 0x91, 0x42, 0xc7, 0x7f, 0x93, 0x10, 0xfb, 0x8d, 0x0e, - 0xec, 0xc9, 0x92, 0xd1, 0x88, 0xd8, 0x6f, 0x46, 0x23, 0x5b, 0xdf, 0xc3, 0xe3, 0x73, 0x2a, 0x6a, 0xbd, 0xae, 0x95, - 0x88, 0x5a, 0x60, 0xe8, 0x57, 0x65, 0x66, 0x81, 0x4a, 0xf1, 0x33, 0xd3, 0xf9, 0xd4, 0x9b, 0x90, 0xe5, 0xb0, 0xd5, - 0xe0, 0x33, 0x96, 0xf5, 0xef, 0x00, 0xe4, 0xb5, 0x8f, 0x36, 0x95, 0x00, 0x6f, 0xf8, 0xd2, 0xd4, 0xea, 0x25, 0x74, - 0x63, 0xaa, 0x55, 0xfc, 0x27, 0xb7, 0x2f, 0x42, 0x67, 0xce, 0x51, 0xc1, 0xf2, 0x37, 0xc9, 0xca, 0x05, 0x13, 0x12, - 0x46, 0x42, 0xcc, 0x69, 0x15, 0x3c, 0x1d, 0x8f, 0x63, 0x71, 0x6e, 0xa5, 0x66, 0x70, 0xcb, 0xe6, 0x83, 0xda, 0x7c, - 0x3d, 0xb3, 0xa1, 0xfa, 0x92, 0x87, 0xf8, 0xb4, 0xb1, 0x3c, 0x98, 0x7c, 0xad, 0xbe, 0x71, 0x2b, 0x62, 0x82, 0x0b, - 0xc5, 0xe3, 0x17, 0xf2, 0x38, 0x2b, 0xc7, 0x2c, 0x94, 0xcd, 0x59, 0x58, 0x14, 0xea, 0x22, 0x80, 0x90, 0xe5, 0x53, - 0xd0, 0x9e, 0x64, 0x4b, 0xfa, 0x29, 0x16, 0x9e, 0xcf, 0x8d, 0x3c, 0xba, 0xda, 0x72, 0x15, 0xda, 0x4e, 0x93, 0x89, - 0x49, 0x73, 0x5e, 0xd8, 0xca, 0x64, 0xd3, 0x48, 0xb4, 0x2d, 0x89, 0x4f, 0x99, 0xe1, 0x67, 0xcc, 0x10, 0x92, 0x8c, - 0xca, 0x05, 0xd1, 0xaf, 0x74, 0x41, 0x61, 0x5a, 0x59, 0xe2, 0x8d, 0xc4, 0x96, 0xc8, 0x4a, 0xcb, 0xa7, 0x7e, 0xa2, - 0x8d, 0x39, 0xc9, 0x0f, 0x76, 0x17, 0xd5, 0xca, 0x17, 0xb6, 0x06, 0x5b, 0x12, 0x6f, 0xff, 0xb8, 0x05, 0x0d, 0xfa, - 0x56, 0x0d, 0xf4, 0x64, 0x2d, 0x99, 0xed, 0xee, 0x14, 0xef, 0x8f, 0x97, 0x6e, 0x3e, 0xc7, 0x6e, 0x3e, 0xb7, 0xbe, - 0x5a, 0x34, 0xe7, 0xf4, 0xea, 0x23, 0xe3, 0x4d, 0xee, 0x4f, 0x9b, 0xe0, 0x3d, 0x15, 0x49, 0x28, 0x8a, 0x3d, 0x0b, - 0x1d, 0x5d, 0x9a, 0x7e, 0xbd, 0x59, 0x0e, 0x99, 0xe0, 0xc2, 0x8c, 0xf2, 0x92, 0x34, 0xa1, 0xbd, 0xfa, 0x49, 0x41, - 0x33, 0x99, 0x59, 0x63, 0x6b, 0xb8, 0x48, 0x21, 0x73, 0x9c, 0xdf, 0x7a, 0x6d, 0xc5, 0xd6, 0xdb, 0x3a, 0x53, 0xb9, - 0xbd, 0xb1, 0xbe, 0xa7, 0x90, 0xdb, 0x10, 0xd2, 0x2b, 0x5b, 0x4f, 0xb5, 0xde, 0x96, 0x4a, 0xfe, 0xa9, 0x73, 0x73, - 0x90, 0xba, 0xa2, 0xff, 0x37, 0x0e, 0x1c, 0xae, 0x16, 0x8b, 0x73, 0x73, 0xf7, 0x81, 0xcc, 0xf3, 0x47, 0x9c, 0x66, - 0xf8, 0x3e, 0x35, 0xaf, 0xc4, 0x15, 0x17, 0x0b, 0x10, 0x33, 0x5e, 0xe7, 0xa8, 0x9e, 0xf5, 0x7d, 0x77, 0xf7, 0x77, - 0x4f, 0xbf, 0x50, 0x38, 0xd2, 0x57, 0xbe, 0xda, 0x76, 0x0f, 0x36, 0x42, 0xec, 0xdf, 0x7a, 0x2c, 0x11, 0x32, 0xef, - 0x0a, 0x92, 0x42, 0x7a, 0xd3, 0x54, 0x1d, 0x00, 0xcd, 0x68, 0x2c, 0xbe, 0xf2, 0xae, 0x96, 0x62, 0xff, 0xe1, 0xf4, - 0x46, 0xaf, 0x46, 0x67, 0xe5, 0x60, 0xe7, 0x1f, 0x7a, 0x7e, 0x73, 0xfb, 0x81, 0xd1, 0xfa, 0x19, 0xc4, 0xc3, 0xe9, - 0x4d, 0x4f, 0x0a, 0xda, 0x66, 0x26, 0xa1, 0x6a, 0x4f, 0x6f, 0xcc, 0x13, 0xac, 0x55, 0x47, 0x96, 0xbb, 0x9f, 0x5b, - 0xd4, 0xcf, 0x69, 0x0f, 0x3e, 0x6a, 0xc5, 0x02, 0x3f, 0x56, 0xc2, 0x7c, 0xc2, 0xc2, 0x30, 0xa6, 0x3d, 0x2d, 0xaf, - 0xad, 0xce, 0x43, 0x38, 0x00, 0x6a, 0x2e, 0x59, 0x7d, 0x55, 0x0c, 0xe4, 0x95, 0x78, 0xf2, 0xaf, 0xf2, 0x34, 0x86, - 0x4f, 0x4a, 0x6e, 0x44, 0xa7, 0x3a, 0x19, 0xd9, 0xae, 0x90, 0x27, 0x7e, 0xd7, 0xe7, 0x72, 0xd8, 0xfe, 0x53, 0x4f, - 0x2c, 0x78, 0xbb, 0xc7, 0xd3, 0xa9, 0xd7, 0xdc, 0xaf, 0x4f, 0x04, 0x5e, 0x95, 0x53, 0xc0, 0x1b, 0xa6, 0x85, 0x41, - 0x5a, 0x49, 0x3e, 0x6d, 0xb9, 0x1d, 0x55, 0x26, 0x3a, 0x00, 0x23, 0xb4, 0x2c, 0x2a, 0xea, 0x93, 0xf9, 0xc7, 0xec, - 0x96, 0xc7, 0x9b, 0x77, 0xcb, 0x63, 0xbd, 0x5b, 0xee, 0xa6, 0xd8, 0x2f, 0x47, 0x1d, 0xf8, 0xaf, 0x57, 0x4d, 0xc8, - 0x6b, 0x5b, 0xfb, 0xd3, 0x1b, 0x0b, 0xf4, 0xb4, 0x66, 0x77, 0x7a, 0x23, 0xcf, 0xef, 0x42, 0x8e, 0x5c, 0x1b, 0x4e, - 0xb4, 0xe2, 0xb6, 0x05, 0x85, 0xf0, 0x7f, 0xbb, 0xf6, 0xaa, 0x73, 0x00, 0xef, 0xa0, 0xd5, 0xe1, 0xfa, 0xbb, 0xee, - 0xdd, 0x9b, 0xd6, 0x4b, 0x52, 0xee, 0x78, 0x9a, 0x1b, 0x23, 0x97, 0xfb, 0x57, 0x57, 0x34, 0xf4, 0x46, 0x69, 0x30, - 0xcb, 0xff, 0x49, 0xc1, 0xaf, 0x90, 0x78, 0xe7, 0x96, 0x5e, 0xe9, 0x47, 0x37, 0x95, 0xa7, 0x89, 0x75, 0x0f, 0x8b, - 0x72, 0x9d, 0xbc, 0x3c, 0xf0, 0x63, 0xea, 0x74, 0xdd, 0x83, 0x0d, 0x9b, 0xe0, 0xdf, 0x64, 0x6d, 0x36, 0x4e, 0xe6, - 0xf7, 0x22, 0xe3, 0x4e, 0x24, 0x7c, 0x16, 0x0e, 0xcc, 0x35, 0x6c, 0x1f, 0x6d, 0x06, 0xf7, 0x5c, 0x8f, 0x34, 0xd4, - 0x42, 0x41, 0xc9, 0x9d, 0x90, 0x8e, 0xfc, 0x59, 0xcc, 0xef, 0xee, 0x75, 0x1b, 0x65, 0xac, 0xf5, 0x7a, 0x07, 0x43, - 0xaf, 0xea, 0xde, 0x93, 0x4b, 0x7f, 0xf9, 0xf8, 0x00, 0xfe, 0x93, 0xe7, 0x6c, 0xae, 0x2a, 0x5d, 0x5d, 0x5a, 0xbd, - 0xa0, 0xab, 0x5f, 0xd7, 0x94, 0x71, 0x29, 0xc2, 0x85, 0x3e, 0x7e, 0xdf, 0xda, 0xa0, 0x55, 0xde, 0xab, 0xba, 0xd2, - 0xb2, 0x3e, 0xab, 0xf6, 0xe7, 0x75, 0x7e, 0xcf, 0xba, 0x81, 0xd4, 0x5c, 0xeb, 0x75, 0xd5, 0x57, 0xee, 0xd7, 0x2a, - 0x6b, 0x8c, 0x8b, 0xfa, 0xd7, 0xe4, 0xaa, 0x34, 0x51, 0x64, 0xd6, 0x2b, 0x58, 0x29, 0xd7, 0xd2, 0x4a, 0x49, 0x29, - 0xb9, 0x3c, 0x1e, 0xdc, 0x4c, 0x62, 0xeb, 0x5a, 0x5e, 0xc5, 0x43, 0xec, 0x8e, 0xdb, 0xb6, 0x2d, 0xe1, 0xa4, 0x83, - 0x2f, 0x82, 0xd9, 0x1f, 0xde, 0x7f, 0xdd, 0x3c, 0xb2, 0x07, 0xa0, 0x69, 0x5d, 0x8f, 0x85, 0x66, 0xf7, 0xd2, 0xbf, - 0xa5, 0xd9, 0x45, 0x57, 0xb9, 0xe0, 0x65, 0x6a, 0xba, 0x28, 0xb3, 0xba, 0xb6, 0x75, 0x33, 0x89, 0x93, 0x9c, 0xd8, - 0x11, 0xe7, 0x53, 0xaf, 0xd5, 0x9a, 0xcf, 0xe7, 0xee, 0x7c, 0xdf, 0x4d, 0xb3, 0x71, 0xab, 0xdb, 0x6e, 0xb7, 0xe1, - 0xe3, 0x22, 0xb6, 0x75, 0xcd, 0xe8, 0xfc, 0x49, 0x7a, 0x43, 0xec, 0xb6, 0xd5, 0xb6, 0x3a, 0xdd, 0x23, 0xab, 0xd3, - 0x3d, 0x70, 0x1f, 0x1e, 0xd9, 0xfd, 0x2f, 0x2c, 0xeb, 0x38, 0xa4, 0xa3, 0x1c, 0x7e, 0x58, 0xd6, 0xb1, 0x50, 0xbc, - 0xe4, 0x6f, 0xcb, 0x72, 0x83, 0x38, 0x6f, 0x76, 0xac, 0x85, 0x7a, 0xb4, 0x2c, 0xb8, 0xb0, 0xc8, 0xb3, 0xbe, 0x1c, - 0x75, 0x47, 0x07, 0xa3, 0xc7, 0x3d, 0x55, 0x5c, 0x7c, 0x51, 0xab, 0x8e, 0xe5, 0xbf, 0x5d, 0xa3, 0x59, 0xce, 0xb3, - 0xf4, 0x23, 0x55, 0xae, 0x7d, 0x0b, 0x44, 0xcf, 0xc6, 0xa6, 0xdd, 0xf5, 0x91, 0x3a, 0x47, 0x57, 0xc1, 0xa8, 0x5b, - 0x55, 0x17, 0x30, 0xb6, 0x4a, 0x20, 0x8f, 0x5b, 0x1a, 0xf4, 0x63, 0x13, 0x4d, 0x9d, 0xe6, 0x26, 0x44, 0x75, 0x6c, - 0x35, 0xc7, 0xb1, 0x9e, 0xdf, 0x31, 0x9c, 0x8f, 0xd7, 0xba, 0xaa, 0x80, 0xc0, 0xb6, 0x42, 0x62, 0xbf, 0xea, 0x74, - 0x8f, 0x70, 0xa7, 0xf3, 0xd0, 0x7d, 0x78, 0x14, 0xb4, 0xf1, 0x81, 0x7b, 0xd0, 0xdc, 0x77, 0x1f, 0xe2, 0xa3, 0xe6, - 0x11, 0x3e, 0x7a, 0x7e, 0x14, 0x34, 0x0f, 0xdc, 0x03, 0xdc, 0x6e, 0x1e, 0x41, 0x61, 0xf3, 0xa8, 0x79, 0x74, 0xdd, - 0x3c, 0x38, 0x0a, 0xda, 0xa2, 0xb4, 0xeb, 0x1e, 0x1e, 0x36, 0x3b, 0x6d, 0xf7, 0xf0, 0x10, 0x1f, 0xba, 0x0f, 0x1f, - 0x36, 0x3b, 0xfb, 0xee, 0xc3, 0x87, 0x2f, 0x0f, 0x8f, 0xdc, 0x7d, 0x78, 0xb7, 0xbf, 0x1f, 0xec, 0xbb, 0x9d, 0x4e, - 0x13, 0xfe, 0xe0, 0x23, 0xb7, 0x2b, 0x7f, 0x74, 0x3a, 0xee, 0x7e, 0x07, 0xb7, 0xe3, 0xc3, 0xae, 0xfb, 0xf0, 0x31, - 0x16, 0x7f, 0x45, 0x35, 0x2c, 0xfe, 0x40, 0x37, 0xf8, 0xb1, 0xdb, 0x7d, 0x28, 0x7f, 0x89, 0x0e, 0xaf, 0x0f, 0x8e, - 0x7e, 0xb4, 0x5b, 0x5b, 0xe7, 0xd0, 0x91, 0x73, 0x38, 0x3a, 0x74, 0xf7, 0xf7, 0xf1, 0x41, 0xc7, 0x3d, 0xda, 0x8f, - 0x9a, 0x07, 0x5d, 0xf7, 0xe1, 0xa3, 0xa0, 0xd9, 0x71, 0x1f, 0x3d, 0xc2, 0xed, 0xe6, 0xbe, 0xdb, 0xc5, 0x1d, 0xf7, - 0x60, 0x5f, 0xfc, 0xd8, 0x77, 0xbb, 0xd7, 0x8f, 0x1e, 0xbb, 0x0f, 0x0f, 0xa3, 0x87, 0xee, 0xc1, 0xb7, 0x07, 0x47, - 0x6e, 0x77, 0x3f, 0xda, 0x7f, 0xe8, 0x76, 0x1f, 0x5d, 0x3f, 0x74, 0x0f, 0xa2, 0x66, 0xf7, 0xe1, 0x9d, 0x2d, 0x3b, - 0x5d, 0x17, 0x70, 0x24, 0x5e, 0xc3, 0x0b, 0xac, 0x5e, 0xc0, 0xff, 0x91, 0x68, 0xfb, 0x6f, 0xd8, 0x4d, 0xbe, 0xde, - 0xf4, 0xb1, 0x7b, 0xf4, 0x28, 0x90, 0xd5, 0xa1, 0xa0, 0xa9, 0x6b, 0x40, 0x93, 0xeb, 0xa6, 0x1c, 0x56, 0x74, 0xd7, - 0xd4, 0x1d, 0xe9, 0xff, 0xd5, 0x60, 0xd7, 0x4d, 0x18, 0x58, 0x8e, 0xfb, 0xef, 0xda, 0x4f, 0xb9, 0xe4, 0xc7, 0xad, - 0xb1, 0x24, 0xfd, 0x71, 0xff, 0x0b, 0xf9, 0xe5, 0xa0, 0x2f, 0x2e, 0xb1, 0xbf, 0xcd, 0xf1, 0x11, 0x7f, 0xda, 0xf1, - 0x11, 0xd1, 0xfb, 0x78, 0x3e, 0xe2, 0x3f, 0xdc, 0xf3, 0xe1, 0xaf, 0xba, 0xcd, 0x6f, 0xf8, 0x9a, 0x83, 0x63, 0xd5, - 0x2a, 0x7e, 0xc1, 0x9d, 0xf3, 0x14, 0xbe, 0x52, 0x5d, 0xf4, 0x6e, 0x38, 0x89, 0xa8, 0xe9, 0x07, 0x4a, 0x81, 0xc5, - 0xde, 0x70, 0xc9, 0x63, 0x83, 0x6d, 0x08, 0x09, 0x3f, 0x8d, 0x90, 0xef, 0xee, 0x83, 0x8f, 0xf0, 0x0f, 0xc7, 0x47, - 0x60, 0xe2, 0xa3, 0xe6, 0xc9, 0x17, 0x9e, 0x06, 0xe1, 0x29, 0x38, 0x13, 0xcf, 0x0e, 0x5c, 0xd0, 0xd1, 0xb0, 0x5b, - 0xf4, 0x5a, 0x44, 0xee, 0x64, 0x70, 0xfd, 0xf9, 0xe7, 0x04, 0x1d, 0xe4, 0x6d, 0x3c, 0x44, 0x1f, 0x8b, 0x98, 0x0a, - 0xa9, 0xa3, 0x1e, 0x4a, 0xa1, 0xd4, 0x75, 0xdb, 0x6e, 0xbb, 0x74, 0xe9, 0xc0, 0x0d, 0x4c, 0x64, 0x91, 0x72, 0xdf, - 0xdb, 0xe9, 0xe0, 0x38, 0x1d, 0xc3, 0xbd, 0x4c, 0xe2, 0x4b, 0x75, 0x70, 0xe2, 0x21, 0x90, 0x1f, 0x09, 0x84, 0xf4, - 0x09, 0xe5, 0xe8, 0xf1, 0xb3, 0x8f, 0x7f, 0x83, 0x20, 0xa6, 0x8e, 0x49, 0x4c, 0xc0, 0xdb, 0xf1, 0x8a, 0x86, 0xcc, - 0x77, 0x6c, 0x67, 0x9a, 0xd1, 0x11, 0xcd, 0xf2, 0x66, 0xed, 0x6a, 0x20, 0x71, 0x2b, 0x10, 0xb2, 0x15, 0x84, 0xa3, - 0x0c, 0xbe, 0xbc, 0x44, 0xce, 0x95, 0xbf, 0xd1, 0x56, 0x06, 0x98, 0x5d, 0x60, 0x5d, 0x92, 0x81, 0xac, 0xad, 0x94, - 0x36, 0x5b, 0x6a, 0x6d, 0x1d, 0xb7, 0x7b, 0x88, 0x2c, 0x51, 0x0c, 0xdf, 0xb4, 0xf9, 0xc1, 0x69, 0xee, 0xb7, 0xff, - 0x84, 0x8c, 0x66, 0x65, 0x47, 0x43, 0xe5, 0x6e, 0xcb, 0xcb, 0x2f, 0x1f, 0xae, 0x84, 0x5d, 0x6d, 0x49, 0x11, 0x5f, - 0xca, 0xb9, 0xdb, 0xa8, 0x97, 0xab, 0xa4, 0x39, 0x79, 0xfb, 0xe0, 0x88, 0x8d, 0x1d, 0xe3, 0x66, 0x8b, 0x5c, 0x7e, - 0x33, 0x07, 0x2e, 0xc6, 0x47, 0xa8, 0xa8, 0xaa, 0xe4, 0x68, 0x21, 0xa2, 0x2d, 0x2c, 0xb1, 0xf2, 0xe5, 0xd2, 0x11, - 0x2e, 0x72, 0x62, 0xe0, 0x14, 0x9e, 0x51, 0x0d, 0xc9, 0x39, 0x2e, 0x01, 0x12, 0x08, 0x26, 0xb9, 0xfc, 0xb7, 0x2a, - 0xd6, 0x3f, 0x94, 0xe3, 0xcb, 0x8d, 0xfd, 0x64, 0x0c, 0x54, 0xe8, 0x27, 0xe3, 0x35, 0xb7, 0x9a, 0x0c, 0x18, 0xad, - 0x94, 0x56, 0x5d, 0x55, 0xee, 0xb3, 0xfc, 0xc9, 0xed, 0x7b, 0x75, 0xb9, 0xb6, 0x0d, 0xde, 0x69, 0x11, 0xdf, 0xa8, - 0x3e, 0x04, 0xd4, 0x20, 0x0f, 0x8e, 0x27, 0x94, 0xfb, 0xf2, 0x5c, 0x1c, 0xe8, 0x13, 0x90, 0xcb, 0x62, 0x29, 0x6b, - 0x54, 0x05, 0xf5, 0x89, 0xbc, 0x37, 0x40, 0x8a, 0x7a, 0x6c, 0xa9, 0x5b, 0xe9, 0x9a, 0x62, 0x69, 0x48, 0x07, 0x4b, - 0x7f, 0x4c, 0xe0, 0x8b, 0x93, 0xcf, 0x24, 0x49, 0xed, 0xfe, 0x83, 0x32, 0xd7, 0x65, 0xdb, 0x22, 0xc4, 0x2c, 0xf9, - 0x78, 0x9e, 0xd1, 0xf8, 0x9f, 0xc8, 0x03, 0x16, 0xa4, 0xc9, 0x83, 0xa1, 0x8d, 0x7a, 0xdc, 0x8d, 0x32, 0x3a, 0x22, - 0x0f, 0x40, 0xc6, 0x7b, 0xc2, 0xfa, 0x00, 0x46, 0xd8, 0xb8, 0x99, 0xc4, 0x58, 0x68, 0x4c, 0xf7, 0x50, 0x88, 0x24, - 0xb8, 0x76, 0xf7, 0xd0, 0xb6, 0xa4, 0x4d, 0x2c, 0x7e, 0xf7, 0xa5, 0x38, 0x15, 0x4a, 0x80, 0xd5, 0xe9, 0xba, 0x87, - 0x51, 0xd7, 0x7d, 0x7c, 0xfd, 0xc8, 0x3d, 0x8a, 0x3a, 0x8f, 0xae, 0x9b, 0xf0, 0x6f, 0xd7, 0x7d, 0x1c, 0x37, 0xbb, - 0xee, 0x63, 0xf8, 0xff, 0xdb, 0x03, 0xf7, 0x30, 0x6a, 0x76, 0xdc, 0xa3, 0xeb, 0x7d, 0x77, 0xff, 0x65, 0xa7, 0xeb, - 0xee, 0x5b, 0x1d, 0x4b, 0xb6, 0x03, 0x76, 0x2d, 0xb9, 0xf3, 0x83, 0x95, 0x0d, 0xb1, 0x21, 0x18, 0x27, 0xcf, 0xf6, - 0xd9, 0x58, 0x1c, 0xc7, 0x36, 0xf7, 0xa7, 0x72, 0xd6, 0x3d, 0xf5, 0x33, 0xf8, 0x88, 0x6a, 0x7d, 0xef, 0xd6, 0xde, - 0xe1, 0x1a, 0xbf, 0xd8, 0x30, 0xc4, 0x54, 0x44, 0xc0, 0xcd, 0x6b, 0xdd, 0xa8, 0xb8, 0x2e, 0x4f, 0x7e, 0x76, 0x4a, - 0x45, 0xc1, 0xca, 0xec, 0x22, 0x83, 0xac, 0x65, 0x0d, 0x48, 0x00, 0x12, 0x34, 0xb8, 0x9a, 0x3f, 0x5a, 0xd1, 0x79, - 0x06, 0x57, 0x21, 0x68, 0x5e, 0xc2, 0xc4, 0xc7, 0xff, 0x04, 0x0c, 0x2f, 0xc2, 0x62, 0x15, 0x3c, 0x38, 0x81, 0x98, - 0xa5, 0xc6, 0xc5, 0x77, 0xb4, 0xca, 0x01, 0x08, 0x19, 0x5c, 0x55, 0x58, 0x14, 0x7a, 0x66, 0x35, 0x2f, 0x6e, 0x85, - 0x44, 0xc1, 0x4e, 0x68, 0x3e, 0xb0, 0xa1, 0xc8, 0xf6, 0x6c, 0xe1, 0x01, 0xb4, 0xcb, 0xef, 0xcc, 0x96, 0x74, 0x5f, - 0x15, 0x60, 0x71, 0x0f, 0x05, 0x6c, 0x6a, 0x40, 0x9f, 0x8d, 0xf6, 0xf6, 0xb6, 0x6e, 0x27, 0xa1, 0x5f, 0xc2, 0xd4, - 0xaa, 0xcf, 0x53, 0x9a, 0x9c, 0xca, 0x36, 0xd7, 0xa1, 0xec, 0x57, 0x60, 0x18, 0x29, 0xb4, 0x5c, 0x51, 0x9f, 0xbb, - 0x7e, 0x22, 0x0f, 0x18, 0x18, 0xfc, 0x0c, 0x77, 0xe8, 0x3e, 0x2a, 0x52, 0xee, 0xcb, 0x9c, 0x31, 0x93, 0x0d, 0xa4, - 0xdc, 0xd7, 0xd7, 0x38, 0xf9, 0xbc, 0x76, 0x84, 0x3f, 0xea, 0xf6, 0xdf, 0xbc, 0x3f, 0xb1, 0xe4, 0xee, 0x3d, 0x6e, - 0x45, 0xdd, 0xfe, 0xb1, 0x70, 0xa9, 0xc8, 0xac, 0x00, 0x22, 0xb3, 0x02, 0x2c, 0x75, 0x7f, 0x0d, 0x04, 0xda, 0x8a, - 0x96, 0x9c, 0xb6, 0x30, 0x29, 0xa4, 0x33, 0x78, 0x32, 0x8b, 0x39, 0x83, 0xcf, 0x2b, 0xb5, 0x44, 0x4a, 0x80, 0x48, - 0x31, 0xd0, 0xc7, 0x61, 0x95, 0xf2, 0x78, 0xc5, 0x13, 0xed, 0x3a, 0x1e, 0xb1, 0x98, 0xea, 0x03, 0xb0, 0xaa, 0xab, - 0x32, 0x1f, 0x68, 0xbd, 0x76, 0x3e, 0xbb, 0x82, 0x9c, 0x08, 0x9d, 0x7d, 0xf4, 0x41, 0x35, 0x38, 0x16, 0x43, 0x41, - 0x60, 0x5f, 0x4a, 0x71, 0xfd, 0x21, 0xd9, 0xfa, 0x92, 0xaa, 0xd9, 0x2b, 0x01, 0x02, 0x97, 0x86, 0x44, 0xfb, 0xfd, - 0xd2, 0x9b, 0x6c, 0xbe, 0x2b, 0x8e, 0x5b, 0xd1, 0x7e, 0xff, 0xd2, 0x1b, 0xab, 0xfe, 0x5e, 0xa6, 0xe3, 0xcd, 0x7d, - 0xc5, 0xe9, 0x78, 0x20, 0x4e, 0xe4, 0xcb, 0xdb, 0xa5, 0xb4, 0x6e, 0x9c, 0xc6, 0x76, 0xff, 0x58, 0xe9, 0x0a, 0x96, - 0x88, 0xba, 0xdb, 0x87, 0x6d, 0x7d, 0xc8, 0x3f, 0x4e, 0xc7, 0xb0, 0x5f, 0x65, 0x13, 0x63, 0x90, 0x9a, 0x43, 0x3e, - 0xea, 0xf4, 0x8f, 0x7d, 0x4b, 0xb0, 0x1e, 0xc1, 0x5b, 0x72, 0xaf, 0x05, 0x8d, 0xa3, 0x74, 0x42, 0x5d, 0x96, 0xb6, - 0xe6, 0xf4, 0xaa, 0xe9, 0x4f, 0x59, 0xe5, 0xfd, 0x06, 0x9d, 0xa4, 0x1c, 0x32, 0x5d, 0xc9, 0xc0, 0xea, 0x56, 0xde, - 0xb8, 0x03, 0x30, 0x89, 0xb4, 0xe7, 0x4e, 0xb8, 0xec, 0x0c, 0xb0, 0xd2, 0xfe, 0x71, 0xcb, 0x5f, 0xc1, 0x88, 0xd8, - 0x8a, 0x85, 0xf2, 0xc3, 0x83, 0xdd, 0x73, 0x25, 0xd2, 0xbf, 0xa4, 0xb4, 0xd0, 0xfe, 0x7a, 0x25, 0xc7, 0x0b, 0xbb, - 0xff, 0xaf, 0xff, 0xe3, 0x7f, 0x29, 0x17, 0xfc, 0x71, 0x2b, 0xea, 0xe8, 0xbe, 0x56, 0x56, 0xa5, 0x38, 0x86, 0x2b, - 0x73, 0xaa, 0x98, 0x31, 0xbd, 0x69, 0x8e, 0x33, 0x16, 0x36, 0x23, 0x3f, 0x1e, 0xd9, 0xfd, 0xed, 0xd8, 0x94, 0xe9, - 0x89, 0x4d, 0x1d, 0x6d, 0x5d, 0x2f, 0x02, 0x7a, 0xfd, 0x4d, 0xf7, 0x3f, 0xe8, 0x8c, 0x2f, 0xb1, 0xb5, 0xcd, 0xdb, - 0x20, 0xaa, 0xdd, 0x57, 0xbb, 0x11, 0x22, 0x57, 0x5f, 0xa7, 0x56, 0x0c, 0x32, 0xaf, 0x5d, 0x04, 0x51, 0xd8, 0x56, - 0x19, 0xf3, 0xfa, 0xbf, 0xff, 0xf3, 0xbf, 0xfc, 0x37, 0xfd, 0x08, 0xa1, 0xac, 0x7f, 0xfd, 0xef, 0xff, 0xf9, 0xff, - 0xfc, 0xef, 0xff, 0x0a, 0xe9, 0x69, 0x2a, 0xdc, 0x25, 0x98, 0x8a, 0x55, 0xc5, 0xba, 0x24, 0x77, 0xb1, 0xe0, 0xd0, - 0xdb, 0x84, 0xe5, 0x9c, 0x05, 0xf5, 0xab, 0x21, 0xce, 0xc4, 0x80, 0x62, 0x67, 0x2a, 0xe8, 0xc4, 0x0e, 0x2f, 0x2a, - 0x82, 0xaa, 0xa1, 0x5c, 0x10, 0x6e, 0x71, 0xdc, 0x02, 0x7c, 0xdf, 0xef, 0x66, 0x1b, 0xb7, 0x5c, 0x8e, 0x85, 0x26, - 0x13, 0x28, 0x29, 0xaa, 0x72, 0x0b, 0x42, 0x2f, 0x0b, 0x78, 0xf4, 0xba, 0x46, 0xb1, 0x58, 0xbd, 0x5a, 0x9b, 0xde, - 0xcf, 0xb3, 0x9c, 0xb3, 0x11, 0xa0, 0x5c, 0xba, 0x91, 0x45, 0x94, 0xbb, 0x09, 0xaa, 0x64, 0x7c, 0x5b, 0x88, 0x5e, - 0x24, 0x81, 0x1e, 0x1c, 0xfd, 0xa9, 0xf8, 0xf3, 0x04, 0x14, 0x36, 0xcb, 0x99, 0xf8, 0x37, 0xca, 0x7a, 0x7f, 0xd8, - 0x6e, 0x4f, 0x6f, 0xd0, 0xa2, 0x1a, 0x01, 0x6f, 0x1b, 0x4c, 0xd0, 0xb1, 0xd9, 0xa1, 0x08, 0x8f, 0x97, 0x5e, 0xee, - 0xb6, 0x05, 0xae, 0x72, 0xab, 0x5d, 0x14, 0x5f, 0x2d, 0x84, 0xa3, 0x95, 0xfd, 0x0a, 0x61, 0x6c, 0xe5, 0x93, 0xbe, - 0x4a, 0xcd, 0xc9, 0x2d, 0x8c, 0x56, 0x5d, 0xd9, 0x2a, 0xea, 0xac, 0x5f, 0x12, 0x63, 0x86, 0xe1, 0xcd, 0x00, 0xfa, - 0x01, 0x84, 0xc4, 0xa3, 0x0e, 0x8e, 0xba, 0x8b, 0xb2, 0x7b, 0xce, 0xd3, 0x89, 0x19, 0x77, 0xa7, 0x3e, 0x0d, 0xe8, - 0x48, 0xfb, 0xf2, 0xd5, 0x7b, 0x19, 0x53, 0x2f, 0xa2, 0xfd, 0x0d, 0x63, 0x29, 0x90, 0x44, 0xbc, 0xdd, 0x6a, 0x17, - 0x5f, 0xc2, 0x0e, 0x5c, 0x8c, 0xe2, 0xd4, 0xe7, 0x9e, 0x20, 0xd8, 0x9e, 0x19, 0xbd, 0xf7, 0x81, 0x27, 0xa5, 0x0b, - 0x03, 0x9e, 0x9e, 0xac, 0x0a, 0x5e, 0xf5, 0xfa, 0x65, 0x91, 0x85, 0x2b, 0x9a, 0x9b, 0x5d, 0x49, 0xa7, 0xdc, 0x77, - 0x2a, 0x28, 0xfe, 0xbc, 0xe6, 0xcd, 0x52, 0x02, 0xa9, 0x8b, 0x36, 0xbf, 0x97, 0x62, 0x5f, 0xbe, 0xfd, 0x9e, 0x3b, - 0xb6, 0x00, 0xd3, 0x5e, 0xad, 0x25, 0x0a, 0xa1, 0xd6, 0x73, 0xf2, 0x5d, 0x69, 0x51, 0xf9, 0xd3, 0xa9, 0xa8, 0x88, - 0x7a, 0xc7, 0x2d, 0xa9, 0x08, 0x03, 0xf7, 0x10, 0x19, 0x1f, 0x32, 0xc1, 0x42, 0x55, 0x52, 0x5b, 0x41, 0xfe, 0x52, - 0xa9, 0x17, 0xf0, 0xd5, 0xf2, 0xfe, 0xff, 0x03, 0x0c, 0xbd, 0x72, 0x0a, 0x4e, 0x98, 0x00, 0x00}; + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xed, 0x7d, 0xcb, 0x76, 0xdb, 0x48, 0x96, 0xe0, 0x7a, + 0xea, 0x2b, 0x20, 0xa6, 0x4a, 0x85, 0x28, 0x05, 0x21, 0x92, 0x92, 0x6c, 0x25, 0xa8, 0x20, 0x4a, 0x96, 0x9d, 0x6d, + 0x57, 0xd9, 0xb2, 0xcb, 0x92, 0xb3, 0x1e, 0x4a, 0x95, 0x00, 0x01, 0x41, 0x32, 0x6c, 0x10, 0x60, 0x06, 0x82, 0x7a, + 0x24, 0x89, 0x3e, 0xb3, 0x9a, 0x55, 0x9f, 0xd3, 0xf3, 0xe8, 0x45, 0x2f, 0xa6, 0x4f, 0xf7, 0x62, 0x3e, 0xa2, 0xd7, + 0xfd, 0x29, 0xf5, 0x03, 0xd3, 0x9f, 0x30, 0xe7, 0xc6, 0x03, 0x08, 0x90, 0x94, 0x2c, 0x67, 0x56, 0xcd, 0xf4, 0x62, + 0x2a, 0x4f, 0xc9, 0x44, 0x20, 0x1e, 0x37, 0x6e, 0xdc, 0x57, 0xdc, 0x7b, 0x23, 0x70, 0xb8, 0x91, 0xe4, 0xb1, 0xb8, + 0x9b, 0x52, 0x67, 0x2c, 0x26, 0xe9, 0xe0, 0x50, 0xff, 0xa5, 0x51, 0x32, 0x38, 0x4c, 0x59, 0xf6, 0xc9, 0xe1, 0x34, + 0x25, 0x2c, 0xce, 0x33, 0x67, 0xcc, 0xe9, 0x90, 0x24, 0x91, 0x88, 0x7c, 0x36, 0x89, 0x46, 0xd4, 0xd9, 0x19, 0x1c, + 0x4e, 0xa8, 0x88, 0x9c, 0x78, 0x1c, 0xf1, 0x82, 0x0a, 0xf2, 0xe1, 0xec, 0x9b, 0xf6, 0xc1, 0xe0, 0xb0, 0x88, 0x39, + 0x9b, 0x0a, 0x07, 0xba, 0x24, 0x93, 0x3c, 0x99, 0xa5, 0xd4, 0x89, 0x79, 0x5e, 0x14, 0x39, 0x67, 0x23, 0x96, 0x0d, + 0xae, 0x23, 0xee, 0x50, 0x32, 0x4a, 0xf3, 0xab, 0x28, 0x3d, 0x1b, 0xb3, 0x02, 0x0b, 0x42, 0xbd, 0xd3, 0x71, 0x94, + 0xe4, 0x37, 0xef, 0xf3, 0x5c, 0x6c, 0x6d, 0xb9, 0xea, 0xf1, 0xee, 0xf8, 0xf4, 0x94, 0x10, 0x72, 0x9d, 0xb3, 0xc4, + 0xe9, 0x2c, 0x16, 0x75, 0xa1, 0x97, 0x45, 0x82, 0x5d, 0x53, 0xd5, 0x04, 0x6d, 0x6d, 0x85, 0x51, 0x92, 0x4f, 0x05, + 0x4d, 0x4e, 0xc5, 0x5d, 0x4a, 0x4f, 0xc7, 0x94, 0x8a, 0x22, 0x64, 0x99, 0xf3, 0x3c, 0x8f, 0x67, 0x13, 0x9a, 0x09, + 0x6f, 0xca, 0x73, 0x91, 0x03, 0x34, 0x5b, 0x5b, 0x21, 0xa7, 0xd3, 0x34, 0x8a, 0x29, 0xbc, 0x3f, 0x3e, 0x3d, 0xad, + 0x5b, 0xd4, 0x95, 0x70, 0x46, 0x4e, 0xef, 0x26, 0x57, 0x79, 0xea, 0x22, 0xcc, 0x49, 0x46, 0x6f, 0x9c, 0xdf, 0xd1, + 0xe8, 0xd3, 0x9b, 0x68, 0x8a, 0x19, 0x89, 0xd3, 0xa8, 0x28, 0xe6, 0x71, 0x9e, 0x15, 0x82, 0xcf, 0x62, 0x91, 0x73, + 0x97, 0x62, 0x81, 0x39, 0x9a, 0xb3, 0xa1, 0x2b, 0xc6, 0xac, 0xf0, 0x2e, 0x37, 0xe3, 0xa2, 0x78, 0x4f, 0x8b, 0x59, + 0x2a, 0x36, 0xc9, 0x46, 0x07, 0xf3, 0x0d, 0x42, 0x32, 0x24, 0xc6, 0x3c, 0xbf, 0x71, 0x5e, 0x70, 0x9e, 0x73, 0xb7, + 0x75, 0x7c, 0x7a, 0xaa, 0x2a, 0x38, 0xac, 0x70, 0xb2, 0x5c, 0x38, 0x55, 0x77, 0xd1, 0x55, 0x4a, 0x3d, 0xe7, 0x43, + 0x41, 0x9d, 0x70, 0x96, 0x15, 0xd1, 0x90, 0x1e, 0x9f, 0x9e, 0x86, 0x4e, 0xce, 0x9d, 0x30, 0x2e, 0x8a, 0xd0, 0x61, + 0x59, 0x21, 0x68, 0x94, 0x78, 0x2d, 0xd4, 0x97, 0x63, 0xc5, 0x45, 0x71, 0x46, 0x6f, 0x05, 0xa1, 0x58, 0x3e, 0x0a, + 0x22, 0xca, 0x11, 0x15, 0x4e, 0x51, 0xcd, 0xc9, 0x45, 0xf3, 0x94, 0x0a, 0x87, 0x12, 0xf9, 0x3e, 0xc7, 0x99, 0xfa, + 0x21, 0xfa, 0x00, 0xed, 0xd6, 0x16, 0xad, 0x90, 0xab, 0xea, 0x09, 0x92, 0x6d, 0x98, 0x92, 0xad, 0xad, 0xcc, 0x4b, + 0x69, 0x36, 0x12, 0x63, 0x42, 0x48, 0xb7, 0x2f, 0x17, 0x85, 0x70, 0x6f, 0x44, 0x85, 0x9b, 0x21, 0x84, 0xeb, 0xa6, + 0x5b, 0x5b, 0xae, 0x9a, 0x79, 0x4e, 0xa8, 0x44, 0x56, 0x03, 0xab, 0xc8, 0xd3, 0xf8, 0x3e, 0xbd, 0xcb, 0x62, 0xd7, + 0x86, 0x1a, 0x61, 0xb1, 0xb5, 0xc5, 0xbd, 0x02, 0x3a, 0xc4, 0x14, 0xa1, 0x92, 0x53, 0x31, 0xe3, 0x99, 0x43, 0x4b, + 0x91, 0x9f, 0x0a, 0xce, 0xb2, 0x91, 0x8b, 0xe6, 0xba, 0xcc, 0x6e, 0x57, 0x96, 0x38, 0x22, 0x94, 0x0c, 0x60, 0x28, + 0xe6, 0xc2, 0x7a, 0xe5, 0x43, 0x87, 0x12, 0x12, 0x16, 0xb2, 0x51, 0x18, 0x50, 0x9f, 0x6e, 0x87, 0x21, 0x56, 0xd0, + 0xe1, 0x0c, 0xe1, 0x9c, 0xb8, 0x14, 0x7b, 0x9e, 0x27, 0x90, 0x69, 0x45, 0xad, 0xa9, 0x05, 0xf4, 0xbc, 0x73, 0xe1, + 0x0b, 0x8f, 0xd3, 0x64, 0x16, 0x53, 0xd7, 0x15, 0x38, 0xc3, 0x1c, 0x91, 0x81, 0xd8, 0x76, 0x29, 0x19, 0xc0, 0xba, + 0x6e, 0x74, 0x08, 0x21, 0xb4, 0xb1, 0xb2, 0xc8, 0x00, 0x6b, 0xa0, 0x92, 0x18, 0xad, 0x61, 0xc9, 0x66, 0x93, 0x2b, + 0xca, 0xc3, 0xaa, 0x5a, 0xdf, 0x26, 0x80, 0x70, 0x56, 0x50, 0x27, 0x2e, 0x0a, 0x67, 0x38, 0xcb, 0x62, 0xc1, 0xf2, + 0xcc, 0x09, 0xb7, 0xe9, 0x76, 0xa8, 0x16, 0xbe, 0x5e, 0x77, 0x54, 0x22, 0x37, 0x43, 0xdb, 0xf4, 0x9c, 0x6f, 0x77, + 0x2f, 0x30, 0x40, 0x89, 0x30, 0x85, 0xf9, 0x14, 0xc4, 0x55, 0x20, 0x4a, 0xa2, 0x43, 0x99, 0xb7, 0x4a, 0xfd, 0x84, + 0x7b, 0x93, 0x68, 0x0a, 0x13, 0xa0, 0x92, 0x6a, 0xa2, 0x2c, 0x06, 0xd0, 0x1a, 0x4b, 0x03, 0x88, 0xf2, 0x6a, 0x5a, + 0x41, 0x7d, 0x9a, 0x16, 0xd4, 0x19, 0xe6, 0xdc, 0x95, 0xb4, 0xe0, 0xe4, 0x43, 0x87, 0x2b, 0xba, 0xe0, 0x24, 0x31, + 0x9c, 0x14, 0x73, 0x1a, 0x09, 0xfa, 0x22, 0xa5, 0xf0, 0xe4, 0x86, 0xb2, 0x79, 0x88, 0x30, 0x23, 0xd4, 0x4b, 0x99, + 0x38, 0xc9, 0xb3, 0x98, 0xf6, 0x99, 0x45, 0x44, 0x72, 0x81, 0x8f, 0x84, 0xe0, 0xec, 0x6a, 0x26, 0xa8, 0x1b, 0x66, + 0x50, 0x23, 0xc4, 0x0c, 0x61, 0xee, 0x09, 0x7a, 0x2b, 0x8e, 0xf3, 0x4c, 0xd0, 0x4c, 0x10, 0x61, 0x10, 0x89, 0x33, + 0x2f, 0x9a, 0x4e, 0x69, 0x96, 0x1c, 0x8f, 0x59, 0x9a, 0xb8, 0x1c, 0x95, 0x25, 0x8e, 0x89, 0x08, 0x60, 0x2a, 0xfe, + 0xc3, 0xf3, 0x91, 0xeb, 0xa5, 0xe8, 0x38, 0x0c, 0xfb, 0x66, 0x22, 0x19, 0x4c, 0x44, 0xae, 0xd3, 0xfb, 0x59, 0x4a, + 0x0b, 0x24, 0xb6, 0x49, 0x56, 0xad, 0x9a, 0x5e, 0x9f, 0xc8, 0x15, 0x80, 0x6d, 0x8a, 0x7c, 0x8a, 0xe7, 0xac, 0xf0, + 0x53, 0x9c, 0xd0, 0x21, 0xcb, 0xe8, 0x3b, 0x9e, 0x4f, 0x29, 0x17, 0x77, 0xfe, 0x0c, 0x8f, 0xa8, 0x78, 0x7b, 0x93, + 0x99, 0x82, 0xe7, 0x54, 0x89, 0xb8, 0x9c, 0xfb, 0xc9, 0xd2, 0xab, 0x93, 0x68, 0x42, 0x0b, 0x7f, 0xb8, 0x54, 0xaa, + 0x04, 0x4a, 0xe1, 0x53, 0x0a, 0x2f, 0xde, 0x19, 0x51, 0xf3, 0x76, 0xe8, 0x0b, 0x5a, 0x92, 0xb7, 0x57, 0x1f, 0x69, + 0x2c, 0xf0, 0xd4, 0x96, 0x89, 0x13, 0x32, 0xf5, 0x04, 0x9f, 0x15, 0x82, 0x26, 0x67, 0x77, 0x53, 0x5a, 0xe0, 0x8c, + 0x92, 0x49, 0x30, 0xf1, 0xe8, 0x64, 0x2a, 0xee, 0x4e, 0xe5, 0xe8, 0x7e, 0x18, 0x62, 0x4e, 0xc9, 0xd4, 0xe3, 0x34, + 0x8a, 0x41, 0x20, 0xea, 0x75, 0x79, 0x97, 0xa7, 0x77, 0x43, 0x96, 0xa6, 0xa7, 0xb3, 0xe9, 0x34, 0xe7, 0x02, 0x8f, + 0x81, 0x01, 0x80, 0xfa, 0x29, 0x1e, 0x91, 0xb9, 0xc8, 0xeb, 0xf5, 0x80, 0xe2, 0x79, 0x71, 0xc3, 0x44, 0x3c, 0x76, + 0x05, 0x9a, 0xc7, 0x51, 0x41, 0x9d, 0x67, 0x79, 0x9e, 0xd2, 0x28, 0xf3, 0x29, 0xa1, 0x41, 0x46, 0xfd, 0x6c, 0x96, + 0xa6, 0xfd, 0x2b, 0x4e, 0xa3, 0x4f, 0x7d, 0xf9, 0x5a, 0xc1, 0xea, 0xcb, 0xdf, 0x47, 0x9c, 0x47, 0x77, 0x50, 0x91, + 0x10, 0xa8, 0x16, 0x50, 0xff, 0xd7, 0xa7, 0x6f, 0x4f, 0x3c, 0xc5, 0x89, 0x6c, 0x78, 0xe7, 0x52, 0x8b, 0xad, 0xf1, + 0x90, 0xe7, 0x93, 0xa5, 0xa1, 0xe5, 0x02, 0x11, 0xda, 0xbf, 0x07, 0x84, 0x8c, 0xd0, 0x0d, 0xd5, 0xb5, 0x0d, 0xc1, + 0x89, 0x64, 0x2e, 0x78, 0x49, 0xf4, 0xb8, 0xf0, 0xc7, 0x57, 0xc5, 0x2e, 0x45, 0x0f, 0x43, 0x2b, 0xf8, 0xdd, 0x3c, + 0x23, 0x12, 0xce, 0x29, 0x28, 0x2d, 0x80, 0x31, 0x8e, 0x44, 0x3c, 0x9e, 0x67, 0xb2, 0xb3, 0xd2, 0x40, 0x9c, 0x95, + 0x25, 0xbe, 0x34, 0x98, 0xdb, 0x48, 0xe5, 0x0f, 0x7c, 0x4d, 0xe6, 0x91, 0x99, 0x82, 0xbf, 0xd1, 0xc1, 0xb0, 0x88, + 0xbe, 0x12, 0x57, 0x38, 0xce, 0xb3, 0x6b, 0xca, 0x05, 0xe5, 0xfe, 0x08, 0x73, 0x3a, 0x4c, 0x61, 0xe0, 0x8d, 0x2e, + 0x9e, 0x15, 0xf4, 0x39, 0x1d, 0x46, 0xb3, 0x54, 0x3e, 0x8d, 0xa3, 0xe2, 0x78, 0x1c, 0x65, 0x23, 0x9a, 0xf8, 0x97, + 0x65, 0x5f, 0x91, 0x85, 0x07, 0x3a, 0x14, 0xb4, 0x6a, 0x10, 0x18, 0xcd, 0x13, 0x9a, 0xa2, 0x10, 0xe1, 0x29, 0xb0, + 0x96, 0x21, 0xa4, 0x37, 0x75, 0x55, 0x4b, 0x33, 0xf5, 0x41, 0xa5, 0xde, 0x29, 0xed, 0xe4, 0xd0, 0x5b, 0x41, 0xb3, + 0xa4, 0x70, 0x5e, 0x9e, 0xbd, 0x79, 0xad, 0x29, 0x62, 0x5e, 0x88, 0x48, 0xb0, 0xd8, 0x89, 0x92, 0xe4, 0x55, 0xc6, + 0x04, 0x8b, 0x52, 0xf6, 0x83, 0xc4, 0xd5, 0x5c, 0x2b, 0xad, 0x17, 0xcc, 0x45, 0x58, 0xc9, 0xe7, 0x34, 0x08, 0xc8, + 0xf9, 0x05, 0xf2, 0xa6, 0xb3, 0x62, 0x0c, 0xc8, 0xd1, 0x4d, 0x41, 0xb3, 0xe4, 0x57, 0x05, 0xe5, 0xd7, 0x34, 0xa9, + 0x56, 0xb1, 0x58, 0x92, 0xd1, 0x43, 0x96, 0xc9, 0xae, 0x5d, 0x84, 0x4d, 0xc7, 0xe3, 0xad, 0xad, 0x73, 0x10, 0xbe, + 0xe6, 0xd1, 0xfb, 0x44, 0xef, 0x0a, 0x17, 0x5d, 0x98, 0x7e, 0x95, 0x44, 0x31, 0xd3, 0x03, 0x2c, 0x93, 0x6b, 0xa5, + 0x4e, 0x3d, 0xa8, 0x41, 0xb7, 0xb6, 0x5c, 0xe1, 0x55, 0x38, 0x27, 0x1b, 0xdd, 0xba, 0x6b, 0x66, 0x86, 0xa9, 0x54, + 0xb7, 0x37, 0x8e, 0x0a, 0x8b, 0xeb, 0x5c, 0x8a, 0xa4, 0x7a, 0xd2, 0x0c, 0xa6, 0xa5, 0x97, 0x2b, 0x10, 0xf2, 0x6e, + 0x38, 0x88, 0x99, 0x84, 0x6c, 0x74, 0x74, 0x1f, 0x54, 0xf3, 0x8e, 0x6a, 0xca, 0x68, 0x21, 0x55, 0x93, 0x5c, 0xf4, + 0x0d, 0xe1, 0x65, 0xf9, 0x51, 0x1c, 0x53, 0xb0, 0x60, 0x0c, 0xd1, 0x5a, 0x26, 0x82, 0x6c, 0xaf, 0xd8, 0x7a, 0x49, + 0x3a, 0xb8, 0x14, 0x67, 0x58, 0xa0, 0x3e, 0xb7, 0x44, 0xe2, 0xcc, 0x6d, 0xc2, 0x8c, 0x29, 0x06, 0x29, 0x57, 0xa3, + 0x79, 0x6d, 0x37, 0x02, 0x67, 0x72, 0xe4, 0xf9, 0x88, 0x0a, 0x9f, 0xe3, 0x82, 0x0a, 0x9f, 0x95, 0x24, 0x59, 0xe9, + 0x0b, 0x05, 0x01, 0x54, 0x69, 0xae, 0xcb, 0xb9, 0xb8, 0x28, 0xb1, 0x9c, 0x8e, 0x5a, 0xf0, 0x73, 0x71, 0x41, 0x68, + 0x59, 0x6a, 0xf1, 0x57, 0x77, 0xe9, 0x6a, 0x96, 0x8c, 0x08, 0x0f, 0xbc, 0x38, 0x4a, 0x53, 0xd9, 0x3d, 0xea, 0x33, + 0xeb, 0x09, 0x10, 0x22, 0x07, 0xe5, 0xf4, 0xfb, 0x19, 0x2d, 0xc4, 0x87, 0x69, 0x12, 0x49, 0x76, 0x8e, 0x70, 0x86, + 0x4a, 0x60, 0x82, 0x21, 0x1b, 0xcd, 0x38, 0x98, 0x32, 0xc0, 0x20, 0x34, 0x9b, 0x4d, 0xa8, 0x79, 0x5a, 0x37, 0xcb, + 0xb7, 0x53, 0x50, 0x81, 0x05, 0x80, 0x66, 0x53, 0xd2, 0xea, 0x72, 0x8c, 0x24, 0xfc, 0x41, 0x70, 0x6d, 0x3a, 0x51, + 0x14, 0x50, 0x59, 0x5e, 0x4b, 0x4b, 0x3f, 0x76, 0xc3, 0x95, 0x3e, 0x42, 0x84, 0xb4, 0x4a, 0xee, 0x6b, 0xbb, 0x88, + 0xea, 0x19, 0x52, 0x9b, 0x74, 0xa9, 0x97, 0x5a, 0xeb, 0xa5, 0xb9, 0x82, 0x00, 0x15, 0x53, 0x2f, 0xbd, 0xb8, 0x8f, + 0x5e, 0x24, 0x3f, 0xbe, 0x01, 0xad, 0xbb, 0xfa, 0xae, 0xe2, 0xa2, 0x7a, 0x94, 0x07, 0xe0, 0x36, 0x95, 0x12, 0x0b, + 0x5e, 0x53, 0xbb, 0x7a, 0x07, 0xc6, 0xe5, 0x0a, 0x23, 0xac, 0xf6, 0x35, 0x6d, 0x4c, 0xde, 0x36, 0x07, 0xeb, 0x37, + 0x58, 0xc8, 0xc9, 0x0d, 0x5d, 0x8a, 0xc0, 0x4e, 0xa2, 0x20, 0x13, 0x2f, 0x9a, 0x0a, 0x54, 0x20, 0x65, 0x83, 0x35, + 0x99, 0x35, 0xc3, 0xf4, 0x3c, 0xbb, 0x40, 0x65, 0xdd, 0xeb, 0xf9, 0x92, 0x44, 0xbb, 0x00, 0xc0, 0x8d, 0x10, 0x37, + 0x56, 0xe6, 0x1a, 0x71, 0xa6, 0x57, 0x57, 0x4e, 0xb3, 0xc2, 0x3d, 0xd2, 0x20, 0x9c, 0x53, 0x9c, 0x5d, 0xd4, 0x40, + 0xdc, 0xc7, 0xa9, 0x19, 0x2a, 0x2b, 0x29, 0x63, 0x16, 0xa3, 0x5f, 0x77, 0x21, 0x64, 0x17, 0x6b, 0x3b, 0x30, 0x3c, + 0x6d, 0x9a, 0xcf, 0x24, 0xdf, 0xf7, 0x6d, 0x6b, 0xb8, 0x96, 0x5f, 0xc6, 0x62, 0x2d, 0xed, 0xbe, 0xa4, 0x19, 0x52, + 0x90, 0xc6, 0x12, 0xa9, 0x32, 0xb5, 0x6c, 0xd2, 0x50, 0x5a, 0x25, 0x03, 0x5d, 0x85, 0x1a, 0xcc, 0x9c, 0x4b, 0x7c, + 0x49, 0x45, 0xe5, 0xb1, 0x42, 0xfe, 0xeb, 0x52, 0x64, 0xc0, 0x83, 0x39, 0x9d, 0xc2, 0x54, 0xbd, 0x61, 0x1a, 0x09, + 0xb7, 0xbb, 0xd3, 0x01, 0xf3, 0xfa, 0x9a, 0x82, 0x16, 0x43, 0xa8, 0x5a, 0x30, 0x0a, 0x0b, 0x96, 0x21, 0xe1, 0xcd, + 0xb2, 0x62, 0xcc, 0x86, 0xc2, 0x8d, 0xa1, 0x8f, 0x52, 0x9a, 0x77, 0xd4, 0x9e, 0x92, 0x12, 0xf1, 0xf2, 0xad, 0xb1, + 0x84, 0x84, 0xc5, 0x5c, 0x33, 0x5b, 0x47, 0x5b, 0x32, 0x58, 0xd7, 0xdd, 0xe8, 0x82, 0xfa, 0x0d, 0x54, 0x6f, 0xbe, + 0x36, 0x7e, 0x33, 0xcb, 0x10, 0xcf, 0xfc, 0x75, 0xd6, 0xb9, 0x27, 0xf2, 0xd7, 0xf9, 0x0d, 0xe5, 0xc7, 0x11, 0x40, + 0xed, 0xab, 0xe6, 0xa5, 0xbd, 0xa3, 0x42, 0xf3, 0x62, 0x36, 0xa5, 0xdc, 0xd2, 0x21, 0x53, 0x0d, 0xb3, 0x2a, 0x60, + 0x85, 0x92, 0x39, 0xef, 0x68, 0x96, 0xb0, 0x6c, 0x44, 0x36, 0xba, 0x15, 0xf1, 0xab, 0x17, 0x49, 0x55, 0x74, 0xb9, + 0xf9, 0x62, 0x22, 0x49, 0xaf, 0x7a, 0xbc, 0x76, 0x51, 0xa9, 0xfe, 0xa9, 0x54, 0xdf, 0xa9, 0x44, 0xec, 0x3b, 0x9e, + 0x4f, 0x18, 0x98, 0x03, 0x64, 0xa0, 0x16, 0x36, 0x03, 0xa1, 0x25, 0x3b, 0x84, 0x41, 0x68, 0x05, 0xcd, 0xd1, 0x6b, + 0x43, 0x5c, 0x55, 0xa7, 0x97, 0xee, 0x5a, 0x99, 0xa8, 0x0b, 0xad, 0xb9, 0x79, 0x69, 0xe0, 0x0d, 0x73, 0xfe, 0x22, + 0x8a, 0xc7, 0xd2, 0x38, 0x57, 0xd2, 0x07, 0x95, 0x51, 0x92, 0x80, 0x25, 0xcc, 0xf3, 0x34, 0x55, 0x6a, 0xd9, 0x6c, + 0x26, 0x5f, 0xbc, 0xd5, 0x8a, 0xfe, 0x14, 0xf6, 0x52, 0x51, 0x92, 0xb8, 0xb4, 0x1a, 0x2a, 0x4b, 0x28, 0x87, 0xfd, + 0xf2, 0x32, 0x95, 0xb2, 0xe2, 0x38, 0xcf, 0x32, 0x1a, 0x0b, 0x9a, 0x6c, 0x6d, 0x51, 0x6f, 0x9c, 0x17, 0xa2, 0x2a, + 0x08, 0x3c, 0x17, 0x4c, 0xb2, 0x49, 0x7e, 0x4d, 0x9b, 0x03, 0xd6, 0xe3, 0x79, 0x09, 0x4d, 0xa9, 0x90, 0x76, 0x91, + 0x9a, 0x9a, 0x16, 0x1a, 0xd5, 0xa4, 0xc9, 0xca, 0xac, 0x56, 0x18, 0x6a, 0x49, 0x78, 0x68, 0x9d, 0x8f, 0xd6, 0xc9, + 0xa8, 0x0c, 0xc9, 0xfd, 0xbe, 0xe2, 0x2a, 0x29, 0x42, 0xb2, 0x0b, 0x84, 0x15, 0x0c, 0x8e, 0x79, 0xee, 0x53, 0xaf, + 0x60, 0x3f, 0xd0, 0x41, 0x25, 0x8e, 0x25, 0x51, 0x80, 0xe5, 0x26, 0x05, 0xd2, 0xfb, 0x0a, 0x17, 0xcd, 0x1d, 0x6f, + 0x51, 0xf9, 0x14, 0x82, 0x40, 0x16, 0x44, 0x42, 0x44, 0xf1, 0x58, 0xf9, 0x0d, 0xdc, 0x95, 0x69, 0xd4, 0xd5, 0xb5, + 0x52, 0xaa, 0xd8, 0xa2, 0x70, 0xe9, 0xea, 0x5a, 0x36, 0x58, 0x1f, 0x61, 0x0a, 0x44, 0xac, 0xb0, 0x7c, 0x1c, 0xa5, + 0xe9, 0x55, 0x14, 0x7f, 0x32, 0x44, 0x56, 0xaf, 0x55, 0x10, 0x10, 0x4b, 0x90, 0xda, 0x70, 0xe3, 0x35, 0x54, 0xe7, + 0x56, 0xd6, 0x89, 0x5a, 0x19, 0x9b, 0x74, 0x56, 0xd7, 0x15, 0x95, 0x4b, 0xad, 0x29, 0x9a, 0x97, 0x09, 0x2b, 0xee, + 0x05, 0xeb, 0x9e, 0x4e, 0x9f, 0x5b, 0x4d, 0x54, 0xbf, 0x15, 0xeb, 0x6b, 0xd3, 0xb5, 0xea, 0x48, 0xdb, 0x25, 0x86, + 0x33, 0x7e, 0xa3, 0xa4, 0xf0, 0xe5, 0xe6, 0x8b, 0xb3, 0x86, 0xec, 0xf8, 0x2c, 0xbd, 0x68, 0xf1, 0x6f, 0x6c, 0x29, + 0xbb, 0xae, 0x16, 0x44, 0x99, 0xd4, 0x0d, 0xb6, 0x1d, 0x25, 0xb7, 0xe5, 0x99, 0xa7, 0x2d, 0x6d, 0x35, 0x16, 0x23, + 0x6e, 0xe6, 0x55, 0x76, 0x78, 0xe0, 0x59, 0x7b, 0x9d, 0xca, 0x61, 0x11, 0x8c, 0x7c, 0xab, 0x0e, 0xb2, 0xeb, 0xc0, + 0xe6, 0xdf, 0x03, 0xa1, 0xa5, 0x1d, 0x2c, 0x52, 0x7c, 0x50, 0xcc, 0xf4, 0x36, 0x43, 0xaf, 0x25, 0x30, 0x4f, 0xdd, + 0x84, 0x23, 0x5f, 0xd1, 0x9a, 0xbd, 0xcf, 0xe5, 0xb0, 0xc3, 0x6d, 0x4a, 0xa0, 0xb2, 0xd4, 0x08, 0xba, 0x17, 0x2d, + 0xe0, 0x6c, 0x52, 0x2a, 0xa6, 0x56, 0x86, 0x7c, 0x8d, 0x0a, 0x9a, 0x6c, 0x10, 0xc2, 0x2b, 0xae, 0xf4, 0xd6, 0xd8, + 0x52, 0x1c, 0x76, 0xe4, 0x46, 0xf8, 0xd6, 0x73, 0x25, 0x24, 0x34, 0x2e, 0x87, 0x30, 0x98, 0x37, 0xb6, 0x63, 0xbe, + 0x55, 0xad, 0xb4, 0x1f, 0x02, 0xaf, 0x51, 0xcf, 0xc6, 0xa2, 0x55, 0xcb, 0x42, 0x17, 0xef, 0x2b, 0x0b, 0x92, 0x35, + 0x1b, 0xba, 0x02, 0x53, 0x0b, 0xb5, 0xe7, 0xfc, 0x82, 0x44, 0x9a, 0x29, 0x2f, 0x37, 0x5f, 0x7c, 0x0c, 0xe4, 0x9c, + 0x39, 0x0a, 0x82, 0x68, 0x05, 0x6f, 0xcb, 0x86, 0xa6, 0xf4, 0xd0, 0x80, 0x88, 0x67, 0xd2, 0x88, 0xaa, 0x55, 0x9a, + 0x31, 0x5e, 0x97, 0x11, 0x0b, 0x88, 0x94, 0xda, 0x8a, 0x6f, 0x6d, 0xb9, 0x4c, 0xd9, 0x29, 0xf4, 0x02, 0xe1, 0x2c, + 0x08, 0x48, 0xb4, 0x0e, 0x7f, 0x14, 0xe1, 0x0d, 0xd7, 0xcd, 0xbc, 0x7a, 0xb3, 0x16, 0x04, 0x97, 0xc8, 0x65, 0x58, + 0xa0, 0xc5, 0x22, 0xf3, 0xea, 0x1d, 0x1d, 0x78, 0xc9, 0x34, 0x01, 0x6e, 0x6d, 0x31, 0x42, 0xc8, 0xd2, 0x84, 0x60, + 0xff, 0xb1, 0x61, 0xa4, 0x5e, 0x8d, 0x8b, 0xa8, 0xa6, 0xea, 0xda, 0xc2, 0x93, 0xd5, 0x8e, 0x35, 0x4b, 0x95, 0x12, + 0xde, 0x75, 0xea, 0xce, 0x92, 0x80, 0xa7, 0xd5, 0x70, 0xef, 0x80, 0x4b, 0x55, 0xdb, 0xb9, 0xb5, 0xdf, 0xcc, 0xaa, + 0x7d, 0x28, 0xc7, 0x7a, 0xc3, 0xe3, 0xb3, 0x12, 0x47, 0x68, 0x9e, 0x6d, 0x6d, 0x6d, 0xb8, 0x35, 0xb0, 0x81, 0x91, + 0xee, 0x08, 0x00, 0x55, 0xdb, 0xa6, 0xea, 0xad, 0x36, 0xaf, 0x60, 0xb9, 0xd4, 0x8a, 0x49, 0xe4, 0x6d, 0x74, 0x36, + 0x08, 0x61, 0x8b, 0x45, 0x54, 0xa3, 0x7f, 0xb1, 0x30, 0x8d, 0x8e, 0x5e, 0xeb, 0x7e, 0x4c, 0x51, 0xad, 0x9b, 0x17, + 0x8b, 0x0c, 0x0a, 0x4d, 0x9b, 0x5a, 0xab, 0x56, 0xfb, 0x2d, 0xe8, 0x5b, 0x2d, 0x96, 0x4d, 0xf1, 0xd4, 0x02, 0xe9, + 0xfb, 0x55, 0xa5, 0x88, 0xca, 0xa8, 0xb8, 0xcb, 0xa4, 0xdd, 0xf2, 0xce, 0xc8, 0xb7, 0x15, 0x43, 0xa1, 0xd3, 0x87, + 0xdd, 0x7f, 0x74, 0x13, 0x31, 0xe1, 0x54, 0x48, 0x54, 0xbb, 0x7f, 0x10, 0x96, 0xda, 0x04, 0xf0, 0x38, 0x85, 0xdd, + 0x22, 0x28, 0x40, 0x5b, 0x97, 0xc4, 0x63, 0x0a, 0x9e, 0x6c, 0xa3, 0xdb, 0x8d, 0x6a, 0xa0, 0x1b, 0x92, 0x4c, 0xb7, + 0xb6, 0x54, 0xb7, 0x14, 0x6f, 0xac, 0x1b, 0xbb, 0x5c, 0x6e, 0xde, 0xd8, 0xec, 0x4c, 0x29, 0x1f, 0xe6, 0x7c, 0x62, + 0xde, 0x95, 0x4b, 0xcf, 0xd2, 0x09, 0xb9, 0xae, 0x57, 0x6b, 0x73, 0xb0, 0xb1, 0x84, 0xe6, 0x7a, 0x7f, 0xf1, 0x78, + 0xe5, 0x03, 0x4a, 0x15, 0xcd, 0xd7, 0x59, 0xcc, 0xf2, 0x8d, 0x5e, 0x7a, 0x22, 0x2a, 0x6e, 0x37, 0x76, 0x99, 0x8d, + 0xa7, 0x87, 0xed, 0x02, 0xe0, 0x57, 0xad, 0xca, 0x2b, 0xeb, 0x5e, 0x28, 0xeb, 0x5e, 0x19, 0xc1, 0x73, 0x43, 0xa7, + 0xb4, 0x24, 0x99, 0xd6, 0x07, 0xe7, 0xe2, 0xa2, 0x2f, 0xc9, 0x8d, 0x2e, 0x16, 0x4d, 0x02, 0x03, 0x7e, 0xe4, 0x56, + 0x88, 0x40, 0xf3, 0x90, 0xa8, 0xbc, 0xbf, 0x72, 0x6b, 0xad, 0xa0, 0x03, 0x9b, 0x90, 0x54, 0xcd, 0x25, 0x25, 0x54, + 0x66, 0x42, 0x3e, 0x4b, 0x13, 0x8d, 0x6d, 0x81, 0x30, 0x0d, 0x14, 0xe6, 0x6e, 0x58, 0x9a, 0xd6, 0xa5, 0x0f, 0xa9, + 0x4c, 0x55, 0x4b, 0x2a, 0x4b, 0x55, 0x6f, 0x66, 0x9a, 0x69, 0xed, 0x70, 0xb9, 0xf9, 0xe2, 0x8d, 0xab, 0x1d, 0x4d, + 0xb0, 0xcb, 0x56, 0xfe, 0x60, 0x6a, 0x1b, 0xaa, 0x6f, 0x60, 0x19, 0x4a, 0x5a, 0x51, 0xfd, 0xd1, 0x0b, 0xf0, 0x4a, + 0x5a, 0x30, 0x80, 0x3a, 0x97, 0xc5, 0xf4, 0x61, 0xfd, 0xad, 0x29, 0xc0, 0x82, 0xc6, 0xe6, 0xbe, 0x65, 0x7e, 0xac, + 0xf6, 0x91, 0x43, 0xc6, 0xab, 0xb6, 0xc0, 0x50, 0xf6, 0x44, 0x12, 0x6d, 0x0d, 0xbe, 0xa9, 0x4d, 0x87, 0x65, 0x33, + 0x78, 0xd5, 0x2a, 0x97, 0xc1, 0x08, 0xd5, 0xfe, 0x38, 0x9f, 0x4c, 0xa5, 0x51, 0xd9, 0xa4, 0xfb, 0x11, 0xd5, 0x03, + 0xd6, 0xef, 0xcb, 0x35, 0x65, 0x8d, 0x36, 0x92, 0x65, 0x1b, 0x2b, 0x56, 0x79, 0x0e, 0x36, 0x3a, 0xe5, 0xac, 0x2a, + 0xaa, 0x64, 0xc5, 0xd6, 0x56, 0x25, 0x26, 0xbf, 0xb7, 0x91, 0x65, 0x0a, 0xcf, 0xb4, 0x6d, 0x07, 0x52, 0x0d, 0xd9, + 0xab, 0x51, 0xd6, 0x73, 0x9f, 0x97, 0x4b, 0xd8, 0x99, 0x97, 0x65, 0xff, 0x6e, 0x69, 0xf3, 0x77, 0x7e, 0x81, 0xef, + 0x56, 0x6d, 0x48, 0x32, 0x9f, 0xe4, 0x09, 0xf5, 0xc3, 0x7c, 0x4a, 0xb3, 0xb0, 0xc4, 0x77, 0xe7, 0xeb, 0x1d, 0x13, + 0x17, 0x15, 0x36, 0x65, 0x0d, 0xcb, 0x05, 0x50, 0xbf, 0xe1, 0x40, 0x61, 0xf3, 0xf7, 0x4d, 0x67, 0xaf, 0x7f, 0x57, + 0x22, 0xec, 0xae, 0xf8, 0x80, 0xbf, 0xa5, 0xbc, 0x80, 0xe1, 0x6d, 0x67, 0x5e, 0xd8, 0xf3, 0xba, 0x5e, 0x2f, 0x44, + 0xd2, 0x5b, 0x78, 0x65, 0x3b, 0x9b, 0x6f, 0x21, 0xa2, 0x42, 0xf1, 0x29, 0xb9, 0x6a, 0xfa, 0x9c, 0x19, 0x25, 0xa7, + 0xc1, 0xa9, 0xd9, 0xf6, 0xe7, 0x29, 0x8b, 0xef, 0xdc, 0x30, 0x65, 0xa2, 0x0d, 0x21, 0xc2, 0x10, 0xcf, 0xd5, 0x0b, + 0x70, 0x34, 0x4a, 0xdf, 0x7c, 0x69, 0xf6, 0x73, 0x38, 0xa2, 0x24, 0xdc, 0x4c, 0x99, 0xd8, 0x0c, 0xf1, 0x31, 0x81, + 0x16, 0x9b, 0x9b, 0xf3, 0x37, 0x91, 0x18, 0x7b, 0x3c, 0xca, 0x92, 0x7c, 0xe2, 0x82, 0xd9, 0xf5, 0x0d, 0xbb, 0xa5, + 0x89, 0xfb, 0x35, 0xf2, 0x8a, 0x94, 0xc5, 0xd4, 0xed, 0xa1, 0x72, 0x33, 0xc4, 0x39, 0x25, 0x61, 0x10, 0x6e, 0x1f, + 0xe3, 0x82, 0x92, 0xf0, 0x70, 0x73, 0x9e, 0xd3, 0x72, 0x10, 0xe2, 0x9b, 0x2a, 0x02, 0x81, 0xcf, 0x88, 0x8b, 0xc8, + 0xe0, 0x46, 0xc3, 0x74, 0x9c, 0x4f, 0x54, 0x24, 0x22, 0x44, 0xf8, 0x85, 0x9c, 0x84, 0xf6, 0x09, 0x2f, 0x16, 0xc6, + 0xfe, 0xd9, 0x20, 0x61, 0x2e, 0xdd, 0x7f, 0xe1, 0xd6, 0x96, 0x55, 0x56, 0x59, 0x42, 0xf8, 0x39, 0x69, 0x6c, 0xb8, + 0x71, 0x0c, 0x0e, 0xed, 0xc1, 0x73, 0xa9, 0xbd, 0x4c, 0x83, 0xc0, 0x33, 0x9e, 0x0d, 0x26, 0x28, 0x8f, 0x44, 0xce, + 0x2f, 0x6c, 0x6b, 0x0a, 0xbf, 0x25, 0xe1, 0xb9, 0xf3, 0x9f, 0x7e, 0xf6, 0xdd, 0xf0, 0x3b, 0x7e, 0x11, 0xe2, 0x4f, + 0x64, 0xe7, 0xd0, 0x0d, 0x7c, 0x77, 0xa3, 0xdd, 0x5e, 0x7c, 0xb7, 0x73, 0xfe, 0xa7, 0xa8, 0xfd, 0xc3, 0x51, 0xfb, + 0x8f, 0x17, 0x68, 0xe1, 0x7e, 0xb7, 0x13, 0x9c, 0xeb, 0xa7, 0xf3, 0x3f, 0x0d, 0xbe, 0x2b, 0x2e, 0x7e, 0xa9, 0x0a, + 0x37, 0x11, 0xda, 0x19, 0xe1, 0x94, 0x92, 0x9d, 0x76, 0x7b, 0xb0, 0x33, 0xc2, 0x33, 0x4a, 0x76, 0xe0, 0xdf, 0x23, + 0xf2, 0x9e, 0x8e, 0x5e, 0xdc, 0x4e, 0xdd, 0x70, 0xb0, 0xd8, 0x9c, 0xbf, 0x2d, 0xa1, 0xd7, 0xf3, 0x3f, 0x7d, 0xf7, + 0x5d, 0xd1, 0xfa, 0xc5, 0x80, 0xec, 0x5c, 0x6c, 0x23, 0x17, 0x4a, 0x7f, 0x49, 0xe4, 0x5f, 0x37, 0xf0, 0xcf, 0xff, + 0xe4, 0x7c, 0x27, 0xbe, 0xcb, 0x00, 0x8e, 0xd6, 0x2f, 0xbe, 0x0b, 0x0f, 0x07, 0xe4, 0x62, 0xe1, 0xb6, 0x16, 0xbf, + 0x40, 0x0b, 0x84, 0x16, 0x9b, 0x28, 0xc4, 0xe1, 0x28, 0x84, 0xdd, 0x15, 0xd9, 0xf9, 0xc5, 0xce, 0x08, 0x0f, 0x29, + 0xd9, 0x69, 0xed, 0x8c, 0xf0, 0x94, 0x92, 0x9d, 0x3f, 0xb9, 0x81, 0xaf, 0xfc, 0x8d, 0x0b, 0xe9, 0xac, 0x58, 0x40, + 0x78, 0x26, 0xe2, 0x34, 0x5a, 0x08, 0x26, 0x52, 0x8a, 0x36, 0x77, 0x18, 0xfe, 0x48, 0x80, 0x71, 0x5c, 0x01, 0x5e, + 0xa2, 0x0c, 0x91, 0x81, 0x3b, 0xbf, 0x84, 0x45, 0x06, 0x5a, 0xd9, 0xf4, 0x29, 0x56, 0x7b, 0xfc, 0xc2, 0x17, 0xf8, + 0x3a, 0x4a, 0x67, 0xb4, 0xf0, 0xb3, 0x12, 0x21, 0xb7, 0x8b, 0xf0, 0x1b, 0xed, 0x2d, 0x05, 0xf6, 0x53, 0xf4, 0x93, + 0xe5, 0xca, 0xb0, 0x0a, 0x11, 0x3e, 0x59, 0xf3, 0x52, 0x8c, 0xc1, 0x59, 0x80, 0xf0, 0x84, 0x36, 0xe2, 0xaf, 0xef, + 0x88, 0x59, 0xf7, 0x33, 0x4e, 0xe9, 0xef, 0xa2, 0xf4, 0x13, 0xe5, 0xee, 0x0d, 0xee, 0xf6, 0xbe, 0x46, 0xfd, 0x2a, + 0x98, 0x36, 0xd6, 0xb1, 0x05, 0x50, 0x8a, 0x6a, 0x11, 0x37, 0x56, 0xfc, 0xc2, 0x21, 0x8f, 0x6e, 0x42, 0xd4, 0x08, + 0xcb, 0x86, 0x2c, 0xbb, 0x8e, 0x52, 0x96, 0x38, 0x82, 0x4e, 0xa6, 0x69, 0x24, 0xa8, 0xa3, 0xa7, 0xe3, 0x44, 0x40, + 0x15, 0x61, 0xa5, 0xf0, 0x99, 0x65, 0x04, 0x0b, 0x9f, 0x51, 0xaf, 0x66, 0x02, 0x10, 0xd8, 0xc0, 0x5b, 0x23, 0x6a, + 0xe2, 0x06, 0x26, 0xc2, 0xa1, 0x03, 0x8e, 0xed, 0x2e, 0xe6, 0x20, 0x27, 0x18, 0x8e, 0x88, 0x20, 0x84, 0xf4, 0x82, + 0xf0, 0xb0, 0xb8, 0x1e, 0x0d, 0x42, 0x1f, 0x9e, 0x76, 0x83, 0xf0, 0x70, 0x12, 0x89, 0xf1, 0x20, 0x84, 0xc8, 0x4e, + 0x4e, 0x3e, 0x55, 0xdb, 0x68, 0x41, 0x3a, 0x7d, 0x71, 0x98, 0xf5, 0xc5, 0xf6, 0x76, 0x15, 0x34, 0x39, 0x17, 0x17, + 0xb8, 0xc0, 0x31, 0x4e, 0x49, 0xbb, 0x8b, 0x67, 0xa4, 0x23, 0x2b, 0xf7, 0x67, 0x87, 0x26, 0x6e, 0xbb, 0xb5, 0xe5, + 0xe6, 0x5e, 0x1a, 0x15, 0xe2, 0x55, 0x96, 0xd0, 0x5b, 0x32, 0xc3, 0x31, 0xc9, 0x3d, 0x7a, 0x4b, 0x63, 0x37, 0x43, + 0x38, 0x36, 0x2e, 0xb9, 0x3e, 0x9a, 0x11, 0xab, 0x1a, 0xce, 0x09, 0x21, 0x9f, 0x82, 0xf8, 0xbc, 0x7b, 0x41, 0x08, + 0x09, 0x37, 0xda, 0xed, 0x30, 0xc8, 0x49, 0x4a, 0x7d, 0x5d, 0xa2, 0xe7, 0x1d, 0x9f, 0xf7, 0x1a, 0x4f, 0xbb, 0x17, + 0xb6, 0xc3, 0x34, 0x27, 0x47, 0xc8, 0x77, 0xa7, 0xd4, 0x13, 0xb4, 0x10, 0x2e, 0xd4, 0x45, 0xd2, 0xf0, 0x36, 0xa4, + 0x7c, 0xb8, 0x13, 0x6e, 0x43, 0xa9, 0x24, 0x46, 0x88, 0xcf, 0x1e, 0x21, 0x3f, 0x27, 0x33, 0xea, 0xc3, 0xe0, 0x47, + 0x41, 0x7c, 0xde, 0x91, 0x83, 0x0f, 0xc2, 0xc0, 0xcd, 0x09, 0x0b, 0x82, 0x4f, 0x72, 0x8e, 0x68, 0x09, 0x86, 0x94, + 0xb4, 0x7b, 0xbe, 0x9b, 0xda, 0xd0, 0xb7, 0xa1, 0x57, 0x3d, 0x7d, 0x5c, 0x10, 0xa8, 0x8f, 0x73, 0x02, 0xe0, 0xd5, + 0xcd, 0x8e, 0x7c, 0xfd, 0x1c, 0xb6, 0xc2, 0x60, 0x48, 0xfd, 0x84, 0x22, 0x39, 0xee, 0x90, 0x2e, 0x16, 0xf0, 0x6f, + 0x42, 0x83, 0x9c, 0x1c, 0xc9, 0xa2, 0x54, 0x17, 0xcd, 0xa0, 0xe8, 0x93, 0x0f, 0xf3, 0xc2, 0xcc, 0x18, 0xae, 0x72, + 0x9b, 0x93, 0x10, 0x09, 0xf2, 0xd6, 0x16, 0x3d, 0x17, 0xdb, 0xdd, 0x0b, 0x88, 0x58, 0x70, 0x51, 0xfc, 0x8e, 0x89, + 0xb1, 0x1b, 0xee, 0x0c, 0x42, 0x14, 0x84, 0x0e, 0xac, 0x65, 0x3f, 0xda, 0x26, 0x0a, 0xb1, 0xd9, 0x76, 0x41, 0xfd, + 0x74, 0x40, 0x3a, 0x81, 0xcb, 0x95, 0x50, 0x2e, 0x10, 0xce, 0xb4, 0x04, 0xec, 0xe0, 0x14, 0x6d, 0x47, 0x74, 0xdb, + 0x3c, 0xa7, 0x68, 0xfb, 0x78, 0x3b, 0x41, 0x7e, 0xb6, 0x7d, 0xbc, 0xed, 0xa6, 0x84, 0x90, 0x76, 0x2f, 0x10, 0x7e, + 0x62, 0x62, 0x6a, 0xe7, 0x92, 0xd2, 0xa3, 0x6d, 0x17, 0x9c, 0xb0, 0x8b, 0x45, 0x78, 0x18, 0x0c, 0x42, 0xb4, 0xed, + 0x1a, 0xba, 0xda, 0x69, 0x12, 0xd6, 0x4e, 0x45, 0x59, 0x08, 0x61, 0x7e, 0x51, 0xe2, 0x6f, 0x4c, 0xb8, 0xa8, 0x91, + 0xce, 0x30, 0xaf, 0x99, 0xd8, 0xe2, 0xed, 0xac, 0xc4, 0x7a, 0xc7, 0xc9, 0x94, 0xf1, 0x37, 0x85, 0x79, 0x82, 0xbb, + 0x52, 0xed, 0xb8, 0x3a, 0x38, 0x27, 0x1d, 0x5c, 0x10, 0x51, 0xd3, 0x79, 0x4c, 0xea, 0x8a, 0xf8, 0x3c, 0xc5, 0xb3, + 0x0b, 0x32, 0x92, 0x1b, 0x6c, 0x54, 0xf9, 0xb2, 0x69, 0x4a, 0xe8, 0x52, 0x44, 0x39, 0xc5, 0x1c, 0xe1, 0x77, 0x5e, + 0x3c, 0xe3, 0x9c, 0x66, 0xe2, 0x24, 0x4f, 0xb4, 0x89, 0x46, 0x53, 0x30, 0x2c, 0x21, 0x54, 0x8c, 0x33, 0x98, 0xdf, + 0x62, 0x01, 0xff, 0xec, 0x36, 0xbc, 0x3d, 0x75, 0x1d, 0x65, 0xcb, 0xc8, 0x08, 0x72, 0x9f, 0x9a, 0x0c, 0x04, 0xb9, + 0x2a, 0xd2, 0x87, 0x1f, 0xc3, 0x0b, 0xe8, 0xbb, 0x40, 0xa5, 0x64, 0x1a, 0x97, 0x91, 0x77, 0x5e, 0x46, 0x6f, 0xe5, + 0x80, 0x2e, 0x42, 0x9a, 0x39, 0xb6, 0xb6, 0x62, 0x3d, 0x9f, 0xc3, 0xa2, 0x2f, 0x05, 0x0a, 0xf3, 0xb2, 0x3c, 0xa1, + 0x80, 0x13, 0x48, 0x1d, 0xd0, 0x45, 0xf6, 0xd6, 0x0e, 0xbc, 0x5c, 0x0d, 0x3f, 0x2c, 0x03, 0x23, 0xa7, 0x7a, 0x2d, + 0x83, 0xc3, 0x2e, 0x42, 0xd2, 0x0c, 0x86, 0x20, 0x9d, 0x04, 0x2a, 0x32, 0x2e, 0x5e, 0x41, 0x66, 0xe7, 0xf9, 0xf6, + 0xf6, 0x05, 0xce, 0x48, 0xb3, 0x9d, 0x4b, 0x91, 0x57, 0x4c, 0x53, 0x26, 0xdc, 0x63, 0x70, 0x92, 0xec, 0xb8, 0xe7, + 0x5e, 0xf0, 0xab, 0x0b, 0x14, 0xb8, 0xde, 0x2f, 0xd1, 0x8e, 0x62, 0x6a, 0x81, 0xfa, 0xb1, 0xa2, 0xa8, 0xb9, 0x0c, + 0x4a, 0x76, 0x31, 0x03, 0x96, 0xf0, 0x23, 0x9c, 0x45, 0x13, 0xea, 0x73, 0xe0, 0x37, 0xb3, 0xb6, 0x19, 0x86, 0xb5, + 0xf6, 0xb9, 0xe6, 0x72, 0x2f, 0x0c, 0xae, 0x69, 0xf5, 0x14, 0x84, 0xc1, 0x5d, 0xfd, 0xf4, 0xab, 0x30, 0xb8, 0xa2, + 0xfe, 0xfb, 0x12, 0x61, 0xb6, 0xe2, 0xfa, 0xa0, 0xc6, 0xa9, 0x6c, 0xd3, 0xfd, 0x31, 0xf0, 0x7a, 0x03, 0x92, 0x27, + 0x06, 0x92, 0x7b, 0x3a, 0x91, 0x04, 0x61, 0xa4, 0x05, 0xf3, 0x44, 0x34, 0x02, 0x34, 0x55, 0xc1, 0x0a, 0x66, 0x27, + 0x0a, 0xd4, 0x58, 0x10, 0x96, 0x50, 0x95, 0x14, 0x35, 0xe8, 0xa0, 0x79, 0xa3, 0xae, 0x34, 0x5d, 0x9a, 0xe1, 0xf2, + 0xda, 0x2f, 0x49, 0x3a, 0xfd, 0xec, 0x50, 0xf4, 0xb3, 0xed, 0x6d, 0xc4, 0x74, 0xc6, 0x81, 0xe4, 0x23, 0x7c, 0x06, + 0x56, 0xb3, 0x4d, 0x0d, 0xb8, 0x31, 0x99, 0x9e, 0x9e, 0xcc, 0xf6, 0x76, 0x54, 0xa2, 0xbe, 0xd5, 0x54, 0xa8, 0xa6, + 0x65, 0xa9, 0x70, 0xb2, 0x4c, 0x2c, 0x07, 0x9a, 0x58, 0x20, 0xd8, 0x41, 0x08, 0xc9, 0x29, 0x5a, 0xdb, 0x2d, 0x74, + 0x0a, 0xed, 0xf5, 0xdc, 0xdb, 0x5d, 0x25, 0xd5, 0x5d, 0x40, 0x83, 0x8c, 0x93, 0xc8, 0x6a, 0x6f, 0x87, 0xee, 0x31, + 0xa6, 0xdb, 0x5d, 0x49, 0xa9, 0xed, 0x6e, 0xbf, 0xd9, 0xd7, 0x53, 0x0b, 0xdf, 0x74, 0x9b, 0x1c, 0x57, 0x68, 0x2a, + 0xcb, 0x68, 0x7b, 0xbb, 0x6c, 0x06, 0x5e, 0x0d, 0xe3, 0x59, 0x7e, 0xa9, 0x9b, 0xe5, 0x2c, 0x0f, 0xa3, 0x11, 0x6b, + 0x1d, 0x98, 0x79, 0x2c, 0xcb, 0x28, 0x07, 0x9d, 0x47, 0x28, 0xce, 0xca, 0xb2, 0x56, 0xbf, 0xaf, 0x94, 0x07, 0x83, + 0x50, 0x93, 0x15, 0x45, 0x08, 0x79, 0x63, 0x12, 0x61, 0x44, 0x5f, 0x79, 0xe9, 0xea, 0x3d, 0x5b, 0x00, 0x2e, 0xaf, + 0xe3, 0xd4, 0x97, 0xff, 0xe4, 0x81, 0x77, 0xce, 0x2f, 0x70, 0x44, 0x60, 0xeb, 0x53, 0x45, 0x16, 0x3c, 0x29, 0x88, + 0x9e, 0x33, 0x4e, 0xa5, 0x81, 0xbb, 0x59, 0x29, 0xe2, 0xc0, 0xde, 0x6c, 0x6e, 0x10, 0x12, 0x81, 0x96, 0x09, 0x60, + 0x6f, 0xf2, 0x36, 0xf0, 0x5c, 0x88, 0x14, 0x47, 0xf5, 0x38, 0x46, 0x70, 0xfb, 0x2e, 0x93, 0x36, 0x45, 0x04, 0x5e, + 0x1e, 0x06, 0x95, 0xcf, 0x64, 0x94, 0x96, 0x83, 0x58, 0x5c, 0x06, 0x8b, 0x30, 0xdf, 0xd5, 0x90, 0x49, 0x3b, 0x1a, + 0xdc, 0x56, 0x0c, 0x61, 0xd6, 0x08, 0x0f, 0x12, 0x98, 0xb2, 0xec, 0xe9, 0x14, 0xe6, 0xee, 0x29, 0xe3, 0x07, 0x61, + 0x26, 0xfb, 0x14, 0xd2, 0x22, 0xb8, 0xa4, 0xeb, 0x53, 0xc7, 0xea, 0xed, 0xd4, 0xb7, 0x60, 0x17, 0x98, 0x87, 0x93, + 0x46, 0xc0, 0xe3, 0x72, 0xf3, 0xe8, 0xb9, 0x49, 0xf2, 0xba, 0xdc, 0x3c, 0x7a, 0xa3, 0xf3, 0xbc, 0xa6, 0x91, 0x91, + 0x91, 0x2b, 0x5b, 0xa4, 0xa3, 0x37, 0x5e, 0xfd, 0x56, 0x56, 0xbe, 0xdc, 0x3c, 0xfa, 0xb0, 0xae, 0x1a, 0x94, 0x97, + 0x33, 0x1d, 0x81, 0x9a, 0xd3, 0xd4, 0x9f, 0x6b, 0x19, 0xea, 0x8b, 0x12, 0x4b, 0xe1, 0xed, 0x67, 0x65, 0xb5, 0x6d, + 0x7e, 0x8e, 0x39, 0x71, 0x69, 0xa0, 0x08, 0x84, 0xe5, 0xd9, 0x69, 0x9c, 0x4f, 0x69, 0x10, 0xdc, 0x20, 0x8f, 0x4d, + 0x20, 0xd5, 0x44, 0x02, 0x23, 0xf0, 0x46, 0x07, 0xf5, 0x9b, 0x42, 0x9c, 0xeb, 0x85, 0x6f, 0x30, 0x56, 0xad, 0x37, + 0xb2, 0xf3, 0x8e, 0x0a, 0x38, 0xf6, 0x8b, 0x0a, 0xb5, 0x4a, 0xe2, 0xc2, 0x0a, 0x16, 0x8a, 0xea, 0xb5, 0x8c, 0xec, + 0x17, 0xd2, 0x8f, 0x28, 0xb5, 0x9c, 0x90, 0x4b, 0xf9, 0xda, 0x65, 0x98, 0xc9, 0x8e, 0x4f, 0xd9, 0x55, 0x0a, 0xa9, + 0x18, 0x00, 0x2f, 0xa6, 0xc8, 0xaf, 0xaa, 0x76, 0x75, 0xd5, 0xc2, 0x93, 0x98, 0x67, 0xb8, 0xf0, 0x40, 0x2c, 0xe2, + 0x42, 0x27, 0xab, 0x14, 0xab, 0x4d, 0x9e, 0xc8, 0xb5, 0x85, 0x46, 0xb7, 0x14, 0x5c, 0x7f, 0xea, 0x7d, 0xed, 0xb0, + 0xfa, 0x56, 0xf1, 0x9c, 0x40, 0x12, 0xfe, 0xed, 0xed, 0xfc, 0xa2, 0x04, 0x5f, 0x58, 0x11, 0x28, 0x68, 0xa5, 0xc5, + 0xd3, 0x9c, 0xee, 0xf6, 0x76, 0x95, 0x0e, 0xd3, 0xc4, 0xce, 0x0d, 0xe6, 0xe5, 0xb4, 0x8e, 0x02, 0x76, 0x96, 0xc2, + 0x27, 0x66, 0x40, 0x64, 0x07, 0x24, 0xdd, 0xcc, 0x80, 0xde, 0x24, 0xda, 0xa3, 0x57, 0x52, 0x18, 0x21, 0x45, 0xb8, + 0xf0, 0x24, 0x53, 0x10, 0xb0, 0xcc, 0x7b, 0xd2, 0x2d, 0x8c, 0x44, 0xe8, 0xc1, 0x74, 0x40, 0x24, 0xe0, 0xd7, 0x95, + 0x31, 0xf0, 0x00, 0xb1, 0x48, 0xd6, 0xfa, 0x50, 0x79, 0x6d, 0x8f, 0xaf, 0xcb, 0xe5, 0x44, 0x48, 0x60, 0x23, 0x45, + 0xd1, 0x12, 0x89, 0xbd, 0x0a, 0x59, 0x2f, 0xc9, 0xc9, 0xfd, 0xc4, 0x7d, 0x64, 0x11, 0xf7, 0x33, 0x22, 0x2c, 0x42, + 0x57, 0x11, 0x21, 0x2f, 0xd7, 0x5b, 0x69, 0x8e, 0xab, 0xa1, 0x21, 0x43, 0xc1, 0x0a, 0x74, 0x05, 0xc1, 0x46, 0x67, + 0x95, 0x29, 0x2c, 0xe3, 0x00, 0x86, 0xb1, 0x78, 0xc2, 0x72, 0x05, 0xbd, 0xa9, 0x62, 0x9f, 0x16, 0x76, 0x69, 0xd0, + 0xd0, 0xf4, 0x5d, 0x99, 0xfe, 0x28, 0xac, 0x0e, 0x20, 0xde, 0xa3, 0x92, 0x2d, 0x23, 0x7e, 0x0f, 0x0f, 0x1e, 0xc9, + 0x0a, 0x34, 0x4b, 0xd6, 0xbf, 0x7e, 0x56, 0xea, 0xe5, 0x51, 0xa0, 0xa0, 0x39, 0x25, 0xaf, 0x54, 0x86, 0x85, 0x4c, + 0x3a, 0x01, 0x37, 0x4f, 0x00, 0x83, 0x9f, 0x2c, 0x16, 0xd4, 0xec, 0x69, 0xe1, 0x39, 0x0c, 0x83, 0xca, 0xcd, 0xfa, + 0x72, 0x83, 0x90, 0x93, 0xda, 0x63, 0xf4, 0xbe, 0xf6, 0xe4, 0x01, 0xc6, 0x91, 0x0f, 0xbe, 0xf1, 0xaa, 0x60, 0x6b, + 0x0b, 0x1e, 0xdf, 0x98, 0xea, 0x32, 0xdd, 0xcd, 0xab, 0x8d, 0xbc, 0x9a, 0x8c, 0xa8, 0x3d, 0x77, 0x63, 0xe3, 0x83, + 0xa6, 0x56, 0x2b, 0xff, 0x09, 0x5a, 0xd6, 0x7d, 0xc8, 0x5f, 0x67, 0xd5, 0xaf, 0x4d, 0x30, 0x0b, 0xde, 0x2e, 0xa7, + 0x73, 0x2c, 0xa1, 0xdf, 0x63, 0x59, 0x41, 0xb9, 0x78, 0x46, 0x87, 0x39, 0xa7, 0xae, 0xb5, 0xfa, 0xa8, 0x3c, 0xb3, + 0x9c, 0x37, 0x72, 0x7e, 0x96, 0xe3, 0x77, 0x69, 0x82, 0xf2, 0xd7, 0x5b, 0xe9, 0xfc, 0xbd, 0x5c, 0x6e, 0x75, 0xb2, + 0xb5, 0xf5, 0xa2, 0x46, 0x13, 0x0a, 0x6a, 0x28, 0x2c, 0x39, 0xa1, 0xb4, 0x31, 0x35, 0x53, 0xa8, 0x36, 0x97, 0x86, + 0x67, 0x6d, 0x76, 0x7f, 0x49, 0x68, 0xb9, 0x69, 0xe4, 0xa4, 0xde, 0xdf, 0x2e, 0xd9, 0xc8, 0xa0, 0xf3, 0x88, 0x15, + 0x08, 0xd7, 0x59, 0xa0, 0xd5, 0xd8, 0xc7, 0x80, 0x24, 0x37, 0x03, 0xbb, 0xb7, 0xc1, 0xc7, 0x34, 0x25, 0xdf, 0x2c, + 0xe9, 0xdc, 0x31, 0x85, 0xf0, 0x03, 0xce, 0xbc, 0xb1, 0xcc, 0xfb, 0xb4, 0xb9, 0x00, 0x21, 0xdb, 0x86, 0x06, 0xc8, + 0x02, 0xa5, 0x21, 0x20, 0x2a, 0x54, 0x95, 0x79, 0x53, 0x57, 0x34, 0x4c, 0x09, 0x10, 0x64, 0x97, 0x10, 0x99, 0x92, + 0xc4, 0x06, 0x0a, 0xda, 0xd3, 0x99, 0x48, 0xa6, 0xdf, 0x3e, 0x95, 0x8d, 0xb0, 0xc6, 0x46, 0xd6, 0x9c, 0x7b, 0xa9, + 0x27, 0xa0, 0x65, 0xd4, 0x84, 0xaa, 0x00, 0x87, 0x11, 0x29, 0x75, 0x06, 0x81, 0x35, 0xb7, 0x89, 0x8a, 0xeb, 0xd2, + 0x5a, 0xc8, 0x4a, 0x30, 0xbe, 0x51, 0x88, 0x2d, 0x3f, 0x81, 0x27, 0xf4, 0xb9, 0xb5, 0x4a, 0x56, 0x00, 0xe1, 0xa5, + 0xad, 0x0e, 0xdf, 0x43, 0x7a, 0x43, 0x23, 0x45, 0xe3, 0xe8, 0x25, 0xe6, 0x98, 0x59, 0x92, 0x32, 0x52, 0x59, 0x2a, + 0x4c, 0xc6, 0x04, 0x95, 0x78, 0x0b, 0x32, 0x25, 0xa1, 0x55, 0x0e, 0xb7, 0x8a, 0xb5, 0x7b, 0x6f, 0xdd, 0xb3, 0xca, + 0x2d, 0x6a, 0xfd, 0x5e, 0xc2, 0xb0, 0xcf, 0x49, 0x76, 0xce, 0x2e, 0x30, 0x57, 0x22, 0x34, 0x42, 0x98, 0x6d, 0x6f, + 0xf7, 0x99, 0xbd, 0xb7, 0xae, 0x61, 0xe3, 0x90, 0xe6, 0x0a, 0xc4, 0xdb, 0x50, 0x41, 0x0c, 0xf6, 0x75, 0x3a, 0xcd, + 0x98, 0x81, 0xf3, 0xf4, 0xe8, 0xbd, 0x6b, 0xcb, 0xa2, 0x86, 0xba, 0x52, 0x5e, 0x77, 0xf3, 0xf2, 0x9d, 0xb4, 0x5e, + 0x30, 0x38, 0x66, 0x51, 0xdf, 0x66, 0xe1, 0x67, 0x7d, 0x83, 0xfe, 0x5b, 0xd8, 0x11, 0x58, 0x5d, 0xf4, 0x65, 0x81, + 0xb2, 0xad, 0x21, 0x83, 0x89, 0x88, 0xb2, 0x2c, 0x68, 0x1d, 0x1f, 0xb6, 0xd9, 0xe3, 0x0d, 0x59, 0x4e, 0x6e, 0x92, + 0x02, 0xb5, 0xe6, 0x42, 0x18, 0x1f, 0x98, 0xaa, 0xc4, 0xef, 0xb5, 0xd5, 0x02, 0x82, 0x4c, 0xdb, 0xe5, 0xee, 0xda, + 0x3c, 0x2d, 0x63, 0xb5, 0x7f, 0xde, 0xd6, 0x58, 0xa3, 0x32, 0x20, 0x90, 0x57, 0x2b, 0x8d, 0xee, 0x23, 0x94, 0x86, + 0x1e, 0xd5, 0xc0, 0x0c, 0xaa, 0xbc, 0xa1, 0x37, 0x78, 0x53, 0x6f, 0xb0, 0x6a, 0x29, 0x06, 0xb0, 0x73, 0x3c, 0xef, + 0x80, 0xbb, 0x22, 0x0c, 0xe1, 0x67, 0x57, 0xfd, 0xb4, 0x44, 0xaa, 0xf2, 0x06, 0xba, 0x59, 0x65, 0x36, 0x23, 0x0f, + 0x92, 0x69, 0x5d, 0x19, 0x70, 0x92, 0x74, 0xac, 0xc9, 0xc7, 0xa8, 0xdf, 0xac, 0xf2, 0xf1, 0x03, 0xc4, 0x4d, 0xa9, + 0xae, 0x34, 0xa2, 0xb2, 0x7d, 0xec, 0x46, 0x38, 0x22, 0x1b, 0x72, 0xdb, 0xc2, 0xea, 0x1c, 0x7c, 0x5b, 0xfe, 0xe3, + 0x0e, 0x98, 0x47, 0x1b, 0x2f, 0xa4, 0xff, 0x6a, 0x9d, 0x14, 0xc7, 0x91, 0x45, 0x83, 0x2f, 0x09, 0xb5, 0x78, 0x9d, + 0x13, 0x8a, 0x73, 0xac, 0x72, 0x30, 0x28, 0x61, 0xe7, 0x1d, 0x70, 0x82, 0x74, 0xfa, 0xf9, 0x21, 0xab, 0x37, 0x4c, + 0xf9, 0xf6, 0x36, 0x2a, 0xcc, 0x78, 0xfc, 0x3c, 0xdb, 0xce, 0x2f, 0xb0, 0xc0, 0x39, 0xd8, 0x32, 0x52, 0x45, 0xb8, + 0x45, 0x3d, 0xe2, 0x79, 0x7e, 0x81, 0x70, 0xb4, 0x58, 0x00, 0x38, 0x05, 0x5a, 0x2c, 0x0a, 0x1b, 0x9c, 0xf3, 0xfc, + 0x42, 0xb6, 0x39, 0x09, 0x28, 0x39, 0x91, 0xfa, 0xe6, 0x04, 0x74, 0xe5, 0x36, 0x71, 0x8b, 0x20, 0x08, 0x43, 0xb4, + 0xcd, 0xce, 0xf3, 0xed, 0xee, 0x85, 0x25, 0x4b, 0xce, 0xf3, 0x0b, 0x52, 0x94, 0xd1, 0xd6, 0xd6, 0x86, 0x89, 0xf0, + 0x7d, 0x04, 0x95, 0x01, 0x7f, 0xe6, 0x52, 0xdf, 0x05, 0x0d, 0xc2, 0x5a, 0xde, 0x2f, 0x56, 0x0b, 0xae, 0xb1, 0x6e, + 0xea, 0x35, 0xe2, 0xef, 0x55, 0x25, 0x4c, 0x25, 0x14, 0x65, 0x89, 0xaf, 0xe9, 0x52, 0x7a, 0xec, 0xfb, 0xf9, 0xba, + 0xa4, 0x23, 0xcf, 0xf3, 0x22, 0x3e, 0x92, 0xae, 0xe6, 0x42, 0x03, 0x2d, 0xa9, 0x72, 0x57, 0x01, 0x68, 0x0f, 0x79, + 0x5e, 0x8d, 0x72, 0x41, 0x14, 0xe0, 0x7a, 0x87, 0x41, 0xcb, 0x12, 0xdf, 0xfd, 0xb4, 0xe1, 0xf6, 0x56, 0x87, 0xf3, + 0x44, 0x3e, 0x1a, 0xa5, 0xeb, 0x30, 0x81, 0x37, 0x36, 0xa8, 0x22, 0x8b, 0x13, 0x98, 0xe9, 0xd5, 0xc3, 0x43, 0x5b, + 0x4c, 0xa7, 0x60, 0xa8, 0x0b, 0x2c, 0x00, 0xf6, 0x97, 0xad, 0x13, 0x36, 0x74, 0xdd, 0x25, 0x0a, 0x0d, 0x82, 0x13, + 0x64, 0xed, 0xee, 0x56, 0x25, 0xb4, 0x42, 0xcb, 0xd6, 0x16, 0xd8, 0xad, 0x60, 0xc6, 0x78, 0x71, 0x34, 0x15, 0x33, + 0x2e, 0xf3, 0x01, 0xcd, 0x6f, 0x28, 0x86, 0x43, 0x01, 0xb2, 0x0c, 0x7e, 0x40, 0xc1, 0x34, 0x2a, 0x0a, 0x76, 0xad, + 0xca, 0xf4, 0x6f, 0x38, 0x63, 0xa0, 0xa9, 0x2b, 0x53, 0x56, 0x11, 0x47, 0x7d, 0x43, 0x41, 0x4d, 0x62, 0x79, 0x71, + 0x4d, 0x33, 0xf1, 0x9a, 0x15, 0x82, 0x66, 0x94, 0x5b, 0x68, 0x52, 0x0c, 0x89, 0x30, 0x5b, 0x6a, 0x15, 0x25, 0xc9, + 0x83, 0x4d, 0x68, 0x53, 0x13, 0x8e, 0xa3, 0x2c, 0x49, 0xd5, 0x20, 0x72, 0x8d, 0x94, 0xc2, 0xaf, 0x6b, 0xd8, 0x59, + 0x16, 0xb5, 0x3e, 0xae, 0x12, 0x68, 0x8d, 0x54, 0x0a, 0x64, 0xb0, 0x2e, 0x68, 0x50, 0x3b, 0xa6, 0x96, 0x2c, 0xf1, + 0x9a, 0x03, 0x95, 0x25, 0xbe, 0xbd, 0x67, 0x17, 0x59, 0xe5, 0xe0, 0x2c, 0xc9, 0x45, 0xb9, 0x92, 0x4f, 0xee, 0x37, + 0xbc, 0xdf, 0x18, 0xa1, 0x69, 0x04, 0x65, 0xf6, 0x79, 0xf9, 0xad, 0xc8, 0x02, 0xcd, 0x0d, 0x25, 0x00, 0x5c, 0xa7, + 0x94, 0x5c, 0x41, 0x92, 0xfa, 0x4b, 0x31, 0x49, 0x97, 0x0e, 0x1f, 0xf4, 0x4f, 0x21, 0x68, 0xf5, 0x0d, 0x7e, 0x8d, + 0xb0, 0x5b, 0xd5, 0x59, 0x1b, 0x9c, 0xda, 0xf5, 0x76, 0xbd, 0x5d, 0x1d, 0x9c, 0x3a, 0x56, 0x0e, 0x74, 0x9c, 0x19, + 0x17, 0x3a, 0x27, 0x59, 0xa0, 0x23, 0xd9, 0xca, 0x68, 0x0c, 0x02, 0x81, 0x19, 0xe1, 0xca, 0x7e, 0x7d, 0x17, 0x71, + 0xb1, 0xb9, 0x24, 0x4d, 0x8d, 0xd9, 0xb3, 0xdc, 0x4c, 0x9e, 0x26, 0xb0, 0xdb, 0x11, 0xa6, 0x37, 0x91, 0xa2, 0x69, + 0x95, 0x9e, 0x81, 0x1e, 0x85, 0x23, 0x37, 0x26, 0x96, 0x1c, 0x04, 0xf3, 0xb2, 0xda, 0xc0, 0x31, 0xbd, 0xb9, 0x42, + 0x98, 0x95, 0xf8, 0x07, 0x3b, 0x96, 0xf6, 0x6c, 0x89, 0xfb, 0xee, 0x1e, 0xcb, 0xf8, 0x0a, 0xce, 0x2a, 0x6c, 0x08, + 0xd4, 0x21, 0x89, 0xa1, 0x34, 0xeb, 0xf5, 0x3c, 0x37, 0xf1, 0xf6, 0x7b, 0xd3, 0xde, 0x64, 0xe7, 0x6b, 0x02, 0xfc, + 0x7d, 0x7b, 0x31, 0x1b, 0x03, 0x2d, 0xa1, 0x87, 0x50, 0xcb, 0x79, 0x8a, 0xa9, 0x15, 0x50, 0x55, 0x86, 0x87, 0xd5, + 0x81, 0xab, 0xb3, 0xa4, 0x56, 0xa3, 0xcb, 0xcd, 0x01, 0xac, 0x6d, 0x9a, 0xc9, 0x68, 0xa9, 0x0a, 0x10, 0x56, 0x10, + 0x57, 0xc3, 0x58, 0x73, 0x3d, 0x06, 0x57, 0x82, 0xd5, 0x1f, 0xcc, 0x64, 0x0d, 0xa6, 0xd0, 0xda, 0xbc, 0x3b, 0x8d, + 0x88, 0xd5, 0x37, 0xf5, 0x00, 0x81, 0xd7, 0xb0, 0x90, 0x36, 0x3a, 0xe8, 0xbe, 0x6c, 0x39, 0xd5, 0xd9, 0xfa, 0x97, + 0xf7, 0xf7, 0xd7, 0x05, 0x62, 0x51, 0x88, 0x32, 0xbc, 0xf4, 0xa6, 0x2c, 0xfb, 0xcf, 0x14, 0xed, 0x69, 0x4b, 0x5f, + 0x1e, 0x12, 0x7c, 0xd6, 0x4c, 0xeb, 0xfe, 0xc1, 0xab, 0xdf, 0xbf, 0xbc, 0x4b, 0x78, 0x24, 0xa8, 0xe6, 0x26, 0x88, + 0xff, 0xbe, 0xae, 0xde, 0xf9, 0xcf, 0x4a, 0xc5, 0x2e, 0x37, 0x94, 0xd8, 0x6d, 0x96, 0x59, 0xf0, 0x86, 0xae, 0xb6, + 0xc3, 0xae, 0xdd, 0x62, 0x2d, 0x43, 0xee, 0x79, 0xbd, 0x2a, 0x5a, 0xfc, 0x2d, 0x51, 0x81, 0x3f, 0xc9, 0x90, 0x99, + 0xb5, 0x2d, 0x9c, 0x15, 0x22, 0x9f, 0xe8, 0x5e, 0x0a, 0x4f, 0x1d, 0x9b, 0x92, 0x8e, 0x2d, 0x1f, 0xce, 0xa5, 0x35, + 0x4e, 0x9b, 0x40, 0xdc, 0x76, 0x7e, 0x7f, 0x83, 0x12, 0x95, 0xf8, 0x8c, 0x7e, 0xf9, 0xf9, 0x9a, 0xc6, 0x89, 0x1a, + 0xfc, 0x02, 0x24, 0x07, 0x39, 0xb3, 0x85, 0xc7, 0xfc, 0x13, 0xcb, 0x12, 0x9f, 0x63, 0x93, 0x93, 0x0e, 0x07, 0x27, + 0x32, 0x1c, 0x59, 0x3c, 0xbb, 0xee, 0x80, 0x8d, 0xdc, 0xde, 0x30, 0xb9, 0xd1, 0x8a, 0x2c, 0x83, 0xf9, 0x33, 0x8d, + 0x60, 0xbb, 0x03, 0xc1, 0x3d, 0x93, 0x4e, 0x25, 0x5d, 0x8a, 0x61, 0x41, 0x85, 0xa0, 0x3c, 0x84, 0xb3, 0x28, 0x74, + 0xe9, 0x2c, 0x0a, 0x5d, 0x3a, 0x8b, 0xa2, 0xba, 0xc8, 0xb4, 0xf1, 0xa2, 0xdb, 0x47, 0xfa, 0xec, 0x49, 0xa8, 0x76, + 0x9f, 0xca, 0xa1, 0x5f, 0x92, 0xcc, 0x1c, 0xe0, 0x90, 0x4d, 0x2a, 0x33, 0x13, 0x20, 0xb7, 0x4f, 0x6f, 0x48, 0xdb, + 0xc8, 0x3a, 0xc0, 0x91, 0xad, 0x4d, 0x56, 0xe6, 0x98, 0x61, 0x0a, 0x7b, 0x0e, 0x38, 0xc5, 0xc1, 0x32, 0x26, 0x0f, + 0x83, 0xac, 0xf1, 0x8c, 0xc8, 0xa6, 0xc7, 0x2e, 0x37, 0x62, 0x51, 0x3a, 0x2b, 0x44, 0x59, 0x96, 0x90, 0xad, 0x68, + 0x4d, 0x76, 0x3d, 0xa8, 0xd5, 0x99, 0x47, 0x0b, 0x5e, 0x95, 0x0e, 0xd8, 0xff, 0x32, 0x10, 0xcb, 0x46, 0xec, 0xf6, + 0x43, 0x56, 0x28, 0x5a, 0xa7, 0x89, 0x93, 0xd0, 0x38, 0x97, 0x11, 0x7a, 0x27, 0xcd, 0x63, 0xe9, 0xa5, 0xf4, 0x9d, + 0x70, 0x9b, 0x23, 0xcb, 0x47, 0xfd, 0xb2, 0x76, 0x4f, 0x68, 0x9a, 0xb6, 0x76, 0xed, 0x3a, 0x59, 0x20, 0x78, 0xa1, + 0x73, 0x0d, 0x91, 0xef, 0x2e, 0xeb, 0x22, 0xb1, 0x9a, 0xc4, 0x5c, 0x09, 0xd8, 0x46, 0x02, 0xd4, 0xea, 0x79, 0x09, + 0x84, 0x79, 0xa0, 0x29, 0xe0, 0xbe, 0x23, 0x85, 0x12, 0x24, 0x93, 0x18, 0x8f, 0x4c, 0x42, 0x60, 0x05, 0xfc, 0x07, + 0xcb, 0xb7, 0xf2, 0xd2, 0x9d, 0x43, 0x44, 0x0b, 0xcb, 0x93, 0x52, 0xc0, 0x2f, 0x16, 0xf3, 0x74, 0x4b, 0x15, 0x8c, + 0x7e, 0x6e, 0xe9, 0x52, 0x95, 0x1d, 0x5b, 0x1d, 0xd0, 0x01, 0x61, 0x93, 0x79, 0xf5, 0x11, 0x1d, 0x78, 0x7e, 0xaf, + 0x38, 0xcb, 0xd3, 0x68, 0xa4, 0x55, 0xd2, 0x84, 0xb0, 0x13, 0x29, 0xf4, 0x14, 0x9a, 0xc7, 0x24, 0xf5, 0x30, 0xe0, + 0x9e, 0xa8, 0xa0, 0x7d, 0xab, 0xa3, 0xf1, 0x1a, 0xdb, 0xca, 0xce, 0xd4, 0x88, 0x84, 0x18, 0xf8, 0x40, 0xd8, 0x09, + 0x6a, 0xde, 0xf7, 0x33, 0xca, 0xef, 0x4e, 0x29, 0x40, 0x00, 0xa6, 0x0d, 0xd2, 0xfa, 0x5a, 0x1e, 0x74, 0xad, 0x8e, + 0x3f, 0x51, 0x79, 0xfc, 0x49, 0x94, 0xc6, 0xd7, 0xc2, 0xad, 0x55, 0xcb, 0x7c, 0x16, 0x04, 0x4a, 0xd4, 0x28, 0x8d, + 0x68, 0xce, 0x69, 0x59, 0x87, 0x9d, 0x96, 0x0e, 0x47, 0x51, 0x7d, 0x38, 0x4a, 0x3b, 0xe3, 0x65, 0x8a, 0x5b, 0x59, + 0x96, 0xa8, 0xd6, 0x9a, 0xcf, 0xa9, 0x04, 0x5c, 0xb7, 0x35, 0x21, 0x7d, 0x8b, 0xc5, 0x4c, 0x58, 0xa4, 0xe1, 0xd7, + 0x21, 0x91, 0x7a, 0x8b, 0xdd, 0x6c, 0xa3, 0x4a, 0x4a, 0x69, 0x2a, 0x4c, 0x04, 0xa7, 0x30, 0x6c, 0xb2, 0x47, 0x10, + 0x4c, 0xa9, 0x8c, 0x8c, 0xe6, 0xb8, 0xf5, 0x61, 0x55, 0xe8, 0x15, 0xaa, 0xc9, 0xf5, 0xfd, 0x1d, 0xc9, 0x43, 0x1f, + 0x8c, 0x85, 0x79, 0x9c, 0xa7, 0x39, 0x6f, 0x43, 0xa6, 0xe1, 0x84, 0xfa, 0x29, 0x1b, 0x8d, 0x85, 0x93, 0x44, 0xfc, + 0x53, 0xbf, 0xdd, 0x9e, 0x72, 0x36, 0x89, 0xf8, 0x5d, 0x5b, 0xd6, 0xf0, 0xbf, 0xea, 0xec, 0x46, 0x5f, 0x0f, 0xf7, + 0xfa, 0xc3, 0x3c, 0x13, 0xed, 0x61, 0x34, 0x61, 0xe9, 0x9d, 0x3f, 0x63, 0xed, 0x49, 0x9e, 0xe5, 0xc5, 0x34, 0x8a, + 0x29, 0x2e, 0xee, 0x0a, 0x41, 0x27, 0xed, 0x19, 0xc3, 0x2f, 0x69, 0x7a, 0x4d, 0x05, 0x8b, 0x23, 0x7c, 0xc4, 0x59, + 0x94, 0x3a, 0x27, 0x11, 0xe7, 0xf9, 0x0d, 0x7e, 0x9f, 0x5f, 0xe5, 0x22, 0xc7, 0x6f, 0x6f, 0xef, 0x46, 0x34, 0xc3, + 0x1f, 0xae, 0x66, 0x99, 0x98, 0xe1, 0x22, 0xca, 0x8a, 0x76, 0x41, 0x39, 0x1b, 0xf6, 0x05, 0x8f, 0xb2, 0x82, 0x49, + 0xde, 0x8b, 0xd2, 0xd4, 0xf1, 0x76, 0xf7, 0x8b, 0x0d, 0x15, 0x21, 0x88, 0x32, 0x51, 0x86, 0xf8, 0x13, 0x25, 0x79, + 0x78, 0x35, 0x13, 0x22, 0xcf, 0xb0, 0x77, 0x25, 0xb2, 0x79, 0x3c, 0xe3, 0x45, 0xce, 0xfd, 0x69, 0xce, 0x32, 0x48, + 0x27, 0x06, 0xd5, 0x3a, 0xe2, 0xf9, 0x2c, 0x4b, 0x34, 0xc8, 0x2c, 0x1b, 0x53, 0xce, 0x44, 0xbf, 0xf9, 0x64, 0x55, + 0x93, 0xf7, 0x11, 0xf8, 0x29, 0xcb, 0x68, 0xc4, 0xdb, 0x23, 0x1e, 0x25, 0x0c, 0xac, 0xe6, 0xaf, 0x9e, 0x0e, 0xe1, + 0xbf, 0x83, 0x8e, 0xd3, 0xf9, 0xb9, 0xd3, 0xed, 0x74, 0x7e, 0x8e, 0xfa, 0x57, 0x39, 0x4f, 0x28, 0xf7, 0xbb, 0xd3, + 0x5b, 0xa7, 0xc8, 0x21, 0xdf, 0xa3, 0xaa, 0xa3, 0x5f, 0xb5, 0xa1, 0xf1, 0xac, 0xf0, 0xf7, 0xa6, 0xb7, 0xfd, 0x69, + 0x94, 0x40, 0x32, 0x9b, 0xdf, 0x9b, 0xde, 0x96, 0x0a, 0x5c, 0x5f, 0x65, 0x59, 0x49, 0xa8, 0xf5, 0xef, 0xf9, 0x63, + 0xc1, 0xd8, 0xdd, 0x75, 0x3a, 0x3f, 0xc7, 0xfa, 0x21, 0x8e, 0x35, 0x40, 0x35, 0xae, 0xda, 0xc9, 0x8c, 0x2b, 0x81, + 0xd5, 0x2d, 0xcc, 0x70, 0xe3, 0xfc, 0x9a, 0x72, 0x35, 0x9a, 0xfc, 0xf9, 0xe8, 0xc1, 0xe2, 0xd8, 0x1a, 0x6c, 0x77, + 0xf7, 0xe1, 0xc1, 0x3c, 0x9e, 0x25, 0xf3, 0xe6, 0xf4, 0xbb, 0x9c, 0x4e, 0xfa, 0x37, 0x2c, 0x11, 0x63, 0xbf, 0x07, + 0x3f, 0xc7, 0x14, 0x08, 0x4a, 0xfd, 0x96, 0x84, 0x03, 0x59, 0x9c, 0x7e, 0xd7, 0xab, 0x0b, 0x6e, 0x54, 0x8d, 0xfd, + 0x4e, 0xa7, 0x0c, 0x6b, 0x01, 0xf0, 0x37, 0x75, 0x60, 0x00, 0xa8, 0x95, 0x91, 0xca, 0xec, 0x35, 0x89, 0x1a, 0x11, + 0x61, 0x87, 0xbb, 0x81, 0xf0, 0xb9, 0x39, 0xce, 0xcb, 0xc9, 0xa3, 0x24, 0x24, 0xc7, 0xb9, 0x75, 0xec, 0x5e, 0xcb, + 0x2d, 0xb2, 0x9a, 0xed, 0xb5, 0x2c, 0xd1, 0xec, 0x0d, 0x1a, 0x8a, 0xc8, 0xf2, 0xeb, 0x0a, 0xde, 0xfa, 0x40, 0x3c, + 0x00, 0x5e, 0xd8, 0xf1, 0xe6, 0x62, 0x40, 0x3a, 0xfd, 0xa2, 0xdd, 0x46, 0x6e, 0x4e, 0xe8, 0x79, 0x21, 0xf3, 0x5b, + 0x22, 0xe2, 0xc2, 0x3c, 0x72, 0x37, 0x42, 0x3e, 0x1b, 0xc0, 0x0f, 0xe8, 0x26, 0x42, 0xbe, 0xfc, 0x81, 0xd0, 0x62, + 0x11, 0xd5, 0x39, 0x44, 0x83, 0xdd, 0xad, 0xad, 0xe8, 0x3e, 0x31, 0xaa, 0xda, 0xe1, 0xa8, 0x96, 0xf9, 0xbf, 0xa9, + 0x0c, 0xfc, 0x1b, 0x96, 0x25, 0xf9, 0x8d, 0x67, 0x54, 0x9b, 0x37, 0x8d, 0xc4, 0x18, 0x94, 0x6c, 0x95, 0x8e, 0x5c, + 0xa7, 0x15, 0x84, 0x3b, 0x21, 0x0a, 0x68, 0x95, 0x5b, 0x02, 0x19, 0x34, 0x54, 0x4a, 0x8c, 0x23, 0x4a, 0x7e, 0xe3, + 0x5a, 0x32, 0xfa, 0xa3, 0x95, 0x43, 0xe9, 0x80, 0x6f, 0x3e, 0x4e, 0x67, 0x09, 0x2d, 0x64, 0x07, 0x35, 0x0c, 0x6f, + 0xec, 0x5a, 0xb2, 0x09, 0x74, 0x2e, 0xc3, 0xf1, 0x50, 0x11, 0x6e, 0x51, 0xa8, 0x9e, 0xdb, 0xf2, 0xb9, 0x6e, 0x7b, + 0x52, 0xe7, 0x64, 0x41, 0x4b, 0x6f, 0x96, 0xb1, 0xef, 0x67, 0xf4, 0x92, 0x25, 0xd5, 0xd9, 0x36, 0x9a, 0xc5, 0x79, + 0x42, 0x3f, 0xbc, 0x7f, 0x05, 0x69, 0x9f, 0x79, 0x26, 0xb7, 0xbc, 0xca, 0xcd, 0x03, 0x6e, 0x04, 0x2f, 0xa1, 0xd7, + 0x2c, 0xa6, 0x41, 0xb8, 0x39, 0x5f, 0x5b, 0x51, 0xbd, 0x46, 0xe5, 0x8e, 0xcc, 0xb6, 0x51, 0x30, 0x86, 0x9b, 0xf3, + 0x23, 0x5a, 0xee, 0x6c, 0xce, 0xa9, 0x97, 0xe4, 0x93, 0x88, 0x65, 0xf0, 0x9b, 0x97, 0x9b, 0x73, 0xf9, 0x43, 0x94, + 0x61, 0x69, 0x04, 0x79, 0x05, 0x8d, 0x05, 0xbe, 0x46, 0x5b, 0x17, 0x79, 0x1f, 0x73, 0x96, 0xc9, 0xa2, 0x87, 0xfa, + 0xad, 0xfa, 0x04, 0xfc, 0x7e, 0xbf, 0xb4, 0x03, 0x7c, 0xd6, 0xd8, 0x01, 0x82, 0xc2, 0xb6, 0x76, 0x81, 0xb4, 0x3a, + 0xf9, 0x23, 0x98, 0x3c, 0x46, 0x6a, 0xfc, 0xde, 0xe3, 0xa8, 0xb8, 0x8c, 0xd5, 0x19, 0xad, 0xa2, 0xce, 0x13, 0x8e, + 0x24, 0x42, 0xd5, 0xd6, 0x8e, 0x2a, 0xcf, 0xf6, 0xbb, 0xf5, 0x27, 0x8f, 0xee, 0xdf, 0x01, 0x69, 0x1a, 0x2a, 0xf2, + 0x19, 0x8f, 0x69, 0xb0, 0xea, 0xfe, 0x08, 0xa5, 0x39, 0x11, 0xe2, 0xfa, 0x3e, 0x05, 0xfb, 0xb8, 0xbc, 0x0c, 0x9a, + 0x40, 0x00, 0x41, 0xc8, 0xf5, 0xb9, 0x64, 0xc9, 0x62, 0x21, 0x3c, 0x96, 0x98, 0xc3, 0x3b, 0x66, 0x22, 0xb0, 0xa7, + 0x49, 0x64, 0x5a, 0x96, 0x4a, 0x4d, 0xae, 0xb0, 0x0c, 0x6c, 0xae, 0x0e, 0xb7, 0x40, 0x4a, 0x53, 0x77, 0x6b, 0x2b, + 0xab, 0x22, 0x75, 0x1a, 0xa3, 0x8b, 0xc5, 0x1b, 0x0a, 0xf1, 0x07, 0x4e, 0xc0, 0xbc, 0x11, 0x58, 0x95, 0xfa, 0x14, + 0x57, 0x7d, 0xf8, 0x59, 0xd9, 0xe7, 0x12, 0x45, 0x0a, 0x21, 0xc4, 0xa0, 0xec, 0x48, 0x59, 0x97, 0x1c, 0x2e, 0x98, + 0xa8, 0x5f, 0x1b, 0x5f, 0x69, 0x13, 0xa7, 0x9d, 0x25, 0xd4, 0xeb, 0x70, 0xc1, 0x72, 0x69, 0x91, 0x73, 0xe1, 0x9a, + 0x1b, 0x14, 0xe4, 0x9c, 0x0f, 0xd5, 0xd4, 0x83, 0x76, 0xd7, 0xef, 0xae, 0xb5, 0x54, 0x75, 0x62, 0x8c, 0x39, 0xc5, + 0x06, 0xd8, 0xa9, 0x7e, 0x6b, 0xa4, 0xd5, 0x05, 0x6a, 0x76, 0xf5, 0x73, 0x35, 0x49, 0xac, 0xc5, 0x03, 0x38, 0xc0, + 0x46, 0x99, 0xdb, 0x80, 0x0a, 0xf2, 0x24, 0xd6, 0x9f, 0xc4, 0x86, 0x8d, 0x54, 0x8d, 0x88, 0x8a, 0x65, 0x43, 0x65, + 0x66, 0x5d, 0x5a, 0x74, 0x0b, 0x77, 0xe0, 0xac, 0xa3, 0xaa, 0x52, 0xa3, 0x68, 0x25, 0x88, 0xd7, 0xac, 0xa6, 0x60, + 0xb9, 0xab, 0x02, 0x07, 0x4b, 0x6f, 0xd5, 0x23, 0x55, 0x54, 0xb1, 0xbe, 0x8a, 0x4c, 0x5c, 0x5a, 0x07, 0x18, 0x58, + 0x40, 0x85, 0x30, 0x53, 0x90, 0xf1, 0x11, 0x0a, 0x99, 0xf3, 0x5a, 0x8e, 0xe0, 0xf9, 0x84, 0x8a, 0x71, 0x9e, 0xf8, + 0xe1, 0xbb, 0xb7, 0xa7, 0x67, 0x21, 0x86, 0xab, 0x8a, 0x28, 0x2f, 0xfc, 0x79, 0x4b, 0xa7, 0xfe, 0xb4, 0x21, 0x24, + 0xd7, 0xf2, 0xc3, 0x68, 0x3a, 0x4d, 0x99, 0x92, 0x94, 0x3b, 0xb7, 0xed, 0x9b, 0x9b, 0x9b, 0x36, 0x9c, 0xab, 0x68, + 0xcf, 0x78, 0xaa, 0xc4, 0x48, 0x12, 0x96, 0x25, 0xf2, 0xc4, 0x98, 0x66, 0xf2, 0xf2, 0x10, 0x60, 0xd3, 0x3c, 0xa5, + 0x5e, 0x9a, 0xc3, 0xe1, 0xb9, 0x72, 0x75, 0xff, 0xfe, 0x31, 0x3c, 0x94, 0x97, 0xf4, 0x0c, 0x0e, 0x85, 0xba, 0x1e, + 0x49, 0x70, 0xf8, 0x39, 0x80, 0xd0, 0xc7, 0xe1, 0x8e, 0x18, 0xcb, 0x87, 0x53, 0xe0, 0x1e, 0xf9, 0xb4, 0x39, 0x5f, + 0xa1, 0xba, 0x00, 0xba, 0x18, 0x0f, 0xd4, 0xd4, 0x0a, 0x59, 0x2b, 0xf4, 0x3f, 0x86, 0x61, 0x79, 0xb8, 0x03, 0x7d, + 0xed, 0x98, 0x7e, 0xaf, 0xf2, 0xe4, 0xce, 0xb4, 0xaf, 0x28, 0x51, 0xdf, 0xe9, 0x02, 0x5d, 0xc0, 0xb8, 0xc9, 0x40, + 0xe2, 0x4c, 0x8b, 0xc6, 0xf3, 0xfa, 0xa1, 0xbc, 0x90, 0x69, 0x87, 0x25, 0x94, 0x00, 0xb9, 0x41, 0xe7, 0x49, 0xd5, + 0x40, 0x72, 0xb7, 0x2a, 0xba, 0x0f, 0x40, 0x55, 0xb1, 0xe6, 0x1f, 0xe5, 0xa4, 0xac, 0xc9, 0xc2, 0x40, 0x9c, 0xd8, + 0xc0, 0x87, 0x08, 0xfe, 0x95, 0x80, 0x1f, 0xee, 0x28, 0x34, 0x85, 0xf6, 0xed, 0x11, 0xea, 0x0c, 0x74, 0x85, 0xcc, + 0xf3, 0xdf, 0xe1, 0x4f, 0x14, 0xe7, 0xa1, 0xac, 0x69, 0x8c, 0x0f, 0xb0, 0x3f, 0xc1, 0xe0, 0xaa, 0x8c, 0xb1, 0x38, + 0x4f, 0xd3, 0x68, 0x5a, 0x50, 0xdf, 0xfc, 0x58, 0xb5, 0x0d, 0xaf, 0x23, 0xee, 0xb6, 0xdb, 0x71, 0xfb, 0x6a, 0xb4, + 0x6a, 0xdd, 0x69, 0x0b, 0x06, 0x8c, 0x9f, 0x52, 0x8c, 0xe7, 0x90, 0x1d, 0xd6, 0x8e, 0x52, 0x36, 0xca, 0xfc, 0x94, + 0x0e, 0x45, 0xc3, 0x6e, 0x79, 0xd2, 0xe9, 0x94, 0x62, 0x8c, 0x85, 0x31, 0x84, 0xac, 0x4e, 0x8c, 0x19, 0xe8, 0xf5, + 0xf6, 0x39, 0x9d, 0x38, 0x1e, 0xfc, 0x2d, 0x45, 0xe2, 0x67, 0x62, 0xdc, 0x96, 0xc9, 0x84, 0x6e, 0x0f, 0x58, 0xb1, + 0xf1, 0x6c, 0x8f, 0x15, 0x53, 0xb0, 0x6a, 0x4b, 0xc1, 0x1d, 0x18, 0x80, 0xdb, 0xf5, 0x32, 0x34, 0x5f, 0x99, 0x90, + 0x36, 0xda, 0xf6, 0x92, 0xb2, 0x90, 0x3b, 0xa1, 0xf9, 0xaa, 0x61, 0x6a, 0x4d, 0x8b, 0x65, 0xd3, 0x99, 0x38, 0x97, + 0xae, 0x5e, 0x0e, 0x6e, 0x90, 0x0b, 0x6c, 0x95, 0x00, 0x10, 0x17, 0x73, 0x55, 0x3b, 0x8e, 0xd2, 0xd8, 0x85, 0x26, + 0x4e, 0xdb, 0x39, 0xe0, 0x74, 0x82, 0xfa, 0x13, 0x96, 0xb5, 0xd5, 0xbb, 0x7d, 0xcb, 0xc4, 0xf3, 0x9e, 0xca, 0xf9, + 0x79, 0xb2, 0x37, 0x2c, 0x33, 0xea, 0xd6, 0x4c, 0x26, 0xbc, 0x28, 0xcb, 0xfe, 0xdf, 0xb8, 0xe7, 0x1f, 0x5c, 0x74, + 0x81, 0xbf, 0xb7, 0xae, 0xa0, 0x08, 0x0d, 0xb9, 0x9a, 0x3b, 0x98, 0x10, 0x5e, 0x5b, 0xcd, 0x26, 0xba, 0xba, 0xea, + 0xf7, 0xe4, 0x6f, 0xdc, 0xf3, 0x6f, 0xdd, 0x90, 0x16, 0xd3, 0xb6, 0x92, 0x2f, 0x6d, 0x49, 0x20, 0x21, 0x34, 0x57, + 0xbe, 0xa8, 0x77, 0xc6, 0x0b, 0x2e, 0xc5, 0x07, 0xad, 0x8f, 0x47, 0x9d, 0xd3, 0x8b, 0x2a, 0x63, 0x5f, 0x3f, 0xdb, + 0x89, 0xfe, 0xa8, 0xc1, 0xdf, 0xe1, 0x51, 0x53, 0x16, 0x6d, 0xce, 0x69, 0x59, 0x5d, 0xc8, 0x15, 0xa5, 0xa9, 0x1a, + 0x54, 0xeb, 0xfc, 0xb2, 0xb9, 0x5f, 0x84, 0x33, 0xe4, 0x8a, 0x31, 0x9e, 0x49, 0x2b, 0xdd, 0xf8, 0xe0, 0x01, 0x10, + 0x6a, 0x47, 0x43, 0x38, 0xc9, 0x40, 0x39, 0x36, 0x8e, 0xbc, 0xf7, 0x6b, 0x59, 0xa2, 0x6c, 0x7c, 0x47, 0xce, 0x86, + 0xb4, 0x78, 0x96, 0xb4, 0x9c, 0x5f, 0xc5, 0x29, 0x8b, 0x3f, 0x91, 0xcd, 0x39, 0x6c, 0x61, 0x25, 0xd7, 0x19, 0x39, + 0x0a, 0x8e, 0x6c, 0x4b, 0x26, 0x72, 0x54, 0x02, 0xfb, 0x96, 0x87, 0x3b, 0xaa, 0x97, 0x41, 0x58, 0x5e, 0xea, 0x6b, + 0x74, 0xa8, 0x2d, 0xaf, 0x00, 0x91, 0xaa, 0xdc, 0x91, 0xd4, 0x45, 0x5a, 0x8a, 0x5f, 0x1a, 0x5b, 0x42, 0xac, 0xb3, + 0x91, 0x8e, 0xe1, 0x01, 0xb5, 0x1c, 0x25, 0x23, 0x48, 0x2d, 0x2d, 0x9c, 0x5f, 0xa9, 0x92, 0xd6, 0xe6, 0x5c, 0x54, + 0x59, 0xed, 0x21, 0x8c, 0x71, 0x19, 0x6e, 0x83, 0x01, 0x2b, 0x22, 0x96, 0xaa, 0xba, 0xfd, 0x87, 0xa0, 0xce, 0x9a, + 0xb8, 0x40, 0x65, 0xd9, 0x1a, 0x1c, 0xee, 0xd4, 0x30, 0xca, 0x59, 0x48, 0xa2, 0xb7, 0xe3, 0x54, 0xf5, 0x6c, 0xd4, + 0x3b, 0xe7, 0x57, 0xb1, 0xf4, 0xf8, 0x01, 0x38, 0x5c, 0x83, 0x03, 0xc1, 0x00, 0x11, 0xf1, 0x11, 0x15, 0x81, 0xca, + 0xc0, 0x7b, 0x10, 0x8e, 0x10, 0x50, 0x17, 0x80, 0xdd, 0x46, 0xd6, 0x9a, 0x94, 0x0c, 0x81, 0x12, 0x2a, 0x5b, 0x83, + 0xcd, 0x39, 0xb7, 0xc4, 0xae, 0x8a, 0x93, 0x38, 0xb2, 0x7f, 0x18, 0x9c, 0x96, 0x2d, 0x27, 0x50, 0x30, 0xd1, 0x44, + 0x16, 0x10, 0xc2, 0x64, 0x2b, 0x10, 0xb0, 0xaa, 0xb6, 0x92, 0x8b, 0xaa, 0x12, 0x4c, 0x4f, 0xb2, 0x55, 0x3d, 0x3b, + 0x1c, 0xe1, 0xdc, 0x9e, 0x61, 0xc2, 0xae, 0x2b, 0x82, 0x80, 0x9a, 0xad, 0xc1, 0x61, 0x1a, 0x5d, 0xd1, 0x74, 0xb0, + 0x39, 0x67, 0x8b, 0x45, 0xa7, 0x3c, 0xdc, 0x51, 0x8f, 0xce, 0xa1, 0x64, 0x73, 0x75, 0xc9, 0x1e, 0x8c, 0xec, 0xc1, + 0x39, 0x23, 0xc8, 0x74, 0x33, 0x79, 0x27, 0x7e, 0x28, 0x3b, 0x08, 0xcb, 0x96, 0x23, 0x03, 0xe4, 0xb2, 0x52, 0x65, + 0x5c, 0x94, 0x2d, 0x87, 0x25, 0xab, 0x65, 0x85, 0xa0, 0x53, 0x28, 0xcd, 0x17, 0x8b, 0x6e, 0xd9, 0x72, 0x26, 0x2c, + 0x83, 0x27, 0xb6, 0x58, 0xc8, 0xd3, 0x3b, 0x13, 0x96, 0xb9, 0x1d, 0x20, 0xbd, 0x96, 0x33, 0x89, 0x6e, 0xe1, 0x4d, + 0x64, 0xde, 0x44, 0xb7, 0x6e, 0x57, 0xbf, 0xf2, 0x2a, 0xfc, 0xf0, 0xb2, 0xf5, 0x17, 0x5e, 0x2b, 0xa6, 0xd7, 0xc5, + 0xa9, 0xb0, 0x12, 0x2d, 0x16, 0xdd, 0x4e, 0x8d, 0x97, 0xc3, 0x9d, 0x84, 0x5d, 0x03, 0x9e, 0xc1, 0x18, 0x12, 0x6c, + 0x42, 0xd7, 0x13, 0x52, 0x13, 0x79, 0xe2, 0x8b, 0x70, 0x54, 0xcf, 0x8f, 0x35, 0xe7, 0x27, 0xaa, 0xf9, 0x89, 0x2f, + 0x9b, 0x5f, 0x06, 0xf3, 0xe3, 0x72, 0x7e, 0x26, 0x5d, 0xdd, 0x0d, 0xcf, 0x42, 0x1c, 0x3a, 0xa1, 0x21, 0xc4, 0xb0, + 0xbc, 0x04, 0x21, 0x2c, 0xe1, 0x7e, 0x14, 0xf5, 0x40, 0xed, 0xd6, 0xe0, 0x7e, 0x2a, 0x81, 0xb8, 0xea, 0x4d, 0xce, + 0x93, 0xd0, 0x0f, 0xa1, 0xea, 0x97, 0x91, 0xc9, 0x84, 0x65, 0x3a, 0xb7, 0xe5, 0x5e, 0xea, 0xa8, 0xdf, 0xdb, 0x34, + 0xd2, 0xdb, 0xdf, 0x57, 0x35, 0xa6, 0x11, 0xb8, 0x89, 0x33, 0x4d, 0x6b, 0x61, 0xf8, 0x57, 0xa6, 0x9b, 0x87, 0x78, + 0xdc, 0x90, 0x8c, 0x36, 0x44, 0xb5, 0x14, 0xad, 0x4f, 0xd0, 0x2a, 0x3d, 0x84, 0x6c, 0x53, 0x58, 0x15, 0x81, 0x65, + 0x3e, 0x9b, 0xd0, 0xe4, 0x52, 0x0a, 0xbe, 0xe0, 0x63, 0xa8, 0xed, 0xa9, 0xa6, 0x72, 0xb0, 0x1a, 0xe0, 0xf0, 0xcf, + 0xff, 0xf4, 0x77, 0x21, 0x56, 0x82, 0x33, 0x1f, 0x0e, 0x43, 0x54, 0x3a, 0x8f, 0x68, 0xf3, 0x3f, 0xff, 0xe1, 0x7f, + 0xff, 0xeb, 0xdf, 0x57, 0xcd, 0x32, 0xa0, 0x09, 0x1d, 0x26, 0x36, 0x17, 0xa7, 0x59, 0x60, 0x9a, 0x69, 0x0c, 0xa3, + 0xec, 0xbe, 0x39, 0x9c, 0xdb, 0x73, 0x28, 0xa6, 0x94, 0x26, 0x40, 0x69, 0x78, 0xa5, 0xf4, 0x32, 0xa5, 0xd7, 0xd4, + 0xdc, 0x9d, 0xb2, 0x66, 0xa8, 0x35, 0x2d, 0xe2, 0x7c, 0x96, 0x09, 0x1d, 0xf6, 0x56, 0x92, 0xae, 0x31, 0x15, 0x39, + 0x03, 0xdb, 0xac, 0xbd, 0x53, 0x4a, 0xa3, 0xa9, 0x16, 0xca, 0x10, 0x87, 0x16, 0x00, 0xf7, 0x42, 0x16, 0xdc, 0x53, + 0xee, 0x77, 0x70, 0xe7, 0x3e, 0xd8, 0x70, 0x17, 0xf9, 0x61, 0x78, 0x61, 0xb0, 0x24, 0xdd, 0xa4, 0x0f, 0xe3, 0xe9, + 0xb3, 0x33, 0xbf, 0xe2, 0xd0, 0x49, 0x46, 0x8b, 0xe2, 0x33, 0x13, 0x87, 0x93, 0x82, 0x61, 0x5d, 0x3b, 0xbc, 0xa7, + 0x17, 0xdc, 0xc1, 0xc0, 0x26, 0x12, 0xd0, 0x46, 0x15, 0xa9, 0xab, 0x2f, 0x21, 0x1d, 0xff, 0x31, 0x03, 0xd5, 0xb5, + 0xef, 0xeb, 0x05, 0x77, 0xf7, 0xf7, 0xf0, 0xee, 0xd3, 0xce, 0x9a, 0xa1, 0xe8, 0x70, 0x48, 0x63, 0x51, 0x04, 0x90, + 0xfb, 0x24, 0x20, 0x49, 0x84, 0x0c, 0xe0, 0xd4, 0xe4, 0x49, 0x9e, 0xd1, 0x10, 0x99, 0x04, 0x3b, 0x8d, 0x1e, 0xa5, + 0xaf, 0xef, 0x81, 0x42, 0x75, 0xb4, 0xb6, 0xf3, 0xc5, 0xc2, 0xf8, 0x3a, 0x1a, 0xe5, 0xcd, 0xf5, 0xc9, 0xa5, 0x33, + 0x63, 0x3d, 0x2b, 0x3e, 0x86, 0xe1, 0xfe, 0xfd, 0x9f, 0xff, 0xe1, 0xbf, 0x86, 0x38, 0x84, 0x7e, 0x1e, 0xc7, 0x6d, + 0xff, 0xfe, 0xcf, 0xff, 0xf0, 0x3f, 0x42, 0x1c, 0xce, 0xb2, 0xc7, 0x37, 0xf9, 0xf3, 0x7f, 0xf9, 0x6f, 0x21, 0x56, + 0x27, 0x7c, 0x51, 0x59, 0xc9, 0x91, 0x18, 0xfc, 0xb5, 0x3f, 0x09, 0xf6, 0x46, 0xbf, 0x8f, 0x81, 0xe3, 0x1f, 0x61, + 0xaa, 0x85, 0xc8, 0xa7, 0x8f, 0x85, 0x1b, 0x66, 0x1a, 0xa7, 0x79, 0x41, 0x6d, 0xc0, 0x95, 0x41, 0xf9, 0xd3, 0x20, + 0x97, 0x90, 0x4c, 0x39, 0x2d, 0x0a, 0xc7, 0xee, 0x5a, 0xd3, 0xca, 0x83, 0xb2, 0x75, 0x2d, 0x41, 0x15, 0x54, 0x48, + 0x54, 0xa8, 0xe3, 0xb6, 0x36, 0xd1, 0xa8, 0xb2, 0x15, 0x5a, 0x92, 0xfa, 0xa1, 0x12, 0x86, 0xca, 0x24, 0xfa, 0xcc, + 0xb8, 0x6b, 0xb8, 0x49, 0x0d, 0x2b, 0xfb, 0x0a, 0x57, 0xbb, 0x6f, 0x94, 0x4c, 0x58, 0x76, 0xb9, 0xa6, 0x34, 0xba, + 0x5d, 0x53, 0x0a, 0x56, 0x56, 0x05, 0x5b, 0x7d, 0xc9, 0xc3, 0x83, 0xc8, 0xae, 0xec, 0x99, 0x06, 0x80, 0x89, 0xf4, + 0xd4, 0x7d, 0x06, 0x4e, 0x6b, 0x01, 0x64, 0x0f, 0x3f, 0x76, 0x30, 0x28, 0xf9, 0x92, 0xc1, 0xaa, 0x5e, 0x7e, 0xca, + 0xec, 0xa0, 0xb4, 0x0d, 0xfe, 0xee, 0xf4, 0x8b, 0xe6, 0x49, 0x6f, 0x3f, 0x47, 0x66, 0xb5, 0x39, 0xf5, 0x53, 0x96, + 0x5c, 0x07, 0x31, 0x96, 0xd7, 0x7c, 0x4d, 0xb1, 0xb6, 0x78, 0xaa, 0x75, 0x8f, 0x53, 0x36, 0x59, 0xba, 0xdf, 0xa3, + 0x01, 0xa6, 0xba, 0xa3, 0x10, 0xeb, 0xeb, 0x36, 0x74, 0x27, 0xca, 0xfc, 0x91, 0xd2, 0x1b, 0xce, 0xa1, 0xcf, 0x38, + 0xbd, 0x4c, 0xf3, 0x9b, 0xe5, 0xf8, 0xfc, 0xfd, 0x95, 0xc7, 0x6c, 0x34, 0xae, 0x6a, 0x07, 0xae, 0x20, 0xd5, 0x12, + 0x3c, 0x38, 0x40, 0xf9, 0x6f, 0xff, 0xe2, 0x79, 0xff, 0xf6, 0x2f, 0x9f, 0xad, 0x0a, 0xdd, 0x97, 0xe0, 0x39, 0xae, + 0x57, 0xf6, 0x5e, 0xae, 0x5a, 0x3f, 0x52, 0x13, 0xe7, 0xeb, 0xeb, 0xac, 0x2c, 0x82, 0x54, 0x66, 0xcb, 0x4b, 0xb0, + 0x52, 0xa8, 0xb8, 0xce, 0xf9, 0x31, 0x80, 0xc1, 0xbc, 0x3e, 0x0b, 0x19, 0x54, 0xfa, 0x49, 0xa0, 0x85, 0xc8, 0x7f, + 0xd4, 0x8a, 0xfc, 0x78, 0x0c, 0x7f, 0x6e, 0x0e, 0x3f, 0x11, 0x7c, 0x9d, 0x02, 0xfa, 0xb1, 0x0a, 0xc2, 0xb8, 0x8d, + 0xa6, 0x70, 0xe4, 0x36, 0x58, 0x29, 0xd1, 0xd6, 0x84, 0xdf, 0x41, 0x03, 0x15, 0x37, 0xff, 0x18, 0xbe, 0x81, 0x2b, + 0x33, 0x0e, 0xaf, 0xb8, 0x71, 0x50, 0x3e, 0xa0, 0x12, 0xa0, 0x8b, 0xe6, 0xac, 0x64, 0xa7, 0x2b, 0xfa, 0x00, 0x4a, + 0x61, 0x9f, 0x01, 0x60, 0xe2, 0x8f, 0xa1, 0xde, 0x3e, 0x1e, 0x2b, 0xbf, 0x87, 0xbf, 0x4c, 0xda, 0xda, 0x1f, 0xd2, + 0x40, 0x3a, 0x76, 0xce, 0x24, 0xbe, 0x54, 0xe5, 0x7a, 0x23, 0x2e, 0x3d, 0x47, 0xb0, 0xcd, 0xa8, 0x84, 0xcf, 0x75, + 0x94, 0x5e, 0x3f, 0x46, 0xe8, 0xdd, 0xaf, 0x3f, 0x17, 0xce, 0xe2, 0xaf, 0xaa, 0xf9, 0x17, 0xed, 0xc5, 0x3a, 0xcd, + 0x7f, 0x13, 0x09, 0xca, 0x2f, 0xc7, 0x90, 0xb4, 0xc2, 0x3f, 0x23, 0x97, 0x60, 0x91, 0xb1, 0x90, 0x7f, 0x33, 0xc8, + 0x65, 0xff, 0x2b, 0x0a, 0xa9, 0x4c, 0xde, 0x51, 0x43, 0x3e, 0x86, 0x36, 0xfe, 0xff, 0xbf, 0xc8, 0xfa, 0x8f, 0x22, + 0xb2, 0x1e, 0x1e, 0xa2, 0x71, 0x64, 0xf1, 0x8b, 0x17, 0xf2, 0x3f, 0xb6, 0xa4, 0xe3, 0x52, 0xd2, 0xfd, 0x08, 0x19, + 0xc7, 0xff, 0x3a, 0x32, 0x4e, 0x6e, 0xa5, 0x8d, 0x90, 0xeb, 0x5b, 0xa7, 0x4e, 0x8c, 0xbb, 0xe2, 0x26, 0xba, 0xab, + 0x73, 0x37, 0x3f, 0x86, 0x10, 0xbc, 0x39, 0xba, 0x89, 0xee, 0xea, 0x85, 0xb8, 0x5f, 0x64, 0x2c, 0xf7, 0x13, 0x84, + 0x6f, 0x4f, 0x42, 0x3f, 0x7c, 0xfb, 0xcd, 0x37, 0xca, 0x2c, 0x0b, 0x64, 0xe7, 0x9b, 0xf3, 0x8d, 0xe5, 0x8a, 0xe0, + 0x64, 0x81, 0x69, 0x86, 0x38, 0x6a, 0x00, 0xc3, 0x8a, 0xcb, 0x3c, 0x5b, 0x86, 0xe6, 0x1d, 0x38, 0x01, 0xbe, 0x14, + 0x1c, 0xd9, 0xd3, 0x0a, 0x3c, 0xaa, 0xff, 0x25, 0x80, 0x64, 0x61, 0x0d, 0x51, 0xde, 0x80, 0x68, 0x8d, 0xd0, 0xaf, + 0x4f, 0x23, 0xd7, 0x3e, 0x36, 0xe3, 0x78, 0xcc, 0x83, 0x8f, 0xe1, 0x97, 0xe8, 0x0f, 0x15, 0x2a, 0xdb, 0x9c, 0xe7, + 0x5b, 0x5b, 0x59, 0x10, 0x62, 0x13, 0xa2, 0x5b, 0xd5, 0x24, 0x1c, 0xfe, 0x30, 0xf8, 0x13, 0xd5, 0xa2, 0x99, 0x65, + 0x43, 0x1e, 0x71, 0x9a, 0xdc, 0x2f, 0x96, 0x9b, 0xda, 0xc6, 0xd3, 0x19, 0x91, 0xc5, 0xa5, 0xcc, 0xf9, 0x99, 0x30, + 0x30, 0x3e, 0x37, 0x08, 0x44, 0xbd, 0x4d, 0xb6, 0x9a, 0xba, 0x66, 0xc7, 0x5c, 0x85, 0x6d, 0x23, 0x97, 0xd4, 0xa1, + 0xff, 0x2a, 0xa7, 0x03, 0x87, 0xc8, 0x78, 0xc2, 0x65, 0x26, 0xc0, 0x2b, 0x99, 0x79, 0x21, 0x38, 0x9b, 0xb8, 0x08, + 0x77, 0x3b, 0x08, 0x59, 0xae, 0x82, 0x0d, 0x56, 0x9c, 0x44, 0x27, 0xf2, 0x98, 0x9f, 0xba, 0xb6, 0x58, 0x9e, 0xa9, + 0x7a, 0x36, 0x1b, 0x0e, 0xe1, 0x74, 0x85, 0x66, 0x86, 0x5f, 0xee, 0x99, 0xef, 0xab, 0x3c, 0x8f, 0x44, 0xf4, 0x2d, + 0xa3, 0x37, 0x90, 0x47, 0x29, 0xaa, 0x3b, 0xba, 0x74, 0xc8, 0x5d, 0x7e, 0x42, 0xe2, 0x55, 0x26, 0x76, 0x7b, 0xae, + 0xf8, 0xe5, 0x9e, 0x4c, 0x00, 0x45, 0x86, 0xb8, 0xa1, 0xf1, 0x07, 0x96, 0x89, 0x03, 0x7d, 0x66, 0x0b, 0x0e, 0x4d, + 0x55, 0xb6, 0x87, 0xc3, 0xec, 0xeb, 0xbe, 0xa2, 0x6d, 0xa2, 0xf2, 0x88, 0xe5, 0xbd, 0x94, 0xc7, 0xe3, 0x88, 0x1f, + 0x9b, 0x23, 0x9e, 0x57, 0x22, 0x8f, 0xdc, 0xa8, 0xfa, 0x54, 0x89, 0xbb, 0xf3, 0xdd, 0xf6, 0xce, 0x08, 0xcb, 0x2c, + 0x90, 0xba, 0x68, 0x07, 0x8a, 0x2e, 0xed, 0x22, 0xb2, 0xbd, 0xb9, 0x83, 0x81, 0xd7, 0xfa, 0x6b, 0xfd, 0xaf, 0x66, + 0xc1, 0xda, 0x90, 0xde, 0x5b, 0x79, 0xf1, 0x8f, 0x23, 0xce, 0x19, 0xe5, 0x8e, 0xfb, 0xf2, 0x07, 0xe4, 0xff, 0xdb, + 0xbf, 0xac, 0xf7, 0xe6, 0xab, 0xdd, 0x6a, 0xcb, 0x81, 0x4c, 0x8b, 0xf6, 0x90, 0xd1, 0x34, 0x21, 0xad, 0x58, 0x35, + 0x6c, 0x99, 0xe0, 0xc3, 0xee, 0x41, 0xa7, 0xd3, 0xd1, 0x0e, 0xfa, 0xae, 0xfa, 0x09, 0x1e, 0x79, 0xf8, 0x09, 0x0f, + 0x32, 0xd8, 0x4a, 0x5a, 0x2a, 0xba, 0x77, 0xd0, 0x99, 0xde, 0xb6, 0x06, 0x40, 0xf2, 0x1a, 0x8a, 0xf7, 0x74, 0x4a, + 0x23, 0xf1, 0x45, 0xe3, 0x73, 0xd9, 0xa4, 0x1a, 0xbe, 0x6b, 0x86, 0xae, 0xc7, 0x5d, 0x1a, 0x74, 0x7f, 0x79, 0xd0, + 0x33, 0x36, 0x91, 0xb7, 0x8f, 0xdc, 0x37, 0xaa, 0x74, 0x58, 0x37, 0xc6, 0x14, 0xaa, 0x45, 0xcb, 0x91, 0x18, 0x1f, + 0xe7, 0x69, 0x42, 0x39, 0x69, 0x51, 0x6f, 0xe4, 0x39, 0x5f, 0x77, 0x3a, 0x1d, 0xdc, 0xde, 0xdb, 0xef, 0x74, 0xf0, + 0xfe, 0x93, 0x0e, 0x6e, 0xc3, 0x1f, 0xcf, 0xf3, 0x96, 0x60, 0x78, 0x28, 0xe4, 0xd9, 0xed, 0x70, 0x3a, 0xd1, 0x00, + 0x3e, 0x14, 0x88, 0xcb, 0xea, 0x23, 0x28, 0x86, 0xad, 0x95, 0xfa, 0xd2, 0xe7, 0x99, 0x75, 0x2e, 0xbb, 0xbc, 0x84, + 0x91, 0xd7, 0x31, 0x46, 0xaa, 0x32, 0x93, 0x5f, 0x69, 0x2a, 0xf0, 0x9d, 0x63, 0xb8, 0xb2, 0x4e, 0x86, 0x17, 0x21, + 0x31, 0x06, 0x3e, 0xfa, 0x23, 0x22, 0x96, 0x41, 0xa6, 0xb4, 0x09, 0x32, 0x1a, 0x17, 0x77, 0x33, 0x09, 0x36, 0x54, + 0xe1, 0xdc, 0x75, 0xb4, 0x70, 0x11, 0x02, 0xc1, 0x3f, 0xa2, 0x81, 0x5e, 0x3c, 0xa8, 0x9f, 0x3f, 0xa6, 0xbe, 0x41, + 0xfc, 0x45, 0x28, 0x13, 0x75, 0x36, 0xd8, 0x62, 0xb1, 0x11, 0x2d, 0x16, 0x1b, 0xf9, 0xe3, 0xe7, 0xa7, 0x56, 0x56, + 0x1f, 0x48, 0x2a, 0xe0, 0xae, 0x38, 0x05, 0xf4, 0x2b, 0x28, 0xf7, 0x19, 0x56, 0x20, 0xa9, 0xa7, 0x08, 0xeb, 0x01, + 0xd5, 0x63, 0x5e, 0x36, 0x50, 0x52, 0x10, 0xa6, 0xf6, 0xde, 0x8b, 0x45, 0x28, 0xa9, 0x3e, 0xc4, 0x31, 0x89, 0xaa, + 0xa2, 0x6e, 0x88, 0xe1, 0x12, 0x28, 0xf3, 0x18, 0x4a, 0x80, 0x53, 0x2d, 0x98, 0x6a, 0x78, 0x6f, 0x22, 0x9e, 0xd9, + 0xe0, 0x9e, 0xe4, 0x8e, 0x1e, 0xd4, 0x99, 0xf2, 0xfc, 0x9a, 0x41, 0x32, 0x48, 0x63, 0xd8, 0x19, 0x11, 0x6e, 0x8a, + 0xfa, 0x8d, 0x98, 0x71, 0xdd, 0xfc, 0xcc, 0x08, 0x55, 0xb8, 0xa8, 0xac, 0x9a, 0x9c, 0x5f, 0xe8, 0x79, 0xf9, 0xb1, + 0x99, 0xd2, 0xfb, 0xe8, 0xc6, 0x4f, 0xcd, 0xc3, 0x0b, 0x95, 0x75, 0xe2, 0xcf, 0x4a, 0x73, 0x7f, 0x94, 0xcc, 0x68, + 0x09, 0x8d, 0x88, 0x0e, 0x11, 0x1e, 0x2a, 0xa1, 0xf6, 0xfe, 0xf5, 0x29, 0x8d, 0x78, 0x3c, 0x7e, 0x17, 0xf1, 0x68, + 0x52, 0xf4, 0x87, 0xe6, 0xa2, 0x99, 0x50, 0x8f, 0x74, 0x39, 0x94, 0x59, 0x3f, 0x59, 0x7c, 0x17, 0xe2, 0x02, 0xe1, + 0xfa, 0xbd, 0x1a, 0x5f, 0xf9, 0xba, 0x43, 0x1c, 0xdb, 0xaf, 0xe4, 0xf7, 0x44, 0xf0, 0x0c, 0x61, 0x95, 0x4c, 0x93, + 0xfc, 0x25, 0xd3, 0x68, 0x30, 0xe4, 0x7d, 0xf8, 0x43, 0xaf, 0xfe, 0x78, 0xd3, 0x7d, 0x89, 0x35, 0x6b, 0x90, 0xe8, + 0x70, 0x5a, 0x4c, 0xf3, 0xac, 0x80, 0x9c, 0x33, 0x68, 0xa7, 0x6f, 0x64, 0xb5, 0x1a, 0xae, 0x50, 0x5b, 0xd5, 0x54, + 0xbe, 0x51, 0xed, 0xca, 0x72, 0x70, 0xf6, 0xfb, 0x2a, 0x1e, 0x6e, 0xa2, 0x3a, 0x25, 0xfe, 0xf5, 0x83, 0xf9, 0x78, + 0x4b, 0xd7, 0xcd, 0xf3, 0xfc, 0xa6, 0x20, 0x5d, 0x1d, 0x3e, 0x48, 0xf3, 0x11, 0x24, 0xe4, 0xfd, 0xa5, 0xf3, 0xeb, + 0xd2, 0x7c, 0x64, 0x67, 0xd7, 0xa9, 0x94, 0x3a, 0x9c, 0x91, 0x79, 0xeb, 0xbb, 0xdb, 0xee, 0xb3, 0xf3, 0x6e, 0x7f, + 0xb7, 0x3b, 0x69, 0xf9, 0x21, 0x0d, 0xb1, 0x2a, 0xe8, 0xf4, 0x77, 0x77, 0xa1, 0xe0, 0xc6, 0x2a, 0xe8, 0x41, 0x01, + 0xb3, 0x0a, 0xf6, 0xa1, 0x20, 0xb6, 0x0a, 0x9e, 0x40, 0x41, 0x62, 0x15, 0x3c, 0x85, 0x82, 0xeb, 0xb0, 0x3c, 0x17, + 0x55, 0x52, 0xe8, 0x53, 0x24, 0xbf, 0x38, 0xb0, 0x91, 0x35, 0xb3, 0x16, 0x4c, 0x85, 0xa7, 0xb8, 0xba, 0xd1, 0x6b, + 0xcf, 0xdc, 0x40, 0x15, 0xfe, 0x4c, 0x7e, 0xf0, 0x89, 0xc3, 0xb9, 0x62, 0xb8, 0xe6, 0x59, 0xd5, 0xdc, 0xad, 0x5e, + 0xfb, 0x55, 0xf2, 0x64, 0x07, 0xf7, 0x4c, 0xfa, 0xa4, 0x2f, 0x25, 0x8f, 0xa9, 0xbc, 0xbf, 0x1d, 0xe9, 0x6e, 0xe1, + 0xc0, 0x31, 0xab, 0xaa, 0xef, 0x22, 0x1c, 0x1b, 0x83, 0x80, 0xca, 0x3b, 0x22, 0xcf, 0xd8, 0x84, 0x1a, 0x82, 0x32, + 0x03, 0x38, 0x32, 0xb9, 0xb4, 0xcf, 0x97, 0x0d, 0x05, 0x2d, 0xa5, 0xd5, 0x25, 0x48, 0x19, 0x56, 0x91, 0xa0, 0x02, + 0x8b, 0x68, 0xe4, 0x47, 0x58, 0x65, 0x28, 0xc8, 0xdb, 0xd0, 0x3a, 0x41, 0xee, 0x53, 0x7c, 0x33, 0xa6, 0x99, 0x1f, + 0x97, 0xfd, 0x6a, 0x9d, 0x4d, 0xf6, 0x5f, 0x89, 0xac, 0xb5, 0xaf, 0xdf, 0x2a, 0x18, 0xdb, 0x15, 0x8d, 0xdc, 0x93, + 0x1e, 0x66, 0x19, 0x00, 0xc3, 0x34, 0xbf, 0x69, 0x83, 0x0a, 0x5c, 0x9b, 0x32, 0x06, 0x33, 0xab, 0x52, 0xc6, 0x5e, + 0x03, 0xac, 0xd5, 0xd3, 0x59, 0x34, 0xaa, 0x7e, 0xbf, 0xa1, 0x45, 0x11, 0x8d, 0x74, 0xcd, 0xfb, 0x53, 0xc4, 0x24, + 0x88, 0x76, 0x7a, 0x98, 0x01, 0x02, 0x02, 0xb7, 0x80, 0x10, 0x08, 0x73, 0xea, 0xb4, 0x2e, 0x98, 0x79, 0x33, 0x23, + 0x4c, 0xa2, 0xaa, 0x59, 0x24, 0xa2, 0x51, 0x5d, 0x70, 0x38, 0xe5, 0x54, 0xe7, 0x9a, 0x01, 0x16, 0xcb, 0xc3, 0x1d, + 0x28, 0x50, 0xaf, 0xef, 0xc9, 0xfc, 0x32, 0xdc, 0x77, 0x7f, 0xfe, 0x97, 0x63, 0x52, 0xbf, 0x74, 0xd2, 0xd3, 0x70, + 0x38, 0x5c, 0xcd, 0xed, 0xfa, 0xaa, 0x1b, 0xc3, 0x7f, 0x6b, 0xb2, 0xf6, 0x93, 0x21, 0xed, 0xd1, 0x7d, 0x2b, 0x11, + 0xaa, 0x71, 0x9c, 0xa1, 0x3a, 0xcb, 0xd0, 0x87, 0xf4, 0xf8, 0xb6, 0xce, 0x6c, 0xea, 0x96, 0x12, 0x77, 0x2b, 0x09, + 0x5e, 0x55, 0x6f, 0x8d, 0xca, 0x32, 0xc9, 0x6b, 0x25, 0x67, 0x4c, 0xe7, 0x88, 0xad, 0x4d, 0x09, 0x9b, 0x72, 0x3a, + 0x9f, 0x44, 0x7c, 0xc4, 0x32, 0xbf, 0x53, 0x7a, 0xd7, 0x66, 0x66, 0x07, 0x07, 0x07, 0xa5, 0x97, 0x98, 0xa7, 0x4e, + 0x92, 0x94, 0x5e, 0x5c, 0xcd, 0xba, 0x33, 0x2c, 0x3d, 0x66, 0x9e, 0x76, 0x7b, 0x71, 0xb2, 0xdb, 0x2b, 0xbd, 0x9b, + 0x1a, 0x29, 0x9d, 0xd2, 0x33, 0x28, 0xe2, 0x34, 0x69, 0x64, 0xac, 0x3d, 0xed, 0x74, 0x4a, 0x4f, 0x51, 0xd9, 0x1c, + 0x62, 0x4d, 0xea, 0xa7, 0x1f, 0xcd, 0x44, 0x5e, 0x86, 0x2a, 0x3b, 0xeb, 0xa5, 0xbe, 0x13, 0x4c, 0x7d, 0x1c, 0xab, + 0x44, 0x17, 0xf8, 0xd7, 0x76, 0x0e, 0x16, 0x10, 0xf2, 0x6a, 0x9a, 0x56, 0xa3, 0x0a, 0x50, 0x56, 0x5d, 0xe5, 0xd7, + 0x56, 0x7a, 0x16, 0x48, 0x31, 0xa8, 0xad, 0xb2, 0xb2, 0xfe, 0x40, 0xc2, 0x78, 0x4c, 0xe3, 0x4f, 0x57, 0xf9, 0x6d, + 0x1b, 0xe8, 0x89, 0x87, 0xf8, 0xf7, 0x3f, 0x26, 0x0f, 0xda, 0x74, 0x62, 0x7d, 0xb6, 0x43, 0x1a, 0x8b, 0x6f, 0x33, + 0x12, 0xbe, 0x35, 0xa1, 0x1f, 0x55, 0x32, 0x1c, 0x92, 0xf0, 0xed, 0x70, 0x18, 0x9a, 0xeb, 0x18, 0x22, 0x41, 0x65, + 0xad, 0x93, 0x46, 0x89, 0xac, 0x05, 0xbb, 0xc2, 0xba, 0xcc, 0x2e, 0x50, 0x49, 0x51, 0xa1, 0x9d, 0x00, 0xa5, 0xdf, + 0x24, 0xac, 0x00, 0xfa, 0x84, 0xaf, 0x89, 0xac, 0x5c, 0xff, 0xdb, 0x04, 0x55, 0xf5, 0x5c, 0x7f, 0x6c, 0x02, 0x0e, + 0x2e, 0x68, 0xb3, 0xf0, 0xd9, 0xdd, 0xab, 0xc4, 0xfd, 0x03, 0x2a, 0x59, 0xf1, 0x36, 0x5b, 0x3a, 0x53, 0xad, 0x40, + 0x21, 0xc4, 0x86, 0xbe, 0x54, 0x87, 0xfc, 0x97, 0xce, 0xdb, 0xaa, 0xc6, 0x41, 0x63, 0x52, 0xbe, 0xdd, 0x4c, 0xef, + 0xb2, 0x8e, 0xd5, 0xe1, 0xca, 0x6b, 0xfd, 0x6d, 0x3e, 0x19, 0x1a, 0x9a, 0x6b, 0xc9, 0x37, 0x57, 0x67, 0xc4, 0x04, + 0x66, 0x89, 0x6a, 0xca, 0x92, 0xb2, 0xd4, 0x27, 0x78, 0x13, 0x56, 0x4c, 0x41, 0xe5, 0xaa, 0x96, 0xd9, 0xe7, 0x04, + 0x5b, 0x71, 0x63, 0x25, 0x25, 0x35, 0xd6, 0xa3, 0x34, 0x16, 0xbd, 0xca, 0x19, 0xf9, 0x43, 0xd9, 0xd2, 0xb6, 0xbd, + 0x41, 0x55, 0xcb, 0x51, 0x58, 0x53, 0xd9, 0x52, 0xd6, 0xe4, 0x20, 0xfd, 0xa3, 0x42, 0xb8, 0x79, 0x65, 0x0a, 0xca, + 0xca, 0x1c, 0x37, 0x6f, 0x14, 0x9a, 0x64, 0x1e, 0x50, 0x31, 0x8d, 0x32, 0x63, 0xf5, 0x2b, 0x3e, 0xd1, 0x75, 0xe4, + 0x43, 0xd9, 0x32, 0x50, 0x4b, 0xa2, 0x84, 0x64, 0x0f, 0x68, 0x30, 0x70, 0x1a, 0x90, 0x67, 0x2b, 0xe9, 0x43, 0x0f, + 0xe6, 0xad, 0xe6, 0xa1, 0x57, 0xdc, 0x60, 0xaf, 0xb8, 0x71, 0x7e, 0x39, 0x6f, 0xdf, 0xd0, 0xab, 0x4f, 0x4c, 0xb4, + 0x45, 0x34, 0x6d, 0x83, 0x37, 0x4d, 0x26, 0x14, 0x68, 0xe9, 0x25, 0xcd, 0x3a, 0xb5, 0x4b, 0xe8, 0xcf, 0x0a, 0x48, + 0x6f, 0x95, 0x36, 0xb7, 0x9f, 0xe5, 0x19, 0xed, 0x37, 0x8f, 0x3c, 0xd9, 0x69, 0x9c, 0x06, 0x59, 0x17, 0xf3, 0x1c, + 0xd2, 0x61, 0xc5, 0x9d, 0xdf, 0xd1, 0x72, 0xae, 0x63, 0x72, 0x34, 0x3b, 0x6b, 0xeb, 0xfb, 0x1a, 0xb7, 0xdb, 0x52, + 0xa2, 0xf3, 0xd5, 0xcc, 0x52, 0x9b, 0xca, 0x1f, 0x71, 0x7a, 0x6a, 0x28, 0xff, 0x67, 0x9d, 0x9e, 0x7a, 0xcc, 0xa8, + 0xfe, 0x95, 0x3c, 0x4a, 0x8e, 0x1f, 0x53, 0x35, 0x1a, 0x0a, 0xca, 0xe7, 0x20, 0x56, 0xfd, 0xee, 0xc1, 0xf4, 0xf6, + 0x51, 0xdd, 0xab, 0x36, 0x0f, 0x4e, 0xad, 0xd4, 0xf3, 0x37, 0x57, 0xd9, 0xb5, 0x5a, 0x3f, 0xee, 0xa8, 0xd8, 0x7d, + 0xa7, 0xd0, 0xe0, 0x18, 0x32, 0x8b, 0xa3, 0x54, 0xab, 0x85, 0x09, 0x4b, 0x92, 0x94, 0x2e, 0x1d, 0x1f, 0xeb, 0xee, + 0x57, 0x69, 0xba, 0xbb, 0x4f, 0xa6, 0xb7, 0x66, 0xe1, 0xba, 0x90, 0xbd, 0x6b, 0x74, 0x84, 0xd3, 0x85, 0x37, 0xd6, + 0x61, 0xb9, 0x7a, 0x44, 0xc7, 0xdb, 0x2d, 0xfa, 0xc0, 0x97, 0x69, 0x74, 0xe7, 0xb3, 0x4c, 0x2a, 0xa6, 0x2b, 0xc8, + 0x48, 0xe8, 0x4f, 0x73, 0x5d, 0x99, 0xd3, 0x54, 0x7e, 0x06, 0xb7, 0x6c, 0xe2, 0xbd, 0x81, 0x26, 0x1b, 0x03, 0x0d, + 0xf0, 0xf6, 0x3b, 0x3f, 0x37, 0xa7, 0xbb, 0x3a, 0x35, 0x74, 0xf2, 0xb7, 0x05, 0x0f, 0xac, 0x0c, 0x40, 0x82, 0x9b, + 0x80, 0x61, 0x10, 0xf2, 0x4a, 0xde, 0x39, 0x5e, 0xb7, 0xc0, 0xb2, 0x05, 0x6c, 0x09, 0xe0, 0xe9, 0x33, 0x50, 0x47, + 0x57, 0x45, 0x9e, 0xc2, 0x57, 0xa4, 0x44, 0x3e, 0xf5, 0xdb, 0xbb, 0xd3, 0xdb, 0xbe, 0x5c, 0xfe, 0x4e, 0x73, 0x16, + 0x7f, 0x21, 0xd2, 0xa5, 0x4f, 0x6a, 0xd2, 0x7d, 0x98, 0x7c, 0xbe, 0x1a, 0x76, 0xe1, 0xbf, 0x7e, 0x3d, 0x33, 0xbf, + 0xe3, 0xec, 0x4e, 0x6f, 0x1d, 0x30, 0x12, 0xda, 0xbd, 0xe9, 0xad, 0xf3, 0x55, 0xa7, 0xd3, 0xd9, 0xc5, 0x1d, 0x07, + 0x7e, 0x9b, 0xe7, 0x4e, 0xa7, 0xd3, 0xdb, 0xc3, 0x1d, 0x59, 0x69, 0xbf, 0x2e, 0xeb, 0x0e, 0x1f, 0xa4, 0x64, 0x3f, + 0xcb, 0x85, 0xeb, 0x1b, 0xe1, 0x86, 0xfe, 0xd6, 0x40, 0x26, 0x4f, 0x13, 0x3e, 0x86, 0x7d, 0x96, 0x3a, 0xf0, 0x44, + 0x74, 0x75, 0x45, 0x13, 0x7f, 0x98, 0xc7, 0xb3, 0xe2, 0x6f, 0xff, 0xca, 0x78, 0xec, 0x57, 0x8b, 0xed, 0x17, 0x71, + 0x94, 0x52, 0xb7, 0xe7, 0xed, 0xdd, 0x23, 0x17, 0x7e, 0xf4, 0x34, 0x7f, 0xc2, 0xf4, 0xcc, 0x0a, 0xec, 0x3d, 0x1e, + 0xce, 0x73, 0x33, 0xd2, 0x85, 0x91, 0x9b, 0x5a, 0x34, 0x27, 0xea, 0x33, 0x2a, 0x6b, 0xac, 0xd2, 0x07, 0x97, 0x79, + 0xa5, 0x3f, 0x45, 0x73, 0x6b, 0xa7, 0x5a, 0xd7, 0x7d, 0xa4, 0x98, 0xfb, 0xea, 0xeb, 0x3d, 0xf8, 0xaf, 0x4a, 0xbf, + 0x37, 0x06, 0x9e, 0xda, 0x24, 0x81, 0x81, 0xf7, 0xfb, 0x86, 0xf5, 0xa6, 0xd4, 0x5b, 0xc3, 0xc6, 0x7b, 0x54, 0x13, + 0x30, 0xab, 0x1e, 0xdf, 0x46, 0x9b, 0x21, 0x5f, 0xde, 0xe4, 0x47, 0x0c, 0xf3, 0x25, 0x0d, 0x62, 0x65, 0xce, 0xad, + 0x69, 0xa0, 0x3f, 0x31, 0xbb, 0xd2, 0xc2, 0xac, 0x47, 0xdd, 0xe8, 0xf7, 0x96, 0xc9, 0xab, 0x32, 0x01, 0xc1, 0xea, + 0xfd, 0xbd, 0xb2, 0x7a, 0xbf, 0xa1, 0x64, 0x7e, 0x74, 0x76, 0xf6, 0xfe, 0xd5, 0xb3, 0x0f, 0x67, 0x2f, 0xfc, 0x2e, + 0x3e, 0x7e, 0xf9, 0xea, 0xf5, 0x73, 0xbf, 0x87, 0xdf, 0xbd, 0x7f, 0xfb, 0xee, 0xc5, 0xfb, 0xb3, 0x3f, 0xf8, 0xbb, + 0xf8, 0xd9, 0xdb, 0xb7, 0xaf, 0x5f, 0x1c, 0x9d, 0x5c, 0xd6, 0xd5, 0xf6, 0xf0, 0x8b, 0x6f, 0x5f, 0x9c, 0x9c, 0xf9, + 0xfb, 0xf8, 0xc5, 0xeb, 0x17, 0x6f, 0xe0, 0xd7, 0x93, 0x12, 0xbf, 0x92, 0x5f, 0x1d, 0x70, 0xf5, 0x77, 0xaa, 0xf5, + 0xcd, 0xfa, 0xf5, 0xa5, 0xb7, 0x3e, 0x35, 0x97, 0xea, 0x8b, 0x12, 0xe1, 0xd7, 0x6b, 0x2f, 0x02, 0x42, 0xf3, 0x47, + 0x5d, 0xdf, 0x73, 0xb6, 0xf4, 0xd9, 0xae, 0x63, 0xd1, 0xbc, 0x5c, 0xb6, 0xba, 0x64, 0x93, 0x91, 0xac, 0x34, 0xb7, + 0xda, 0x36, 0xfb, 0x33, 0xd7, 0xb5, 0xc0, 0xb5, 0x1d, 0xd6, 0xef, 0x46, 0x1d, 0x6d, 0x43, 0xca, 0x09, 0x95, 0x25, + 0xfe, 0xe3, 0xd2, 0x66, 0xe0, 0x35, 0x5d, 0x06, 0x9e, 0x0d, 0x5d, 0x7d, 0x21, 0x95, 0xde, 0x0a, 0x30, 0x41, 0x4e, + 0xf4, 0x57, 0xa3, 0x36, 0x08, 0xf9, 0x86, 0x7a, 0x12, 0xbb, 0x8d, 0x5b, 0xfb, 0xb5, 0xa1, 0x57, 0xdf, 0xb8, 0x90, + 0x18, 0x8c, 0xc1, 0x91, 0xac, 0xed, 0xd0, 0x45, 0x4e, 0x1c, 0x65, 0x4e, 0x9e, 0xa5, 0x77, 0xce, 0x15, 0x75, 0x66, + 0x05, 0x05, 0xcf, 0xa4, 0x23, 0x0f, 0xdf, 0x38, 0x57, 0x4c, 0x7e, 0xaa, 0xa4, 0x08, 0x2b, 0x83, 0x57, 0x41, 0xd1, + 0xbc, 0x75, 0x73, 0x29, 0x69, 0xa8, 0xf9, 0x29, 0x42, 0x41, 0x68, 0x5f, 0xb7, 0x78, 0x53, 0x7f, 0xed, 0xdb, 0xfa, + 0x18, 0xf8, 0x46, 0xf5, 0xe9, 0xc3, 0x2f, 0x87, 0x3b, 0x4d, 0x69, 0xe2, 0xdc, 0x30, 0x31, 0x76, 0x22, 0x27, 0xcb, + 0xb3, 0xb6, 0xea, 0x48, 0x79, 0xe0, 0x95, 0x63, 0xb6, 0xda, 0x3e, 0x30, 0xb1, 0x04, 0x66, 0xbf, 0x86, 0x4f, 0x7f, + 0x5a, 0x92, 0x5e, 0xd4, 0x77, 0x54, 0xf0, 0xe8, 0xa6, 0x5a, 0x67, 0x41, 0xec, 0xaf, 0x38, 0xac, 0x00, 0xc6, 0xe5, + 0x17, 0xcf, 0xe1, 0xe5, 0xea, 0xf7, 0x1d, 0xce, 0x2f, 0xca, 0xb2, 0xec, 0xff, 0xb1, 0x09, 0x3c, 0xd1, 0xdf, 0xae, + 0x87, 0xcb, 0xa1, 0x43, 0xfc, 0x47, 0xab, 0x03, 0xd2, 0x95, 0x3c, 0xf3, 0x9e, 0x92, 0x57, 0xd4, 0xfd, 0x23, 0xc2, + 0x3f, 0xc0, 0x27, 0x3e, 0x82, 0xdb, 0x49, 0xea, 0x5c, 0xab, 0xfb, 0x67, 0x48, 0xab, 0xeb, 0x75, 0x5a, 0x8e, 0x74, + 0x2a, 0xc2, 0x37, 0x64, 0x5a, 0x1f, 0xce, 0xbe, 0x69, 0x1f, 0xb4, 0x02, 0xb0, 0xf2, 0xaf, 0x47, 0x72, 0x53, 0xf1, + 0x3a, 0xba, 0xa3, 0xfc, 0xb2, 0xa7, 0xe3, 0x04, 0x2a, 0x61, 0x5d, 0x96, 0x39, 0xbd, 0x96, 0x73, 0x3b, 0x49, 0xb3, + 0x82, 0xb4, 0xc6, 0x42, 0x4c, 0xfd, 0x9d, 0x9d, 0x9b, 0x9b, 0x1b, 0xef, 0x66, 0xd7, 0xcb, 0xf9, 0x68, 0xa7, 0xd7, + 0xe9, 0x74, 0xe0, 0x3e, 0xfc, 0x96, 0x73, 0xcd, 0xe8, 0xcd, 0xb3, 0xfc, 0x96, 0xb4, 0x3a, 0x4e, 0xc7, 0xe9, 0xf6, + 0x0e, 0x9c, 0x6e, 0x6f, 0xcf, 0x7b, 0x72, 0xd0, 0x1a, 0xfc, 0xcc, 0x71, 0x0e, 0x13, 0x3a, 0x2c, 0xe0, 0x87, 0xe3, + 0x1c, 0x4a, 0xa3, 0x5f, 0xfd, 0x76, 0x1c, 0x2f, 0x4e, 0x8b, 0x76, 0xd7, 0x99, 0xeb, 0x47, 0xc7, 0x81, 0xdb, 0x75, + 0x7c, 0xe7, 0xab, 0x61, 0x6f, 0xb8, 0x37, 0xfc, 0xba, 0xaf, 0x8b, 0xcb, 0x9f, 0x35, 0xaa, 0x63, 0xf5, 0x6f, 0xcf, + 0x6a, 0x56, 0x08, 0x9e, 0x7f, 0xa2, 0x3a, 0xfe, 0xe0, 0x80, 0xad, 0xb5, 0xb6, 0x69, 0x6f, 0x75, 0xa4, 0xee, 0xc1, + 0x55, 0x3c, 0xec, 0xd5, 0xd5, 0x25, 0x8c, 0x3b, 0x15, 0x90, 0x87, 0x3b, 0x06, 0xf4, 0x43, 0x1b, 0x4d, 0xdd, 0xf6, + 0x3a, 0x44, 0x75, 0x5b, 0x7a, 0x8e, 0x23, 0x33, 0xbf, 0x43, 0x38, 0x45, 0x6e, 0xf6, 0x49, 0x12, 0x82, 0x96, 0x93, + 0x90, 0xd6, 0x9b, 0x6e, 0xef, 0x00, 0x77, 0xbb, 0x4f, 0xbc, 0x27, 0x07, 0x71, 0x07, 0xef, 0x79, 0x7b, 0xed, 0x5d, + 0xef, 0x09, 0x3e, 0x68, 0x1f, 0xe0, 0x83, 0x97, 0x07, 0x71, 0x7b, 0xcf, 0xdb, 0xc3, 0x9d, 0xf6, 0x01, 0x14, 0xb6, + 0x0f, 0xda, 0x07, 0xd7, 0xed, 0xbd, 0x83, 0xb8, 0x23, 0x4b, 0x7b, 0xde, 0xfe, 0x7e, 0xbb, 0xdb, 0xf1, 0xf6, 0xf7, + 0xf1, 0xbe, 0xf7, 0xe4, 0x49, 0xbb, 0xbb, 0xeb, 0x3d, 0x79, 0xf2, 0x7a, 0xff, 0xc0, 0xdb, 0x85, 0x77, 0xbb, 0xbb, + 0xf1, 0xae, 0xd7, 0xed, 0xb6, 0xe1, 0x0f, 0x3e, 0xf0, 0x7a, 0xea, 0x47, 0xb7, 0xeb, 0xed, 0x76, 0x71, 0x27, 0xdd, + 0xef, 0x79, 0x4f, 0xbe, 0xc6, 0xf2, 0xaf, 0xac, 0x86, 0xe5, 0x1f, 0xe8, 0x06, 0x7f, 0xed, 0xf5, 0x9e, 0xa8, 0x5f, + 0xb2, 0xc3, 0xeb, 0xbd, 0x83, 0x3f, 0xb6, 0x76, 0xee, 0x9d, 0x43, 0x57, 0xcd, 0xe1, 0x60, 0xdf, 0xdb, 0xdd, 0xc5, + 0x7b, 0x5d, 0xef, 0x60, 0x77, 0xdc, 0xde, 0xeb, 0x79, 0x4f, 0x9e, 0xc6, 0xed, 0xae, 0xf7, 0xf4, 0x29, 0xee, 0xb4, + 0x77, 0xbd, 0x1e, 0xee, 0x7a, 0x7b, 0xbb, 0xf2, 0xc7, 0xae, 0xd7, 0xbb, 0x7e, 0xfa, 0xb5, 0xf7, 0x64, 0x7f, 0xfc, + 0xc4, 0xdb, 0xfb, 0x76, 0xef, 0xc0, 0xeb, 0xed, 0x8e, 0x77, 0x9f, 0x78, 0xbd, 0xa7, 0xd7, 0x4f, 0xbc, 0xbd, 0x71, + 0xbb, 0xf7, 0xe4, 0xc1, 0x96, 0xdd, 0x9e, 0x07, 0x38, 0x92, 0xaf, 0xe1, 0x05, 0xd6, 0x2f, 0xe0, 0xff, 0x63, 0xd9, + 0xf6, 0xff, 0x62, 0x37, 0xc5, 0x6a, 0xd3, 0xaf, 0xbd, 0x83, 0xa7, 0xb1, 0xaa, 0x0e, 0x05, 0x6d, 0x53, 0x03, 0x9a, + 0x5c, 0xb7, 0xd5, 0xb0, 0xb2, 0xbb, 0xb6, 0xe9, 0xc8, 0xfc, 0x5f, 0x0f, 0x76, 0xdd, 0x86, 0x81, 0xd5, 0xb8, 0xff, + 0x4f, 0xfb, 0xa9, 0x96, 0xfc, 0x70, 0x67, 0xa4, 0x48, 0x7f, 0x34, 0xf8, 0x99, 0xfa, 0xd8, 0xc5, 0xcf, 0x42, 0xfc, + 0xdb, 0x15, 0x97, 0x93, 0xda, 0xc8, 0xcf, 0xb5, 0xb7, 0x44, 0x7e, 0xa8, 0xc9, 0xdc, 0x97, 0x62, 0x36, 0x2a, 0x72, + 0x87, 0x52, 0x16, 0xd7, 0xa3, 0xb9, 0xe5, 0x4d, 0x34, 0xfb, 0x35, 0xf8, 0xdd, 0xac, 0x18, 0xae, 0xb8, 0x47, 0xde, + 0x53, 0xf7, 0x07, 0xb8, 0x08, 0xaf, 0xff, 0xdb, 0xa6, 0x7b, 0x2c, 0x07, 0x4b, 0xe1, 0xb7, 0x4b, 0x01, 0x01, 0xe9, + 0xa9, 0x91, 0x9e, 0x96, 0x53, 0xf9, 0xec, 0xfe, 0xc6, 0x45, 0xdb, 0xe1, 0x0e, 0xbd, 0x96, 0x71, 0x32, 0x65, 0x56, + 0x6c, 0x7e, 0x49, 0xc4, 0x42, 0x5d, 0xf8, 0x42, 0x4c, 0x02, 0xff, 0x14, 0x24, 0xa7, 0x79, 0x30, 0x82, 0x35, 0xec, + 0x79, 0x1d, 0xaf, 0x53, 0xb9, 0xbc, 0xe0, 0x0a, 0x20, 0x32, 0xcf, 0x45, 0x04, 0x17, 0x68, 0xa5, 0xf9, 0x48, 0x5e, + 0xb5, 0x05, 0x9f, 0xf9, 0x81, 0x63, 0x00, 0xb1, 0xfa, 0xa6, 0x12, 0x64, 0x27, 0x68, 0x47, 0x58, 0xc4, 0x3f, 0xfd, + 0x16, 0x42, 0x86, 0xe6, 0xf6, 0x89, 0x09, 0x38, 0x8b, 0xde, 0xd0, 0x84, 0x45, 0x6e, 0xe8, 0x4e, 0x39, 0x1d, 0x52, + 0x5e, 0xb4, 0x1b, 0xb7, 0xcf, 0xc8, 0x8b, 0x67, 0x50, 0xa8, 0x21, 0x1c, 0x72, 0xf8, 0xee, 0x05, 0x39, 0xd7, 0x7e, + 0xcc, 0x50, 0xef, 0xa3, 0xc3, 0x12, 0x9b, 0x12, 0x0e, 0x16, 0x57, 0x6d, 0xb1, 0x87, 0xca, 0x64, 0xef, 0x7a, 0xbd, + 0x7d, 0xe4, 0xc8, 0x62, 0xf8, 0xfe, 0xc0, 0x1f, 0xdc, 0xf6, 0x6e, 0xe7, 0xe7, 0xc8, 0x6a, 0x56, 0x75, 0x74, 0xa1, + 0xb3, 0x18, 0xcc, 0x67, 0xa2, 0x96, 0x43, 0x9c, 0xea, 0xe6, 0x90, 0xaf, 0xd4, 0xcc, 0x43, 0xd4, 0x37, 0x9f, 0x59, + 0x53, 0x37, 0xb6, 0x0d, 0xd9, 0xc8, 0x6d, 0x5c, 0x71, 0x20, 0xbf, 0x6e, 0x00, 0xd7, 0x40, 0x23, 0x54, 0xd6, 0x55, + 0x28, 0x9a, 0xcb, 0xd0, 0x0d, 0xcb, 0x1c, 0xba, 0x58, 0xb8, 0x32, 0x9c, 0x45, 0x2c, 0x8c, 0xc2, 0x33, 0x6a, 0xa0, + 0x98, 0xe2, 0x0a, 0x20, 0x89, 0x5e, 0x42, 0xd5, 0xbf, 0x75, 0xb1, 0xf9, 0xa1, 0xdd, 0x85, 0x5e, 0x1a, 0xc1, 0xc7, + 0x86, 0xe5, 0x3f, 0x2b, 0x4e, 0x47, 0x15, 0x71, 0x5a, 0x2a, 0xad, 0xbb, 0xaa, 0x9d, 0x8e, 0xc5, 0xb3, 0xbb, 0x33, + 0x7d, 0x5b, 0x6f, 0x08, 0x0e, 0x6f, 0x19, 0x30, 0xa9, 0x3f, 0xd9, 0xb0, 0x4d, 0xc2, 0x43, 0xb8, 0x0c, 0x4d, 0x9d, + 0xf7, 0x02, 0x8d, 0x08, 0x89, 0x22, 0x8e, 0xf6, 0x15, 0xe8, 0xd8, 0x39, 0x51, 0x47, 0xc9, 0x95, 0xb2, 0xc2, 0x0e, + 0x53, 0x17, 0xb9, 0xb5, 0xe5, 0xc2, 0x90, 0x2e, 0x56, 0xee, 0xac, 0x38, 0x92, 0xe7, 0x64, 0x49, 0x96, 0xb7, 0x06, + 0xa1, 0x36, 0x34, 0xee, 0x5b, 0x82, 0x94, 0x65, 0x9f, 0xce, 0x39, 0x4d, 0xff, 0x96, 0xfc, 0x82, 0xc5, 0x79, 0xf6, + 0x0b, 0x88, 0x2d, 0x0b, 0x6f, 0xcc, 0xe9, 0x90, 0x84, 0xea, 0x5a, 0x36, 0xd8, 0x81, 0x02, 0x23, 0x6f, 0xdf, 0x4e, + 0x52, 0x2c, 0x35, 0xfe, 0x23, 0x14, 0xba, 0x02, 0xb6, 0xd5, 0xdb, 0x6f, 0x39, 0x8a, 0x65, 0xe5, 0xef, 0x81, 0x52, + 0x07, 0x52, 0x89, 0x39, 0xdd, 0x9e, 0xb7, 0x3f, 0xee, 0x79, 0x5f, 0x5f, 0x3f, 0xf5, 0x0e, 0xc6, 0xdd, 0xa7, 0xd7, + 0x6d, 0xf8, 0xb7, 0xe7, 0x7d, 0x9d, 0xb6, 0x7b, 0xde, 0xd7, 0xf0, 0xff, 0x6f, 0xf7, 0xbc, 0xfd, 0x71, 0xbb, 0xeb, + 0x1d, 0x5c, 0xef, 0x7a, 0xbb, 0xaf, 0xbb, 0x3d, 0x6f, 0xd7, 0xe9, 0x3a, 0xaa, 0x1d, 0x88, 0x1b, 0xfd, 0x29, 0x9d, + 0x25, 0x66, 0x58, 0x13, 0xd7, 0x53, 0x27, 0xd6, 0x42, 0x2c, 0xaf, 0x9f, 0xb2, 0x79, 0x53, 0x3b, 0x3a, 0x9f, 0x47, + 0xfc, 0x93, 0x5b, 0x05, 0x98, 0xd6, 0xbd, 0x6b, 0x8a, 0x8a, 0x35, 0x43, 0x4c, 0x65, 0xbc, 0xd9, 0x8a, 0x1d, 0x4a, + 0x63, 0x53, 0x7d, 0x1b, 0x44, 0x87, 0xd4, 0xf4, 0x65, 0x1a, 0x16, 0x41, 0xab, 0xf7, 0x70, 0xc1, 0xb7, 0xa4, 0xbe, + 0xe5, 0x44, 0x4c, 0x9b, 0xc2, 0xcb, 0x5a, 0x86, 0x08, 0xf9, 0x61, 0x25, 0x39, 0xfe, 0xab, 0xa4, 0x5c, 0x06, 0x0d, + 0x0e, 0xdc, 0xf1, 0x9c, 0x93, 0xea, 0x42, 0x37, 0x5a, 0xc7, 0xda, 0x13, 0xc6, 0xe5, 0x85, 0xa5, 0x66, 0x56, 0x8d, + 0x7d, 0x41, 0x8d, 0x40, 0x29, 0x46, 0x68, 0x11, 0x84, 0x50, 0x14, 0xfa, 0xa1, 0x74, 0x9d, 0x86, 0xf6, 0x67, 0xf7, + 0xec, 0xcb, 0x21, 0x25, 0xb1, 0xcb, 0x4b, 0x09, 0x80, 0x9d, 0x01, 0x75, 0x21, 0x5c, 0xbb, 0x73, 0x1f, 0x27, 0xdd, + 0xcf, 0x62, 0x52, 0x0b, 0xc0, 0xa4, 0xeb, 0xcf, 0x81, 0xd9, 0xb2, 0x2b, 0xb4, 0x57, 0x07, 0x55, 0x43, 0x4a, 0xc4, + 0x23, 0x8d, 0xb1, 0x2b, 0x1a, 0x09, 0x2f, 0xca, 0x54, 0xfe, 0xbe, 0x25, 0xe2, 0x70, 0x97, 0xee, 0xa2, 0x32, 0x17, + 0x91, 0x95, 0xfc, 0xab, 0x65, 0x43, 0x2e, 0xa2, 0x3a, 0x01, 0xf8, 0x70, 0xdc, 0x1b, 0xbc, 0x3d, 0x3b, 0x72, 0x14, + 0x1b, 0x1f, 0xee, 0x8c, 0x7b, 0x83, 0x43, 0xe9, 0x3f, 0x53, 0x01, 0x79, 0xd2, 0x82, 0x80, 0x7c, 0xcb, 0xd1, 0x77, + 0x9b, 0xb4, 0x36, 0xe7, 0xbf, 0x71, 0x51, 0xb9, 0xa3, 0xf0, 0x20, 0xed, 0x63, 0xe5, 0x55, 0x9f, 0xcc, 0x52, 0xc1, + 0xe0, 0x23, 0x1d, 0x3b, 0x32, 0x1e, 0x0f, 0x8b, 0x5c, 0x9d, 0xf8, 0xd4, 0x96, 0xd0, 0x95, 0xc8, 0x8c, 0x0f, 0x7e, + 0xc8, 0x52, 0x6a, 0xce, 0x78, 0xea, 0xae, 0xaa, 0x0c, 0x9c, 0xd5, 0xda, 0xc5, 0xec, 0x6a, 0xc2, 0xea, 0x7c, 0x9f, + 0x0f, 0xba, 0xc1, 0xa1, 0x1c, 0xaa, 0x3a, 0x2c, 0x69, 0xbe, 0xbf, 0xd7, 0x5c, 0x62, 0x3d, 0x65, 0xad, 0x48, 0xe0, + 0x46, 0x89, 0xf1, 0xee, 0xa0, 0xf2, 0xca, 0xdb, 0xef, 0xca, 0xc3, 0x9d, 0xf1, 0xee, 0x20, 0xf4, 0x4f, 0x74, 0x7f, + 0xaf, 0xf3, 0xd1, 0xfa, 0xbe, 0xd2, 0x7c, 0x14, 0xc8, 0xf3, 0xdf, 0xea, 0x42, 0x21, 0x63, 0xe7, 0xe5, 0x69, 0x6b, + 0x70, 0xa8, 0xb5, 0xad, 0x23, 0x43, 0xf7, 0xad, 0xfd, 0x8e, 0x39, 0x52, 0x9e, 0xe6, 0x23, 0xe0, 0x5d, 0xd5, 0xc4, + 0x1a, 0xa4, 0x11, 0xd7, 0x18, 0x77, 0x07, 0x87, 0x91, 0x23, 0xc5, 0x90, 0x94, 0x33, 0x85, 0xbf, 0x03, 0x8d, 0xc7, + 0xf9, 0x84, 0x7a, 0x2c, 0xdf, 0xb9, 0xa1, 0x57, 0xed, 0x68, 0xca, 0xea, 0x28, 0x42, 0x3e, 0xca, 0xeb, 0x21, 0xf3, + 0xa5, 0x94, 0xa7, 0x5e, 0xed, 0x4a, 0xdd, 0x03, 0xf3, 0xbe, 0x61, 0x38, 0x58, 0x60, 0xe5, 0x83, 0xc3, 0x9d, 0x68, + 0x09, 0x23, 0x92, 0x35, 0x4b, 0x1d, 0xcf, 0x00, 0x1b, 0xfe, 0x4a, 0xe6, 0x5b, 0x29, 0xbd, 0x61, 0xe2, 0x1e, 0x5a, + 0x9f, 0x97, 0xad, 0xc1, 0x9f, 0xff, 0xe9, 0x7f, 0xe9, 0x50, 0xc6, 0xe1, 0xce, 0xb8, 0x6b, 0xfa, 0x5a, 0x5a, 0x95, + 0xf2, 0x10, 0xee, 0x53, 0xa9, 0x03, 0xd2, 0xf4, 0xb6, 0x3d, 0xe2, 0x2c, 0x69, 0x8f, 0xa3, 0x74, 0xd8, 0x1a, 0xdc, + 0x8f, 0x4d, 0x95, 0x07, 0xd8, 0x36, 0xa1, 0xdc, 0xd5, 0x22, 0x20, 0xd8, 0x1f, 0x75, 0xb3, 0x80, 0x49, 0xb1, 0x02, + 0x1c, 0x55, 0xf7, 0x0c, 0x98, 0xd9, 0x29, 0x9e, 0x83, 0x68, 0x4f, 0x55, 0x6e, 0x3e, 0xd4, 0xa9, 0x85, 0x25, 0x6d, + 0x5c, 0x35, 0x50, 0xb6, 0x1c, 0x13, 0x1b, 0x6c, 0xfd, 0xfb, 0x3f, 0xff, 0xdd, 0x7f, 0x37, 0x8f, 0xc3, 0x21, 0x69, + 0xfd, 0xf9, 0x1f, 0xff, 0xf3, 0xff, 0xfe, 0xd7, 0xbf, 0x87, 0x7c, 0x30, 0x15, 0x16, 0x6c, 0x81, 0x90, 0x31, 0x8f, + 0x50, 0x21, 0x55, 0x20, 0xc0, 0xf1, 0xb1, 0x09, 0x2b, 0x04, 0x8b, 0x9b, 0x17, 0x11, 0x9c, 0xca, 0x01, 0x25, 0x6b, + 0x6a, 0xe8, 0x24, 0x5b, 0x97, 0x35, 0x41, 0x35, 0x50, 0x2e, 0x09, 0xb7, 0x84, 0xaf, 0xac, 0xb1, 0xec, 0x51, 0xd7, + 0x9e, 0x78, 0xd5, 0x6a, 0x54, 0x76, 0x28, 0x94, 0x94, 0x75, 0xb9, 0x03, 0x11, 0xac, 0x39, 0x3c, 0xfa, 0x3d, 0xab, + 0x58, 0x2e, 0xde, 0xfc, 0xe3, 0xac, 0x10, 0x6c, 0x08, 0x48, 0x56, 0x0e, 0x7e, 0x19, 0xec, 0x6e, 0x83, 0x11, 0x99, + 0xde, 0xf5, 0x9b, 0x1d, 0x42, 0x2f, 0x8a, 0x3e, 0xf7, 0x0e, 0x7e, 0x5e, 0xfe, 0x6a, 0x02, 0x76, 0x9b, 0xe3, 0xca, + 0x92, 0x43, 0xf2, 0xa4, 0xd3, 0x99, 0xde, 0xa2, 0x79, 0xdd, 0x3d, 0x5e, 0x1e, 0xa9, 0x69, 0xfc, 0x5a, 0xbd, 0x49, + 0xd3, 0xb8, 0x0a, 0x65, 0x74, 0x9c, 0x6e, 0x67, 0x7a, 0x5b, 0x96, 0xbf, 0x9c, 0x4b, 0x17, 0x3a, 0xfb, 0x01, 0xa2, + 0xe3, 0x3a, 0xe6, 0x70, 0x95, 0xdb, 0xf3, 0x9a, 0x5b, 0x6d, 0x20, 0xe0, 0x50, 0x8e, 0xbb, 0xab, 0xf7, 0x8b, 0xd8, + 0x81, 0x7d, 0x3b, 0x2a, 0xbf, 0x07, 0x71, 0xf6, 0x71, 0x17, 0x8f, 0x7b, 0xf3, 0xaa, 0x73, 0x21, 0xf2, 0x89, 0x1d, + 0xcc, 0xa7, 0x11, 0x8d, 0xe9, 0x50, 0x83, 0x66, 0xde, 0xab, 0x40, 0x7d, 0x39, 0xde, 0x5d, 0x33, 0x96, 0x06, 0x48, + 0x06, 0xf1, 0x9d, 0x4e, 0xf9, 0x15, 0x70, 0xde, 0x7c, 0x98, 0xe6, 0x91, 0xf0, 0x25, 0xa1, 0xf6, 0xed, 0x94, 0x80, + 0x08, 0x64, 0x51, 0xae, 0x5f, 0xcb, 0x5b, 0x64, 0x2c, 0xd0, 0x9a, 0x17, 0x14, 0x96, 0x9e, 0x6c, 0x6e, 0x77, 0xd5, + 0xbc, 0x37, 0x65, 0xb3, 0xe1, 0xdd, 0xd4, 0xea, 0x67, 0x39, 0x1c, 0xdf, 0xa8, 0xa4, 0xf4, 0xbf, 0x55, 0xe5, 0x2d, + 0x75, 0x43, 0x09, 0x70, 0xb8, 0x5c, 0x55, 0x16, 0x56, 0x55, 0x37, 0xad, 0xad, 0x49, 0x34, 0x9d, 0xca, 0xda, 0xa8, + 0x7f, 0xb8, 0xa3, 0x2c, 0x63, 0x10, 0x22, 0x32, 0xab, 0x44, 0x25, 0x71, 0xe8, 0x4a, 0x9a, 0x23, 0xd4, 0x2f, 0x9d, + 0xde, 0x01, 0x5f, 0x7e, 0x1d, 0xfc, 0x1f, 0xfe, 0x58, 0xb1, 0x62, 0x32, 0x92, 0x00, 0x00}; #else // Brotli (default, smaller) constexpr uint8_t INDEX_BR[] PROGMEM = { - 0x1b, 0x4d, 0x98, 0xa3, 0x10, 0xd8, 0x38, 0x00, 0x40, 0x74, 0x87, 0x5d, 0x14, 0x95, 0xac, 0x9e, 0x80, 0x5a, 0x16, - 0xd8, 0x44, 0x44, 0xed, 0xc1, 0xec, 0xbf, 0x23, 0x3c, 0x6d, 0x9a, 0x66, 0x3e, 0x6c, 0xc2, 0x28, 0x09, 0x3c, 0x6e, - 0x5f, 0x78, 0xfd, 0x3f, 0x03, 0xf2, 0xf9, 0xd8, 0x63, 0x23, 0xd6, 0x47, 0x4b, 0xb8, 0x52, 0xbd, 0x19, 0x5a, 0x7e, - 0xdb, 0x62, 0xfe, 0x45, 0xae, 0x2e, 0x1e, 0x2d, 0x75, 0x91, 0x2c, 0x66, 0xae, 0xa8, 0x95, 0x97, 0xe5, 0x64, 0x1c, - 0xa1, 0xb1, 0x4f, 0x72, 0x37, 0x53, 0xad, 0xd7, 0x77, 0xc5, 0xf3, 0xe4, 0xa0, 0x14, 0x9b, 0xb4, 0xb7, 0x34, 0x79, - 0x53, 0x5a, 0x99, 0x3d, 0x9b, 0xa1, 0x10, 0x13, 0x89, 0x05, 0x2a, 0x24, 0x94, 0xa6, 0xe4, 0xff, 0xb9, 0xff, 0x75, - 0xd9, 0xfb, 0x75, 0xa6, 0xa9, 0x98, 0x1b, 0x1f, 0x5b, 0x7a, 0x5c, 0x81, 0xb1, 0xb3, 0x0a, 0xae, 0xc9, 0xb2, 0xec, - 0x1e, 0x07, 0x18, 0x23, 0x63, 0x4e, 0x30, 0xf8, 0x20, 0x79, 0x99, 0x27, 0x6e, 0xfa, 0xe2, 0x57, 0x65, 0x8a, 0xea, - 0x5b, 0x96, 0x99, 0xfe, 0xf3, 0x79, 0x49, 0xca, 0x42, 0xe8, 0x32, 0x2b, 0xe3, 0xe3, 0xd9, 0xb3, 0x25, 0xe6, 0xbc, - 0x95, 0xbc, 0x08, 0x22, 0xcb, 0xac, 0xb8, 0x36, 0x11, 0x41, 0x34, 0xc4, 0xb6, 0x9d, 0x84, 0x6a, 0x33, 0x6d, 0x59, - 0xb5, 0x0e, 0xb0, 0xb4, 0x63, 0x81, 0x75, 0xba, 0x40, 0x8f, 0x35, 0x96, 0x4f, 0x21, 0x76, 0xb0, 0x49, 0x5c, 0x24, - 0xdf, 0x39, 0xe5, 0x80, 0xb5, 0x79, 0x5b, 0x9a, 0xb4, 0x82, 0x0b, 0x5c, 0xab, 0x35, 0x95, 0x7d, 0xa0, 0x4c, 0x23, - 0x72, 0x77, 0x0f, 0x25, 0x36, 0x0e, 0xd8, 0x95, 0x65, 0x67, 0xff, 0xde, 0x54, 0xab, 0xb4, 0x01, 0x9a, 0xb3, 0x36, - 0x35, 0x2e, 0x35, 0x4e, 0x19, 0xc4, 0x95, 0xce, 0xf9, 0x24, 0xb8, 0x20, 0x64, 0xbf, 0xf7, 0xfe, 0x7f, 0xcb, 0x76, - 0x18, 0xa2, 0xbb, 0x89, 0x1d, 0x38, 0x8d, 0xe8, 0xb0, 0xf4, 0x35, 0xb4, 0x72, 0x9c, 0xf9, 0xff, 0x77, 0x03, 0xec, - 0x06, 0x28, 0x2d, 0x40, 0x51, 0x5b, 0x24, 0x87, 0x5b, 0x25, 0xb7, 0xc6, 0x6b, 0xe6, 0xac, 0xd3, 0x4c, 0xd5, 0x69, - 0xce, 0xd9, 0xc8, 0x46, 0x89, 0xf1, 0xd9, 0x55, 0x6e, 0xa3, 0xd0, 0xd8, 0xf4, 0xb2, 0x0b, 0x2f, 0x3d, 0x9d, 0x63, - 0x9b, 0xa9, 0x66, 0x65, 0x06, 0x9c, 0xbf, 0x4d, 0x72, 0xd6, 0x90, 0x03, 0xc2, 0x41, 0xca, 0x7d, 0xd8, 0x75, 0x91, - 0x65, 0x59, 0x72, 0x91, 0x0b, 0x9b, 0x37, 0x91, 0xcd, 0x94, 0x37, 0xa3, 0x12, 0x2a, 0xa9, 0x25, 0xac, 0xdc, 0xc4, - 0xf4, 0xc4, 0xbd, 0x7f, 0x17, 0x64, 0x62, 0x6c, 0x71, 0x00, 0x3e, 0x05, 0x71, 0xe8, 0xc8, 0xa6, 0xeb, 0x1c, 0xe7, - 0x18, 0xbd, 0x61, 0x21, 0x98, 0x66, 0x7b, 0x08, 0x0e, 0x7d, 0x38, 0xb0, 0x01, 0x8d, 0x3c, 0xcf, 0x1d, 0x5e, 0x7d, - 0x60, 0xeb, 0x7e, 0xf9, 0x68, 0x18, 0xf4, 0x78, 0xb3, 0x2a, 0x01, 0xb7, 0x91, 0x43, 0xab, 0x65, 0x64, 0x23, 0x50, - 0xcd, 0x6a, 0xec, 0xe7, 0xf0, 0x67, 0xf3, 0x7f, 0x5f, 0x9c, 0x1c, 0x55, 0x14, 0x4c, 0xff, 0x84, 0xbe, 0xbd, 0xef, - 0xf0, 0x0a, 0xe9, 0x92, 0xb5, 0x05, 0xec, 0x67, 0x14, 0xe5, 0x61, 0xe4, 0xa1, 0x0a, 0x5e, 0x7b, 0xd9, 0x4d, 0x97, - 0x39, 0x9e, 0x19, 0x33, 0x36, 0x5d, 0x70, 0x3d, 0x30, 0x73, 0x65, 0xe5, 0x78, 0xb4, 0xa5, 0x1a, 0x9c, 0x67, 0x0a, - 0x0d, 0xda, 0x74, 0xa3, 0xe5, 0xf4, 0x21, 0x1e, 0x3f, 0x4c, 0x29, 0x3d, 0xf7, 0x93, 0xad, 0x2b, 0xe3, 0xbe, 0xb2, - 0x24, 0x6b, 0x3a, 0xfc, 0x39, 0xe7, 0xab, 0x09, 0x91, 0x84, 0x95, 0x9e, 0x46, 0xa4, 0x5c, 0x1d, 0x75, 0xdc, 0xb2, - 0x8c, 0xb2, 0xf4, 0xe6, 0x77, 0x94, 0x69, 0xd2, 0x96, 0x8a, 0x14, 0x88, 0x37, 0xd7, 0xf9, 0xc3, 0x64, 0xcc, 0xab, - 0xa6, 0x3e, 0x3e, 0x1e, 0x6f, 0x7b, 0x37, 0xb4, 0x6c, 0x78, 0x8e, 0x66, 0x3d, 0x98, 0xba, 0x7d, 0xf3, 0x59, 0x1a, - 0x37, 0xe3, 0xe6, 0x42, 0xb6, 0x36, 0xfd, 0x75, 0x1e, 0x3e, 0x85, 0xeb, 0x66, 0xec, 0x96, 0xe5, 0xa1, 0xc3, 0xcd, - 0x5c, 0x51, 0xb2, 0x7a, 0x68, 0x77, 0xd0, 0xe7, 0xaa, 0x4b, 0xb8, 0xe9, 0xe5, 0x22, 0xcc, 0xd7, 0x63, 0x6c, 0x52, - 0xd8, 0xae, 0x5a, 0xbe, 0x4e, 0x57, 0x28, 0x32, 0x13, 0x85, 0x8a, 0xff, 0x08, 0x65, 0xe5, 0xe5, 0x95, 0x9e, 0x8c, - 0x63, 0x3f, 0x17, 0x5c, 0x47, 0x58, 0x4d, 0x2d, 0x92, 0x70, 0xfb, 0xa7, 0xb9, 0x9f, 0x41, 0x01, 0xf9, 0xb7, 0xa6, - 0xa2, 0x30, 0x95, 0xf6, 0x73, 0x10, 0xf9, 0x28, 0x93, 0x31, 0x0c, 0x01, 0x8a, 0x4c, 0x47, 0x00, 0x9e, 0x79, 0x42, - 0x9e, 0x8e, 0xe7, 0x18, 0x25, 0x06, 0xde, 0xef, 0xf8, 0x7a, 0x79, 0xb4, 0x30, 0xdc, 0x08, 0xd2, 0x7e, 0xee, 0xa3, - 0x24, 0x57, 0x37, 0x28, 0x40, 0x76, 0x76, 0x0a, 0x92, 0x27, 0x05, 0x26, 0xd9, 0x35, 0xcb, 0x51, 0x26, 0xc8, 0x9b, - 0x8e, 0x43, 0x49, 0x43, 0x5f, 0xe3, 0x25, 0x29, 0xfe, 0xce, 0x27, 0x15, 0x2a, 0xc5, 0xdf, 0xba, 0x6b, 0x93, 0xa7, - 0x06, 0x00, 0x21, 0x9d, 0x66, 0xba, 0xde, 0xf8, 0x41, 0x90, 0xd8, 0x2d, 0x25, 0xa0, 0xe1, 0x8a, 0x99, 0x6c, 0x0a, - 0xeb, 0xbe, 0x36, 0x75, 0xba, 0x77, 0x29, 0x73, 0x78, 0x3c, 0xd3, 0x80, 0xc8, 0x8c, 0xd0, 0x70, 0x6a, 0x44, 0xd0, - 0x30, 0xca, 0x7b, 0x84, 0xdb, 0x54, 0x31, 0x7c, 0xc0, 0xe9, 0x87, 0x1b, 0x62, 0x59, 0xc0, 0x54, 0x08, 0xb4, 0xf6, - 0x36, 0x36, 0x9a, 0xaf, 0xa4, 0x21, 0x16, 0x93, 0x3f, 0xe3, 0x96, 0x36, 0xfe, 0x55, 0xd5, 0x84, 0x06, 0x48, 0x82, - 0xcf, 0xcf, 0xda, 0x21, 0x61, 0x8c, 0x26, 0x75, 0xb1, 0x49, 0x7a, 0x42, 0xca, 0x1c, 0x48, 0x20, 0xa1, 0x86, 0x4c, - 0xe1, 0x9c, 0x4d, 0x2e, 0xc7, 0x3b, 0xde, 0x3e, 0x08, 0x47, 0x6b, 0x4b, 0x62, 0x79, 0x23, 0x49, 0xa9, 0x86, 0xb7, - 0x86, 0x1a, 0x8e, 0x6d, 0xaa, 0x47, 0xcc, 0x4f, 0x71, 0xb7, 0xa7, 0x35, 0x8e, 0x25, 0x7d, 0x6e, 0x86, 0x4b, 0xb9, - 0x9b, 0xaf, 0xfa, 0x85, 0x60, 0x57, 0x12, 0x4d, 0x2a, 0x51, 0x85, 0x9f, 0x7f, 0xfd, 0x1d, 0xc8, 0x5a, 0x2d, 0x0f, - 0x53, 0xfc, 0x1c, 0xf8, 0x71, 0xac, 0x4c, 0x61, 0x3d, 0x48, 0x2f, 0xd5, 0xe9, 0x4d, 0x6d, 0xde, 0x91, 0x41, 0x2a, - 0xdc, 0x4a, 0xb0, 0xbf, 0x19, 0x21, 0x62, 0x87, 0x99, 0xf8, 0xd7, 0x8d, 0x84, 0x44, 0xd2, 0x85, 0xc2, 0x39, 0xab, - 0xe1, 0xe2, 0x3f, 0xa4, 0x0c, 0xd1, 0x9c, 0x10, 0x0d, 0x13, 0xc6, 0x57, 0x46, 0x29, 0x48, 0xef, 0xe6, 0xab, 0x4d, - 0xd3, 0x86, 0xee, 0x88, 0x3f, 0xa8, 0x57, 0xb9, 0x8e, 0xb1, 0x21, 0xf2, 0x55, 0x22, 0x79, 0xf6, 0x38, 0x0c, 0xe3, - 0x60, 0x39, 0xc1, 0x53, 0x95, 0x11, 0xfe, 0x75, 0xaa, 0x0a, 0xee, 0x39, 0x9a, 0x55, 0xce, 0xdd, 0x17, 0xb9, 0xe6, - 0x5b, 0x50, 0xe3, 0xf3, 0x66, 0x6e, 0x86, 0xca, 0x68, 0xeb, 0x58, 0x4b, 0x06, 0xc9, 0x95, 0x65, 0x57, 0x80, 0x8d, - 0xe9, 0x28, 0x8e, 0x2c, 0x5a, 0x60, 0x6c, 0xf6, 0xd7, 0x30, 0xfd, 0x4f, 0xd0, 0x09, 0x91, 0xb6, 0x97, 0x12, 0x6a, - 0x65, 0xc6, 0x0f, 0x46, 0xa8, 0xb7, 0xb2, 0xf3, 0x29, 0x8b, 0x20, 0xc3, 0xf7, 0xac, 0xe5, 0x39, 0x9c, 0xc7, 0xe1, - 0xe2, 0x49, 0xa9, 0xfd, 0x22, 0x5c, 0x76, 0xbb, 0x55, 0xa2, 0xb8, 0xd5, 0x08, 0x89, 0x0d, 0xd7, 0x3f, 0x51, 0xad, - 0x15, 0x0c, 0x57, 0x54, 0x5c, 0x6b, 0xad, 0xf5, 0x31, 0x76, 0x29, 0xa5, 0x6c, 0x4c, 0x4f, 0xff, 0x59, 0x4a, 0x7d, - 0xb5, 0x94, 0x94, 0x21, 0x26, 0xef, 0x09, 0x75, 0xc7, 0x49, 0x15, 0x0c, 0x0b, 0xcf, 0xdc, 0x52, 0x71, 0x26, 0x51, - 0x09, 0x06, 0x46, 0xe5, 0xb4, 0x3f, 0x78, 0xbe, 0xeb, 0x5d, 0xb0, 0x04, 0x88, 0xb7, 0xc8, 0xf5, 0xbf, 0x15, 0x05, - 0x2b, 0xe6, 0x56, 0x00, 0x4e, 0xcc, 0x82, 0x84, 0x2b, 0x3a, 0x18, 0x24, 0xd4, 0x1b, 0x98, 0xc9, 0x35, 0xa2, 0x77, - 0x82, 0xf5, 0x22, 0xb7, 0xfa, 0x25, 0x0a, 0xb9, 0x4d, 0x49, 0x45, 0x02, 0xb7, 0xd5, 0xda, 0x30, 0xcd, 0x7a, 0xa6, - 0x99, 0x38, 0x3d, 0x67, 0x31, 0x65, 0x76, 0xd4, 0x5c, 0xbb, 0xba, 0x04, 0xb3, 0xbb, 0x3b, 0x3d, 0x33, 0xf4, 0xc3, - 0x32, 0x44, 0xdf, 0xcd, 0xbe, 0x26, 0x49, 0x0c, 0xa9, 0x6c, 0xc3, 0xda, 0xf4, 0xff, 0x78, 0xda, 0x09, 0x05, 0x7f, - 0xad, 0xd5, 0x0d, 0xc4, 0xbd, 0x88, 0x4e, 0x5d, 0x4e, 0x84, 0xf9, 0xfa, 0x62, 0x60, 0x3f, 0x29, 0x67, 0xb8, 0x46, - 0x3c, 0xb2, 0xb1, 0x37, 0xd4, 0x5b, 0x23, 0x5a, 0x86, 0xe4, 0xf3, 0x7e, 0x95, 0xf6, 0x0d, 0x65, 0x66, 0x5f, 0xec, - 0x87, 0x8b, 0x77, 0xda, 0x4c, 0x0e, 0xb8, 0xd3, 0xd0, 0xf3, 0xa6, 0xf9, 0x06, 0xf2, 0xac, 0x3d, 0x38, 0x61, 0x4f, - 0x27, 0xdd, 0xe9, 0xc6, 0xd5, 0x24, 0x6b, 0xe3, 0xa1, 0xc4, 0x90, 0xc0, 0xaf, 0x59, 0x4e, 0x00, 0x39, 0x10, 0x7b, - 0xc4, 0xda, 0xe4, 0x52, 0xb8, 0x7e, 0xa3, 0x45, 0x37, 0x30, 0xaf, 0x9b, 0xbf, 0xc8, 0x21, 0x95, 0xc5, 0x1b, 0x10, - 0x32, 0x32, 0x3f, 0xa3, 0x1c, 0x59, 0xc1, 0xa3, 0xf2, 0xf5, 0x21, 0x52, 0x87, 0x2f, 0xaf, 0xf6, 0x43, 0x63, 0xdf, - 0x22, 0xf3, 0xa2, 0x68, 0x2a, 0x33, 0x47, 0xb9, 0x0f, 0x90, 0xc4, 0x92, 0x67, 0x58, 0x61, 0x7c, 0xd5, 0xda, 0x88, - 0x08, 0xbe, 0x11, 0xc0, 0x7e, 0xf7, 0x49, 0x70, 0x6c, 0x63, 0x12, 0x28, 0xd0, 0xee, 0x66, 0x20, 0x41, 0x01, 0x99, - 0x38, 0x92, 0xd4, 0x8e, 0x06, 0x89, 0xfd, 0x09, 0xda, 0x76, 0x71, 0x45, 0x24, 0x1b, 0xfb, 0x39, 0x60, 0x21, 0x8d, - 0x0f, 0xa8, 0xcc, 0x80, 0x08, 0x4b, 0x01, 0x3a, 0x7a, 0xfe, 0xa9, 0x42, 0x5c, 0xcd, 0xb0, 0xf0, 0x9c, 0xc1, 0x5d, - 0x99, 0xaf, 0xfb, 0x79, 0xf6, 0xe0, 0x4c, 0x05, 0xc4, 0xe3, 0x89, 0x5f, 0x6e, 0x17, 0x28, 0x32, 0x10, 0xb4, 0x42, - 0x3c, 0x14, 0x84, 0x16, 0x8a, 0x18, 0xb4, 0xf9, 0x8f, 0x7d, 0xae, 0x8a, 0x91, 0x0a, 0x85, 0xa8, 0x68, 0x4d, 0xc6, - 0x70, 0x45, 0x9d, 0x23, 0x06, 0xdf, 0xcc, 0xd8, 0xa1, 0x65, 0xa2, 0x52, 0xbe, 0x54, 0xf1, 0x58, 0x07, 0xeb, 0x89, - 0x14, 0x32, 0x32, 0x52, 0x93, 0x9d, 0x6f, 0x21, 0x49, 0xf0, 0x4e, 0xad, 0x3c, 0x83, 0x14, 0x5e, 0xe9, 0xb0, 0x4f, - 0xa2, 0x5f, 0x86, 0x28, 0x8c, 0xda, 0xd7, 0x94, 0xbe, 0x9a, 0x89, 0xc4, 0xd8, 0x13, 0x79, 0x50, 0xa2, 0xe5, 0x1f, - 0xd9, 0x84, 0x91, 0x84, 0xe4, 0xd8, 0xf3, 0xe1, 0xdf, 0xe7, 0x04, 0xe9, 0xe3, 0xac, 0x87, 0xb4, 0x25, 0x11, 0x3e, - 0x51, 0x96, 0x03, 0xba, 0xee, 0x80, 0xa4, 0x00, 0xde, 0x75, 0xc1, 0xed, 0x7d, 0xdb, 0x21, 0x8e, 0x4e, 0xce, 0xa9, - 0x19, 0xe3, 0x65, 0x0a, 0x1b, 0x39, 0x1c, 0x6f, 0x93, 0x20, 0x6c, 0x44, 0xaf, 0x4c, 0xd3, 0xb1, 0xc0, 0x2c, 0x81, - 0x44, 0x88, 0xf4, 0x7e, 0x71, 0xce, 0x85, 0x98, 0xd7, 0x49, 0x66, 0xa8, 0x78, 0x6a, 0x95, 0xa9, 0x09, 0x32, 0x1c, - 0xe7, 0x2a, 0xbe, 0x27, 0x29, 0xc9, 0x13, 0xee, 0x62, 0xb2, 0x5f, 0x61, 0x1d, 0x25, 0x4f, 0x49, 0x41, 0xc9, 0xa8, - 0xe1, 0x7f, 0x99, 0xd2, 0x44, 0x62, 0x57, 0x76, 0x87, 0x24, 0x80, 0x94, 0x60, 0xa9, 0xce, 0xe0, 0x71, 0x44, 0x3c, - 0x17, 0x82, 0x86, 0x88, 0x44, 0xe1, 0x33, 0xdb, 0xcb, 0xcf, 0x22, 0x87, 0x04, 0xcf, 0x4c, 0x89, 0xce, 0xe2, 0x0f, - 0xd6, 0x71, 0x8f, 0x8c, 0x37, 0x1a, 0x46, 0x35, 0xaf, 0x0f, 0xda, 0x3e, 0x62, 0x6e, 0x7a, 0xfe, 0x30, 0x30, 0xd3, - 0xb1, 0xc9, 0x26, 0x95, 0x70, 0x56, 0x6e, 0xfe, 0xc6, 0x05, 0x8a, 0x8d, 0x5a, 0xa1, 0xe5, 0x67, 0x3d, 0xb5, 0x21, - 0xea, 0x9c, 0x13, 0xe2, 0x80, 0x03, 0x56, 0xb3, 0x60, 0x9e, 0x6b, 0xfc, 0xcf, 0x65, 0x72, 0x97, 0x1c, 0xc1, 0x99, - 0x1b, 0x4b, 0x73, 0x79, 0x15, 0xc9, 0xa1, 0x0b, 0xb6, 0x02, 0x55, 0x40, 0x39, 0xc9, 0x18, 0x23, 0xcb, 0x01, 0x23, - 0x96, 0x48, 0x2e, 0x17, 0x20, 0xb4, 0xc8, 0xba, 0x0a, 0xc2, 0x50, 0xa8, 0x9c, 0x46, 0xda, 0x70, 0x28, 0xe3, 0x18, - 0x99, 0xd6, 0x55, 0xdf, 0x19, 0x42, 0x96, 0xf2, 0xae, 0x01, 0xed, 0x28, 0x95, 0xbc, 0x94, 0xef, 0xa2, 0xdc, 0x9d, - 0xf0, 0x52, 0x18, 0x20, 0xcf, 0x1f, 0x15, 0x1b, 0x75, 0x47, 0x81, 0x17, 0x83, 0xf1, 0x42, 0x96, 0x0d, 0x77, 0x52, - 0xc9, 0x12, 0x13, 0x25, 0x08, 0x9c, 0x32, 0xd2, 0xd8, 0xa7, 0x2c, 0xed, 0xca, 0xfb, 0x2b, 0x4c, 0x2c, 0x4f, 0xca, - 0x28, 0x46, 0x3c, 0x39, 0xab, 0xb2, 0xae, 0x59, 0x3c, 0xc4, 0xfc, 0xc9, 0xdb, 0x24, 0xe5, 0x37, 0x3d, 0xd3, 0xe8, - 0x8d, 0x49, 0x67, 0x0d, 0x39, 0x9c, 0x4e, 0xc5, 0xe9, 0xec, 0x59, 0x5c, 0x35, 0x48, 0x55, 0x40, 0x11, 0x08, 0x87, - 0x3c, 0xf9, 0x26, 0x33, 0xda, 0x37, 0x01, 0x4b, 0xa5, 0x63, 0x28, 0x4f, 0xaa, 0x31, 0x26, 0x24, 0x2d, 0xf7, 0x3f, - 0x82, 0xe2, 0x4a, 0x8d, 0x24, 0x4b, 0xf0, 0xe1, 0x1d, 0x4a, 0x08, 0x4a, 0xc9, 0xa1, 0x83, 0x6e, 0x43, 0x45, 0x13, - 0x28, 0xa2, 0x27, 0x41, 0x9e, 0xaf, 0x37, 0x76, 0xaa, 0x14, 0x03, 0x9c, 0x98, 0xec, 0xca, 0xe3, 0x68, 0x66, 0x95, - 0x3e, 0xfb, 0x4f, 0x11, 0x1c, 0x0e, 0x87, 0x17, 0x34, 0x48, 0xa4, 0xf7, 0x5c, 0x91, 0x9b, 0x5a, 0x70, 0x7e, 0xba, - 0x10, 0x93, 0x59, 0x5b, 0x16, 0xd2, 0x72, 0x84, 0x62, 0x24, 0x87, 0x8e, 0xc0, 0xb6, 0x0c, 0xb9, 0xad, 0x91, 0xc8, - 0xe4, 0x5b, 0xfe, 0x1d, 0x87, 0x4c, 0x52, 0x32, 0xa5, 0xc9, 0x78, 0x2f, 0xa7, 0x22, 0xbb, 0x12, 0x45, 0x25, 0x32, - 0x2a, 0xa6, 0x41, 0x0c, 0xa9, 0xac, 0xde, 0xd3, 0x82, 0xa5, 0xba, 0x23, 0xb8, 0x3b, 0x27, 0xa4, 0x60, 0x19, 0x54, - 0xdd, 0x8e, 0xce, 0x38, 0xda, 0x20, 0x66, 0x5d, 0x92, 0xec, 0x27, 0xc5, 0x20, 0x9b, 0x48, 0xa1, 0x44, 0x3d, 0x61, - 0x37, 0x6e, 0x4b, 0x08, 0xfb, 0xdd, 0xc0, 0xc4, 0xd2, 0xb2, 0x4c, 0x93, 0x3e, 0x45, 0x62, 0xa7, 0x14, 0x8f, 0x50, - 0xf9, 0x14, 0xba, 0x77, 0xd3, 0x48, 0x48, 0x75, 0x92, 0x27, 0x08, 0xda, 0x73, 0x30, 0x76, 0x4c, 0xc0, 0x7c, 0x7f, - 0x0a, 0xd6, 0x8f, 0xd3, 0xb4, 0x60, 0xe1, 0xe0, 0x21, 0xc5, 0x9e, 0x99, 0xdd, 0xfc, 0xcb, 0x7c, 0x8e, 0x72, 0xce, - 0x0c, 0x9d, 0xcc, 0x53, 0x48, 0x66, 0xe3, 0xec, 0xe4, 0x5f, 0x90, 0xe6, 0xbd, 0x83, 0xdd, 0x91, 0xb6, 0xe1, 0xf7, - 0x99, 0xe0, 0xfa, 0x44, 0x0e, 0x23, 0xf8, 0xaa, 0x4b, 0x62, 0x37, 0x1f, 0x23, 0x8c, 0x22, 0x45, 0xaf, 0x1d, 0x07, - 0xe2, 0xb2, 0xda, 0x7d, 0x79, 0x10, 0x00, 0xb0, 0xa8, 0xf4, 0xef, 0x95, 0x88, 0x4c, 0xcc, 0x83, 0x5c, 0x06, 0x5b, - 0x19, 0xf0, 0xb3, 0x4a, 0xe2, 0x01, 0x97, 0x80, 0x4b, 0xe8, 0xb3, 0x02, 0x66, 0xa8, 0x01, 0xd4, 0xde, 0x79, 0x53, - 0x18, 0x46, 0x3a, 0x68, 0x4e, 0xb5, 0x86, 0xe2, 0x2d, 0x8a, 0x28, 0x1f, 0xfa, 0xb0, 0xf7, 0x61, 0x91, 0x01, 0x1d, - 0xfc, 0x38, 0x33, 0xa1, 0x3c, 0x4c, 0x9a, 0x31, 0x9a, 0x98, 0xe7, 0x19, 0xc5, 0xbd, 0xe1, 0xc2, 0xa4, 0xb7, 0x24, - 0x10, 0xd3, 0xbe, 0x6f, 0x4b, 0x45, 0x7c, 0xbf, 0x1b, 0x97, 0xfe, 0xd5, 0x7a, 0x04, 0xbd, 0x64, 0x16, 0x4a, 0xe4, - 0x5b, 0x2a, 0xd4, 0x91, 0x07, 0x86, 0xdb, 0x76, 0x6c, 0x98, 0x75, 0xa7, 0x95, 0xf4, 0x7a, 0x55, 0x35, 0xec, 0x80, - 0x71, 0x54, 0x5a, 0x7a, 0xaa, 0x5f, 0x1c, 0xd4, 0xe4, 0xf5, 0x62, 0xfd, 0xd5, 0x8e, 0xbd, 0x3c, 0x01, 0x99, 0x19, - 0xa3, 0xc1, 0x9c, 0x92, 0xc6, 0x0e, 0xa8, 0x85, 0x34, 0x94, 0x75, 0xb8, 0x8b, 0xa7, 0xb5, 0x12, 0x0e, 0x44, 0xe0, - 0x6c, 0xba, 0x4d, 0xac, 0x97, 0xdc, 0x0f, 0x1d, 0x40, 0x19, 0x1d, 0x3e, 0x77, 0x9b, 0x5a, 0x0c, 0xeb, 0x01, 0x6f, - 0x10, 0xd1, 0x42, 0x93, 0x0a, 0x2e, 0xb1, 0x43, 0xca, 0xa6, 0xca, 0xd0, 0x41, 0xe7, 0x5c, 0x53, 0x66, 0x65, 0xa5, - 0xf2, 0x2e, 0xaf, 0xa4, 0x9f, 0x66, 0x21, 0x1b, 0xeb, 0x2a, 0x68, 0x2c, 0xc8, 0x6f, 0x21, 0x00, 0xce, 0xa3, 0x99, - 0xbe, 0xd9, 0x00, 0x73, 0xb2, 0x64, 0xf9, 0xad, 0x3c, 0xaa, 0x2c, 0x56, 0xee, 0x2d, 0x47, 0xea, 0xc8, 0xc8, 0xa4, - 0xef, 0x4a, 0x01, 0x92, 0x0e, 0xc6, 0xe5, 0x8e, 0xd5, 0x9e, 0x31, 0x25, 0xba, 0x5f, 0x30, 0xc4, 0xda, 0xe1, 0xf0, - 0xcb, 0x91, 0xc3, 0xa1, 0x66, 0x90, 0x1d, 0x69, 0xf4, 0x20, 0x45, 0xf0, 0x22, 0x57, 0xb8, 0xe2, 0x8f, 0x65, 0xdb, - 0x96, 0x08, 0xe2, 0x29, 0xc2, 0xdf, 0x33, 0x49, 0xe8, 0xe3, 0x01, 0xa1, 0xbb, 0x90, 0xf6, 0xf9, 0x34, 0x93, 0xf5, - 0x23, 0x94, 0x91, 0x64, 0xfa, 0x3e, 0xd4, 0x54, 0xa6, 0xc1, 0x37, 0xbf, 0xe6, 0xa9, 0x41, 0xe5, 0x36, 0x98, 0x44, - 0x83, 0x92, 0x3b, 0x07, 0x18, 0x7e, 0xa4, 0x5c, 0xd5, 0xab, 0xa2, 0x93, 0x56, 0x66, 0x6a, 0x7f, 0x90, 0x39, 0x02, - 0x93, 0xd3, 0x43, 0x33, 0xd2, 0x40, 0x88, 0x00, 0x2f, 0x10, 0x88, 0xbc, 0x04, 0xca, 0x00, 0xb6, 0xe9, 0x5e, 0x1b, - 0x34, 0xc6, 0xe3, 0xf1, 0x33, 0xa2, 0x98, 0x48, 0x2a, 0xdf, 0x13, 0xc7, 0xd1, 0x68, 0xb1, 0x88, 0x54, 0xd0, 0x84, - 0x62, 0x06, 0xfe, 0xdc, 0x7c, 0xb0, 0x3c, 0xeb, 0x7d, 0xd6, 0x0c, 0x63, 0x4c, 0xb3, 0x74, 0xd3, 0x26, 0xe7, 0xc8, - 0xdd, 0x4f, 0x58, 0x5a, 0x33, 0x42, 0x46, 0x09, 0x9b, 0x32, 0xb4, 0xea, 0x5a, 0x57, 0x8a, 0x63, 0x38, 0x46, 0xe3, - 0xfc, 0x1d, 0x59, 0x74, 0xf8, 0x53, 0x8d, 0x4f, 0x1f, 0x63, 0xa4, 0xe5, 0xf9, 0xd9, 0xb7, 0x09, 0xc4, 0x2f, 0xa3, - 0x1a, 0x75, 0x25, 0xc2, 0xa2, 0x65, 0x82, 0xd4, 0x61, 0x43, 0x2f, 0x23, 0x5e, 0x5e, 0xb3, 0xb8, 0x23, 0x41, 0x0f, - 0x4a, 0xec, 0x89, 0x86, 0xd4, 0xed, 0x99, 0xd8, 0xda, 0x26, 0xf5, 0xfa, 0xf3, 0xc9, 0x4f, 0xf3, 0x64, 0x7f, 0x5c, - 0x26, 0x75, 0x8e, 0x0a, 0xc4, 0x51, 0x7b, 0xbb, 0xcc, 0x77, 0xc6, 0x5c, 0x79, 0xf4, 0xdd, 0x56, 0x32, 0x46, 0xd1, - 0x8c, 0xb4, 0x6c, 0x1c, 0x18, 0xd5, 0xc5, 0x0e, 0xd5, 0x77, 0x0a, 0xcb, 0x8f, 0xaf, 0xe4, 0xc8, 0x23, 0x4a, 0x02, - 0x55, 0xd7, 0x8f, 0x24, 0x94, 0x86, 0x71, 0x7e, 0x35, 0xd6, 0x3e, 0x26, 0xd7, 0x06, 0xc5, 0xd2, 0x9e, 0xc7, 0x8c, - 0x8f, 0xb8, 0xf9, 0xcb, 0xb5, 0x1e, 0x64, 0x45, 0xed, 0x39, 0xf1, 0x74, 0xd4, 0xa1, 0x6d, 0x16, 0x93, 0x4d, 0x30, - 0xc0, 0x07, 0x68, 0xc2, 0xda, 0x63, 0x51, 0xeb, 0x8f, 0xc1, 0xd7, 0x3e, 0x40, 0x80, 0x6b, 0x21, 0xac, 0x9c, 0xa2, - 0x40, 0xe9, 0xda, 0x96, 0x5c, 0x1f, 0xef, 0xda, 0xfd, 0x28, 0x23, 0x91, 0xed, 0x2a, 0x29, 0x51, 0x6c, 0xa7, 0x29, - 0xf5, 0x77, 0x4a, 0x7d, 0xf0, 0x28, 0x22, 0x3e, 0xe3, 0x44, 0x8f, 0x4f, 0x56, 0xdd, 0x3c, 0x69, 0x4f, 0x7a, 0xa1, - 0x74, 0x03, 0x5e, 0x5c, 0x56, 0xdd, 0x14, 0x9f, 0x1c, 0x7b, 0x29, 0x62, 0x6b, 0x09, 0xb2, 0x45, 0x14, 0x6d, 0x07, - 0x39, 0xe4, 0x7b, 0x16, 0x29, 0xa4, 0x66, 0xd3, 0x29, 0xee, 0x00, 0x3b, 0xc5, 0x78, 0xe5, 0x88, 0x59, 0xab, 0xc9, - 0x9c, 0x6b, 0x14, 0xc8, 0xcb, 0xa0, 0xea, 0xf7, 0xf6, 0x03, 0x79, 0x37, 0x9e, 0x3f, 0x09, 0xa9, 0x5c, 0x85, 0x9d, - 0xf9, 0xbd, 0xd0, 0xf8, 0x77, 0xa7, 0x3d, 0x89, 0x3c, 0x3c, 0xcc, 0x2f, 0x49, 0xef, 0xf7, 0x71, 0x5f, 0x90, 0x6b, - 0xf8, 0x59, 0x88, 0x84, 0x26, 0x7e, 0xb3, 0x29, 0x90, 0x3c, 0x56, 0x08, 0xb8, 0x50, 0x49, 0x35, 0x8b, 0xb5, 0x25, - 0x9c, 0xd3, 0x83, 0xfb, 0x19, 0x73, 0xee, 0x30, 0x3c, 0xc8, 0x95, 0xd0, 0xb8, 0xbc, 0xc6, 0xdd, 0xa0, 0xb6, 0xfe, - 0x45, 0x58, 0xc2, 0x6b, 0x64, 0x89, 0xb4, 0x2c, 0x9f, 0x51, 0xea, 0x04, 0x0d, 0x5f, 0xba, 0x50, 0x8c, 0xd7, 0x21, - 0x4e, 0xf5, 0x10, 0xdd, 0xdf, 0xb7, 0x23, 0xb5, 0x32, 0xde, 0x7e, 0x7a, 0xe3, 0xe1, 0xe9, 0xf0, 0x34, 0xee, 0x4a, - 0x3c, 0xa3, 0x5e, 0x06, 0x7f, 0x34, 0x64, 0x4a, 0x4d, 0x4f, 0xf1, 0xf6, 0xbf, 0x4a, 0xbd, 0xfe, 0x70, 0xe1, 0x7a, - 0x87, 0x49, 0x20, 0x9f, 0x94, 0x6f, 0x27, 0x53, 0xab, 0x9b, 0x27, 0xbb, 0x7b, 0xf5, 0xfc, 0x33, 0xcf, 0xa4, 0x8c, - 0x1b, 0x9c, 0x38, 0xea, 0x29, 0xb5, 0x89, 0x0a, 0x15, 0x3c, 0x47, 0xcf, 0x74, 0x6b, 0x7b, 0xdc, 0x3c, 0xde, 0x4c, - 0x33, 0x7f, 0xc4, 0x94, 0x27, 0xc5, 0xd6, 0xd3, 0x8d, 0x50, 0x6e, 0x28, 0xde, 0x85, 0x52, 0xd8, 0x84, 0xcf, 0xe8, - 0x3f, 0x9b, 0x30, 0x59, 0x45, 0x48, 0xfe, 0x40, 0xa0, 0x7c, 0x2a, 0xb3, 0x21, 0xed, 0x26, 0xa1, 0xa6, 0x85, 0x9c, - 0xa4, 0x9c, 0x66, 0xb2, 0x44, 0xd5, 0x00, 0x70, 0xe4, 0xa8, 0xb7, 0x88, 0x1b, 0xbc, 0xf3, 0x0b, 0x50, 0x38, 0x98, - 0xfa, 0x5b, 0x4f, 0xa2, 0x36, 0x77, 0x92, 0x72, 0x04, 0x93, 0xa2, 0xd8, 0x9d, 0x14, 0xb6, 0x5b, 0xe4, 0x2c, 0x6e, - 0xf1, 0x21, 0xa9, 0x2a, 0x42, 0x64, 0x31, 0x30, 0xc4, 0xab, 0x89, 0x76, 0x94, 0xe1, 0xc0, 0x37, 0x0b, 0x33, 0x9d, - 0xf0, 0xea, 0xb1, 0x8b, 0x04, 0x95, 0xc2, 0xcf, 0xd2, 0xc8, 0x12, 0xa7, 0xf4, 0xe0, 0x84, 0x01, 0xb7, 0xdc, 0x8a, - 0xd5, 0xf7, 0x57, 0x94, 0x99, 0x50, 0x9a, 0x89, 0xb1, 0xa2, 0x7e, 0x40, 0xc0, 0x3d, 0x49, 0x98, 0x78, 0x22, 0xf4, - 0xd6, 0x76, 0xcd, 0x3f, 0xa9, 0x3e, 0x5b, 0xf8, 0x42, 0x6c, 0x01, 0xf3, 0x86, 0xc0, 0x04, 0x1a, 0x37, 0x9b, 0x51, - 0x2c, 0xa1, 0xf1, 0x03, 0xca, 0xa2, 0xdb, 0x59, 0x82, 0xaa, 0xb7, 0x8a, 0x0e, 0x43, 0x5d, 0x00, 0x2d, 0xad, 0x9e, - 0xfd, 0x98, 0xeb, 0x7d, 0x1e, 0xe5, 0x56, 0x1f, 0x60, 0xac, 0x6e, 0x00, 0x1d, 0x69, 0xd8, 0xf6, 0x6a, 0x78, 0xb9, - 0xa7, 0x9a, 0x88, 0x33, 0x9e, 0x2c, 0xaf, 0x0c, 0xfd, 0x86, 0x6c, 0x3d, 0xee, 0x3c, 0x51, 0xbb, 0xa8, 0xbc, 0xec, - 0x00, 0x91, 0x5a, 0x58, 0xd9, 0x8c, 0x7a, 0x81, 0x64, 0x5d, 0xdf, 0xac, 0x4a, 0x48, 0xd2, 0x23, 0xec, 0x13, 0xfe, - 0x7a, 0x19, 0x49, 0xa8, 0xa0, 0xd5, 0x4c, 0x65, 0xe9, 0xda, 0x6c, 0x40, 0x2b, 0xc0, 0x40, 0x67, 0xe2, 0x21, 0x70, - 0xf4, 0xba, 0x5e, 0x7a, 0xe4, 0x33, 0x4c, 0x7d, 0x18, 0x4a, 0x6a, 0x96, 0x8d, 0xb6, 0x9e, 0xc4, 0xcf, 0xe9, 0x58, - 0x62, 0x43, 0x0b, 0x09, 0x6b, 0xd2, 0xde, 0x16, 0x7e, 0xd5, 0x99, 0xdd, 0xd4, 0xfb, 0xce, 0xe7, 0x22, 0x44, 0x58, - 0x79, 0x7e, 0x51, 0xaa, 0xb1, 0xa4, 0x10, 0xe1, 0xdd, 0xec, 0x85, 0x95, 0x58, 0xd6, 0x36, 0xef, 0x2b, 0xd3, 0xfc, - 0x4c, 0x4e, 0x7f, 0xed, 0x18, 0xa8, 0xa0, 0x5f, 0xf3, 0x72, 0x6b, 0x76, 0x22, 0x82, 0x47, 0xa5, 0x20, 0x1f, 0x68, - 0xe2, 0xb4, 0x29, 0x47, 0xdd, 0xbe, 0x8b, 0x55, 0x69, 0xbf, 0x01, 0x07, 0x6e, 0xff, 0x0d, 0xb0, 0x02, 0x29, 0x40, - 0xc0, 0xcc, 0xbd, 0xac, 0xb2, 0x1e, 0x84, 0x36, 0xc8, 0xa0, 0xcf, 0x49, 0xfc, 0xc1, 0xc7, 0x3d, 0xcb, 0x92, 0x81, - 0xad, 0x40, 0x0b, 0x08, 0x40, 0xe1, 0x36, 0xa2, 0x9f, 0xdf, 0x40, 0xbe, 0x62, 0x7e, 0xd4, 0xe0, 0x84, 0xfa, 0x2c, - 0xba, 0x2e, 0x82, 0xf3, 0x31, 0xb2, 0xf1, 0x07, 0x56, 0x43, 0x68, 0x22, 0xe2, 0xa8, 0x0d, 0x8a, 0x94, 0xa8, 0xa1, - 0x23, 0x3f, 0x35, 0x06, 0xda, 0xaa, 0xe2, 0x35, 0x7e, 0xd6, 0x66, 0xb7, 0x2e, 0x60, 0x91, 0x1f, 0x9c, 0x1e, 0xb9, - 0x20, 0xcc, 0x1e, 0xdc, 0x34, 0xfd, 0xbf, 0xa5, 0x70, 0xf9, 0x40, 0xcf, 0xc6, 0x63, 0x4d, 0xf1, 0x54, 0x39, 0xd3, - 0xc1, 0x8d, 0x91, 0x1f, 0xa5, 0xce, 0x21, 0xac, 0x14, 0xfe, 0x5b, 0xe6, 0x73, 0xbb, 0xf5, 0x61, 0xb2, 0xbb, 0x2c, - 0x88, 0xe0, 0xe2, 0x92, 0xbd, 0x41, 0xc5, 0x1b, 0x90, 0x39, 0x04, 0xd9, 0x3b, 0x9f, 0x6a, 0x7f, 0x6c, 0x28, 0x95, - 0x5f, 0xd7, 0x36, 0xdf, 0x86, 0x37, 0x07, 0xe9, 0x16, 0x48, 0xac, 0xd7, 0x04, 0x6d, 0xe5, 0xf9, 0x12, 0xcd, 0x06, - 0x0d, 0x45, 0x63, 0x66, 0xf7, 0x17, 0x75, 0xe6, 0x2a, 0xb8, 0x75, 0xf7, 0x42, 0xa3, 0xa2, 0x58, 0xe8, 0x7b, 0x95, - 0x4d, 0xe0, 0xa2, 0x87, 0x57, 0x32, 0x4f, 0xb7, 0x2b, 0x12, 0xb5, 0xd8, 0x08, 0x31, 0xcb, 0x1b, 0xdc, 0xde, 0x55, - 0xf6, 0x67, 0xb8, 0x93, 0x0d, 0x30, 0x5b, 0xd0, 0x5b, 0x76, 0x48, 0x90, 0xfa, 0xd4, 0x29, 0xe5, 0x97, 0xf5, 0x47, - 0x99, 0xb6, 0xc0, 0xab, 0xf5, 0x40, 0x15, 0x73, 0x30, 0x43, 0x9d, 0x56, 0xdc, 0xeb, 0x44, 0x32, 0xf4, 0xae, 0x28, - 0xcd, 0x20, 0x11, 0xf6, 0x09, 0x2f, 0x61, 0xfa, 0x01, 0x2b, 0x2f, 0xb7, 0xf0, 0xc6, 0xb1, 0xec, 0xb5, 0x3a, 0x28, - 0x09, 0xaa, 0x80, 0xfc, 0x61, 0x78, 0xd6, 0xb2, 0x26, 0x77, 0x87, 0x23, 0x81, 0x2f, 0x17, 0x32, 0x11, 0xcc, 0x0d, - 0xe4, 0xcb, 0xb9, 0xb8, 0x10, 0x89, 0x2a, 0xc4, 0x78, 0xc9, 0xd2, 0xd1, 0xbb, 0x71, 0xd2, 0xa8, 0xd5, 0xf4, 0xa1, - 0x50, 0x71, 0x1b, 0xd7, 0x7a, 0x74, 0xbc, 0x60, 0x39, 0x1b, 0x8d, 0xee, 0x8a, 0x75, 0x4b, 0x79, 0x0b, 0xa5, 0x11, - 0x36, 0x52, 0x5f, 0x90, 0x65, 0x69, 0x16, 0x58, 0x2f, 0xc0, 0x16, 0xc1, 0x62, 0xc0, 0xf2, 0xd6, 0x59, 0x16, 0xb1, - 0xfa, 0xbd, 0xaf, 0x55, 0x8e, 0xc3, 0x90, 0x25, 0x21, 0x89, 0xe6, 0x55, 0x14, 0xc6, 0x18, 0x6a, 0x1c, 0x4d, 0x51, - 0xa5, 0x84, 0x31, 0x77, 0x23, 0xc3, 0x2e, 0xd6, 0x39, 0xc6, 0xd2, 0x48, 0xd2, 0xf0, 0x4d, 0x39, 0xa6, 0x27, 0xab, - 0xb1, 0x36, 0x22, 0x1b, 0x39, 0x34, 0x9e, 0xcb, 0xd5, 0x8c, 0x55, 0xee, 0xd0, 0xdd, 0x5a, 0xa9, 0xec, 0x42, 0x13, - 0x0a, 0xa3, 0xbd, 0xc6, 0x35, 0xc9, 0xa2, 0x5d, 0x83, 0x55, 0xfa, 0x92, 0x66, 0x8f, 0x38, 0x94, 0x6f, 0xc3, 0x56, - 0x55, 0xea, 0x02, 0xcd, 0xf9, 0xd0, 0x2b, 0xfc, 0x8d, 0x74, 0x72, 0x8e, 0x8a, 0x1e, 0xdc, 0x74, 0xdb, 0xc5, 0xbf, - 0x68, 0xa1, 0xfb, 0x2c, 0x7f, 0xce, 0x3c, 0x16, 0x2a, 0x54, 0xab, 0xab, 0x89, 0x2d, 0x99, 0xa1, 0xe1, 0x6b, 0x02, - 0xae, 0x44, 0xbe, 0x18, 0x60, 0x67, 0x94, 0xce, 0x25, 0xed, 0x54, 0x0e, 0x49, 0x4b, 0x36, 0x4e, 0xdc, 0x64, 0x23, - 0xda, 0xe5, 0x8f, 0xb1, 0xc5, 0xca, 0x4b, 0xd6, 0xad, 0x0f, 0xac, 0xf3, 0xf8, 0x3c, 0xab, 0xbc, 0x75, 0x6f, 0xc6, - 0xbf, 0xda, 0x0c, 0x13, 0xf6, 0xce, 0x6e, 0x70, 0xa9, 0xec, 0xd8, 0xa8, 0x91, 0xd3, 0x13, 0x3b, 0x5a, 0xe6, 0x22, - 0xc3, 0x6b, 0xb4, 0xaa, 0xb1, 0x90, 0xe3, 0x16, 0x7e, 0x0e, 0x34, 0x12, 0x8b, 0xa4, 0x58, 0x40, 0xe7, 0xfb, 0xd5, - 0x87, 0x17, 0x58, 0xcd, 0x63, 0xae, 0xc9, 0xd4, 0xa2, 0xce, 0x9c, 0xba, 0x50, 0x7d, 0x5e, 0x75, 0x5f, 0xd7, 0x2a, - 0xb8, 0x10, 0xd7, 0x9f, 0xa0, 0xe9, 0xaa, 0x9e, 0xfb, 0x96, 0x83, 0xd4, 0x94, 0x67, 0x10, 0xc7, 0xfa, 0xd3, 0x73, - 0x73, 0x23, 0x5b, 0xad, 0x8f, 0xd6, 0x51, 0x26, 0x5e, 0x8c, 0xc4, 0x16, 0x7e, 0xc7, 0x19, 0xd4, 0xa2, 0xbe, 0xcf, - 0x2a, 0x8a, 0x93, 0x80, 0xcb, 0x70, 0x05, 0x27, 0x30, 0xd5, 0x02, 0x03, 0x25, 0x39, 0xd1, 0x80, 0x46, 0xd6, 0xb9, - 0x3a, 0x78, 0xb9, 0x33, 0xdf, 0x34, 0x09, 0xa1, 0x83, 0x39, 0x83, 0x7b, 0x25, 0xdf, 0xec, 0xbb, 0x4a, 0x1d, 0x4c, - 0xb5, 0xf3, 0xda, 0x84, 0xad, 0x66, 0x7a, 0xda, 0x35, 0xb4, 0x42, 0xf4, 0x5c, 0x52, 0xcf, 0x90, 0x32, 0x56, 0x91, - 0xaa, 0x59, 0x1a, 0x87, 0x77, 0x8f, 0x84, 0x94, 0x29, 0xdb, 0x9d, 0x83, 0xf3, 0x0e, 0xa2, 0x12, 0xa9, 0xb2, 0x6e, - 0x0b, 0x23, 0x03, 0x3d, 0xe7, 0x58, 0x57, 0x51, 0xac, 0xa0, 0x18, 0x82, 0x5c, 0xe8, 0xa4, 0x15, 0x49, 0xa5, 0x1f, - 0x77, 0x16, 0x96, 0x51, 0x67, 0x65, 0x2e, 0x96, 0xcd, 0x75, 0xd4, 0xbb, 0x51, 0xff, 0xcc, 0xbb, 0x76, 0x39, 0x1d, - 0x9b, 0xc0, 0x4c, 0x28, 0x85, 0x05, 0xd2, 0x2c, 0x7f, 0x8b, 0xd3, 0xfb, 0xf1, 0xae, 0xe8, 0xd7, 0xc3, 0x66, 0x21, - 0x73, 0xb6, 0x02, 0x07, 0x90, 0xe9, 0xb8, 0xfa, 0x9d, 0x23, 0xa3, 0x8c, 0x42, 0x21, 0xad, 0xef, 0x41, 0x31, 0xd8, - 0x8e, 0xa9, 0x84, 0xe8, 0xd8, 0xdc, 0xcd, 0x00, 0x1d, 0xb4, 0xb1, 0xd5, 0x7b, 0x08, 0x36, 0x93, 0xb4, 0xe2, 0x2c, - 0x81, 0x8e, 0xd5, 0x4f, 0x2d, 0x55, 0x2f, 0x0d, 0x81, 0x41, 0xbf, 0x05, 0x82, 0xc0, 0x0b, 0x11, 0x7e, 0x66, 0x5e, - 0xd9, 0x20, 0xc2, 0x43, 0xf7, 0x06, 0xa0, 0x0c, 0xb1, 0xd6, 0x51, 0x2f, 0x8b, 0x85, 0xf7, 0x97, 0x05, 0x6d, 0xd1, - 0xcc, 0x51, 0x24, 0xa0, 0x7f, 0x85, 0x13, 0x57, 0x96, 0xf1, 0x09, 0x20, 0xa0, 0xcf, 0x91, 0xa4, 0xf8, 0xe8, 0x7d, - 0xaf, 0x9f, 0xa6, 0x94, 0x48, 0x9d, 0xf3, 0xd2, 0x93, 0xdc, 0xe0, 0xef, 0x3b, 0xcf, 0x1b, 0xaf, 0xac, 0x4a, 0x9e, - 0xfb, 0x7b, 0xba, 0x64, 0x71, 0x3d, 0x70, 0x7c, 0xb5, 0x94, 0xc9, 0xe6, 0xca, 0xc5, 0x04, 0x59, 0xb0, 0xf1, 0xbe, - 0x67, 0x46, 0x61, 0xdf, 0x40, 0xbe, 0x2b, 0xe6, 0x23, 0x8c, 0x6b, 0x2b, 0x9e, 0xbd, 0x15, 0x0f, 0x73, 0x4e, 0x49, - 0x91, 0xd4, 0x76, 0x4e, 0x81, 0x54, 0x67, 0x54, 0x5b, 0x90, 0x21, 0xe6, 0x02, 0x59, 0xf5, 0x29, 0x0e, 0xce, 0x96, - 0xa6, 0x81, 0x28, 0x5a, 0xca, 0x8f, 0x0a, 0x15, 0x82, 0xff, 0x1a, 0x88, 0x99, 0x46, 0x15, 0x60, 0x6e, 0x24, 0xd4, - 0xe1, 0x20, 0x9e, 0xf0, 0x74, 0x2f, 0x4d, 0x2b, 0x4d, 0x27, 0xee, 0xb4, 0x88, 0xa8, 0xfe, 0x72, 0x6e, 0x93, 0xa0, - 0x59, 0xf5, 0x2a, 0x0a, 0x97, 0x62, 0x49, 0x04, 0xd7, 0xcb, 0xea, 0xaa, 0x1f, 0x51, 0xaa, 0x7b, 0x65, 0xc1, 0x75, - 0xce, 0x02, 0x83, 0xe3, 0x5b, 0x8f, 0x74, 0x7b, 0x9e, 0x2e, 0xaf, 0x91, 0xdb, 0xa6, 0xc0, 0x8d, 0x8f, 0x99, 0xd0, - 0x95, 0xb8, 0x9a, 0x0d, 0x74, 0x85, 0x79, 0xdb, 0xae, 0xf8, 0x4a, 0xb0, 0x36, 0xff, 0x75, 0x3f, 0x03, 0xef, 0x8b, - 0x17, 0x61, 0xc1, 0x4c, 0x15, 0x8c, 0x62, 0xe2, 0x17, 0x61, 0x89, 0x30, 0xbc, 0x68, 0x6e, 0xce, 0xf6, 0xf9, 0xe6, - 0x3c, 0x02, 0x1c, 0x16, 0xe5, 0x09, 0x73, 0x7b, 0x06, 0x14, 0x54, 0x9b, 0xb0, 0xa9, 0xd6, 0x80, 0xb1, 0x3d, 0x4b, - 0xf3, 0x31, 0xdf, 0x9b, 0x0e, 0x50, 0x4f, 0xad, 0x39, 0xc5, 0x60, 0x0c, 0x61, 0xa2, 0xdb, 0x80, 0x02, 0xa4, 0x26, - 0x0b, 0x87, 0xcc, 0xfa, 0x5b, 0xca, 0x0b, 0x6d, 0x62, 0x43, 0x5f, 0x92, 0xa5, 0xb5, 0x56, 0xf0, 0x13, 0x34, 0x4d, - 0xc1, 0x29, 0x0e, 0x3f, 0x48, 0xbc, 0xe7, 0xde, 0x79, 0x8d, 0x44, 0x46, 0x3d, 0x17, 0x7e, 0x21, 0xc2, 0xca, 0x7d, - 0xc4, 0x9c, 0x73, 0x53, 0x13, 0xb2, 0x2f, 0x5d, 0xb2, 0x96, 0xd5, 0x24, 0xe0, 0xd1, 0x73, 0xa1, 0x42, 0x3b, 0x23, - 0xde, 0x5d, 0x5b, 0x79, 0xab, 0x7a, 0x34, 0x03, 0x56, 0x73, 0xdc, 0xb6, 0x98, 0x86, 0xa9, 0x28, 0xa9, 0x84, 0x20, - 0x6e, 0x09, 0x91, 0x85, 0x61, 0xcb, 0x1a, 0x7b, 0x9f, 0x58, 0xad, 0xa7, 0x24, 0x00, 0x70, 0x25, 0x0d, 0xdd, 0x33, - 0x94, 0x09, 0xa9, 0x97, 0xb4, 0x40, 0x39, 0xe4, 0x6a, 0xe2, 0xe5, 0xc6, 0x3d, 0x86, 0x81, 0x1b, 0xb3, 0xb5, 0xc8, - 0x34, 0x26, 0x44, 0x96, 0x81, 0x00, 0x71, 0x68, 0x5e, 0x9a, 0xca, 0xa2, 0xd3, 0x4d, 0x50, 0x74, 0x51, 0x8f, 0x33, - 0x5c, 0x59, 0x88, 0xbb, 0x64, 0xe8, 0x1c, 0x78, 0x39, 0x5d, 0xe3, 0xe5, 0x24, 0x15, 0x02, 0xaf, 0x82, 0x95, 0x07, - 0x12, 0xd9, 0x03, 0xed, 0xa0, 0x6c, 0x00, 0x24, 0xb9, 0x13, 0x5c, 0x29, 0x48, 0x6b, 0x2b, 0xc8, 0x21, 0xfe, 0xa7, - 0xb6, 0x1c, 0xa5, 0x02, 0xf2, 0xd4, 0xb1, 0xe5, 0xa4, 0xf1, 0x3c, 0x5c, 0x0a, 0x6f, 0xa4, 0x36, 0xcc, 0x60, 0xc5, - 0x0a, 0x16, 0x22, 0x33, 0x25, 0xcf, 0xad, 0x60, 0x1b, 0xaf, 0xde, 0xc4, 0x8c, 0x44, 0x85, 0xe9, 0xa3, 0xd8, 0x59, - 0xdd, 0x0d, 0x13, 0x6c, 0x2b, 0x9e, 0xb2, 0xdb, 0x8f, 0xc8, 0x7f, 0x4c, 0x50, 0x92, 0xa6, 0xc3, 0x97, 0x4a, 0xa6, - 0x93, 0xf2, 0xe2, 0x9d, 0x16, 0x46, 0x4b, 0x0e, 0x01, 0x17, 0x7c, 0x06, 0xde, 0x9d, 0x89, 0xfc, 0xcb, 0xa6, 0x35, - 0xc9, 0x1c, 0xa3, 0xaa, 0x8a, 0x16, 0x12, 0x8d, 0x71, 0x51, 0xb6, 0x26, 0x16, 0x0f, 0x16, 0x57, 0x03, 0x48, 0xa6, - 0x31, 0x2c, 0xf0, 0xf2, 0xc8, 0x7c, 0xcd, 0xe6, 0x45, 0xf5, 0x44, 0x96, 0x8a, 0x2e, 0xc8, 0xe5, 0x67, 0x18, 0x9b, - 0x99, 0x32, 0xac, 0x16, 0xcb, 0x70, 0x38, 0x2b, 0x08, 0x7b, 0x3f, 0xe0, 0x82, 0xe7, 0xa6, 0x8f, 0xbe, 0x5c, 0x30, - 0xa9, 0x1c, 0x46, 0x26, 0x7f, 0x96, 0x5c, 0xbc, 0x22, 0xac, 0x9e, 0x6c, 0xe7, 0x00, 0x72, 0xa1, 0x06, 0xe5, 0x08, - 0x87, 0x96, 0x13, 0xd8, 0xc4, 0x58, 0x44, 0x67, 0xd5, 0x54, 0x35, 0xc2, 0xd2, 0x7c, 0xe9, 0x46, 0x99, 0x37, 0xd9, - 0x76, 0x86, 0x4c, 0xd8, 0xba, 0x1f, 0x89, 0x20, 0x37, 0x1e, 0x0c, 0xa5, 0x31, 0xef, 0xc3, 0x1a, 0xac, 0xfa, 0x44, - 0x5e, 0xce, 0xa3, 0xaa, 0x11, 0x32, 0xc3, 0x29, 0xf9, 0x69, 0xf4, 0x14, 0x4d, 0x77, 0x92, 0x13, 0x2a, 0xda, 0x24, - 0x2a, 0x0a, 0x6c, 0xe2, 0x45, 0x29, 0x24, 0x82, 0xe2, 0x2e, 0xc7, 0x43, 0x0d, 0xf3, 0x0f, 0x27, 0x07, 0x57, 0x22, - 0x56, 0x07, 0x6e, 0xef, 0x1b, 0x48, 0xf2, 0x33, 0x99, 0xf4, 0x46, 0xba, 0x77, 0x37, 0xe5, 0xe1, 0x69, 0x22, 0x33, - 0xf7, 0x91, 0xb8, 0x8e, 0x8b, 0x8a, 0x42, 0x05, 0xdc, 0x6f, 0xd5, 0x5e, 0x7c, 0x92, 0x74, 0x82, 0xcc, 0x30, 0x73, - 0x6d, 0x7c, 0x6e, 0x8a, 0x91, 0x9a, 0x93, 0x54, 0x81, 0x7c, 0x72, 0xf7, 0x97, 0x46, 0x90, 0x9b, 0xf0, 0x17, 0xdf, - 0x3b, 0xaf, 0x93, 0xf2, 0x1c, 0xed, 0xe7, 0x44, 0xf4, 0xba, 0x1c, 0x6d, 0x31, 0x68, 0x63, 0x4e, 0x8c, 0x7c, 0xbb, - 0xbb, 0x88, 0x7c, 0xb9, 0xe1, 0x14, 0xc3, 0x54, 0x05, 0x32, 0x79, 0xf8, 0x43, 0x2d, 0x0f, 0x84, 0xfd, 0x29, 0x99, - 0x61, 0xa6, 0x89, 0xa8, 0xc2, 0x16, 0x38, 0x05, 0x0e, 0xd4, 0x5c, 0x39, 0x51, 0xf3, 0x70, 0xa0, 0x4a, 0x71, 0xf6, - 0x49, 0x22, 0xce, 0x5c, 0xc6, 0x36, 0x7e, 0x25, 0x5d, 0x30, 0x97, 0xd5, 0x48, 0x5b, 0x11, 0x2d, 0x8f, 0x14, 0x02, - 0x82, 0x5a, 0x8a, 0xa5, 0xd8, 0x12, 0x40, 0x30, 0xbe, 0xc5, 0xf3, 0xfb, 0x18, 0xb1, 0x0a, 0xc5, 0xcb, 0x34, 0xb2, - 0xa2, 0x5d, 0x7e, 0x63, 0x17, 0xa6, 0x0b, 0x26, 0xe0, 0x66, 0x24, 0xc5, 0xc8, 0x73, 0x87, 0x57, 0xe5, 0x46, 0xea, - 0x74, 0xbf, 0x2d, 0x0a, 0x05, 0x4f, 0x8b, 0x46, 0xe7, 0xc6, 0x54, 0x11, 0x5c, 0x35, 0x2a, 0xb6, 0x38, 0x38, 0x9c, - 0x7f, 0xa8, 0x99, 0x85, 0x74, 0x4d, 0x94, 0x23, 0x89, 0xfc, 0x7e, 0x11, 0x1c, 0x6a, 0x94, 0x17, 0xa2, 0x10, 0xa9, - 0x9f, 0x18, 0x72, 0x59, 0xc4, 0xec, 0x30, 0x37, 0xaa, 0xcb, 0x16, 0xc0, 0x96, 0xae, 0xc3, 0xc8, 0x50, 0x88, 0x3c, - 0x62, 0x98, 0x99, 0x26, 0xf5, 0x71, 0xe5, 0x20, 0x8b, 0xae, 0x52, 0x83, 0x34, 0xef, 0xb8, 0x91, 0x37, 0x49, 0xa2, - 0x84, 0x0c, 0xf1, 0xcc, 0x7c, 0x52, 0x67, 0x27, 0xb1, 0x57, 0x69, 0x29, 0xa4, 0x23, 0xd5, 0x4d, 0xa2, 0xd8, 0xe9, - 0x3e, 0x13, 0x7a, 0x5f, 0xb5, 0xf7, 0xb1, 0x18, 0xbc, 0x6e, 0x9b, 0x30, 0x7f, 0xf4, 0xf9, 0x4d, 0x7c, 0x47, 0x4d, - 0xd5, 0x13, 0x69, 0x41, 0x27, 0xa1, 0x35, 0x00, 0xee, 0xf3, 0xe6, 0xce, 0xf6, 0x60, 0xb8, 0x4d, 0x00, 0x5a, 0xc1, - 0x59, 0x4e, 0x37, 0x42, 0x56, 0xb7, 0x4f, 0x5a, 0xa7, 0x89, 0x8b, 0x38, 0xd8, 0x01, 0xd2, 0x10, 0xb8, 0x0a, 0x3e, - 0x67, 0x5f, 0x21, 0xf5, 0x23, 0x35, 0xb1, 0xb3, 0x4d, 0xd2, 0x83, 0xb6, 0xf7, 0xc9, 0xe5, 0xbc, 0x9f, 0x67, 0x2c, - 0x26, 0x0b, 0xf7, 0x4e, 0xfe, 0x10, 0xae, 0xe2, 0xa8, 0x16, 0x23, 0xe6, 0x0a, 0x01, 0xa6, 0xaa, 0x61, 0xb8, 0xd9, - 0x57, 0x4a, 0x63, 0xdc, 0x62, 0x0a, 0x40, 0x05, 0xc7, 0xa4, 0x5e, 0x7d, 0x0c, 0x55, 0xeb, 0xfe, 0xe7, 0x0a, 0xd6, - 0xd5, 0x6e, 0x59, 0xef, 0xf4, 0x00, 0x98, 0x00, 0xfc, 0x01, 0xa8, 0xaa, 0xe7, 0xe5, 0xce, 0xbf, 0xb0, 0x57, 0x10, - 0xa4, 0x24, 0xe0, 0x5e, 0x25, 0xfd, 0xdf, 0x6a, 0x1a, 0x08, 0x9a, 0xaf, 0x97, 0xf5, 0xb1, 0xcf, 0x44, 0x22, 0xf7, - 0x3c, 0x69, 0xf1, 0xf1, 0x1e, 0x78, 0x0b, 0x38, 0x7e, 0x19, 0x5b, 0x97, 0x74, 0xce, 0xfc, 0x41, 0x02, 0xcb, 0x1b, - 0xb5, 0xaf, 0x1e, 0x5f, 0xd2, 0x89, 0x60, 0xa7, 0x28, 0x50, 0x1f, 0x22, 0x02, 0x4a, 0x04, 0x4a, 0x8e, 0xb4, 0x84, - 0xee, 0x27, 0x9f, 0xa0, 0x5a, 0x40, 0x48, 0x9d, 0x12, 0x16, 0xf5, 0xed, 0xa0, 0x8e, 0xe0, 0x6d, 0x33, 0x72, 0xe2, - 0xc0, 0xb9, 0x81, 0x93, 0xf2, 0x39, 0xec, 0x6a, 0x84, 0xcb, 0xe3, 0x0d, 0x9e, 0xc0, 0x97, 0xe8, 0x37, 0x8e, 0x6f, - 0xe2, 0x79, 0x8b, 0x41, 0xe4, 0x1c, 0xb2, 0x9c, 0x7c, 0x21, 0xa2, 0x46, 0x24, 0x09, 0x75, 0xd8, 0x85, 0x90, 0xd6, - 0x17, 0x30, 0x38, 0x5e, 0x31, 0x8d, 0xa1, 0x7a, 0x18, 0x83, 0xc1, 0xe6, 0xf9, 0xed, 0xe9, 0x74, 0xeb, 0x21, 0xf9, - 0x20, 0xea, 0x8b, 0x88, 0x77, 0x4d, 0xa9, 0x51, 0x64, 0x79, 0xd8, 0xb4, 0xae, 0x53, 0xc3, 0x7b, 0x88, 0xc3, 0xbf, - 0x0a, 0x90, 0x00, 0xc5, 0x6e, 0xd3, 0xe7, 0x5c, 0xb0, 0xd1, 0x3b, 0x4d, 0x44, 0x68, 0xa1, 0x19, 0xa4, 0x70, 0xd5, - 0x7c, 0x81, 0x95, 0x69, 0xa7, 0xff, 0x45, 0xe7, 0xb6, 0x24, 0x01, 0x41, 0xb4, 0xd2, 0xef, 0xab, 0x30, 0x61, 0x89, - 0x31, 0x01, 0xde, 0x11, 0x62, 0xce, 0x33, 0x58, 0x49, 0x2c, 0x40, 0x72, 0xb4, 0x5e, 0x97, 0x1f, 0xcb, 0x74, 0x8a, - 0xd1, 0xe8, 0x4d, 0x9d, 0x64, 0xaa, 0xf5, 0xb5, 0x04, 0xf0, 0xc7, 0x79, 0x0d, 0x5b, 0xe6, 0x1e, 0x08, 0xb0, 0x63, - 0x25, 0xa1, 0x49, 0xb7, 0x64, 0xa7, 0xba, 0xe3, 0x66, 0x93, 0x9a, 0x72, 0x3f, 0x6f, 0x55, 0xb2, 0x54, 0x82, 0xc3, - 0xba, 0xf6, 0xa0, 0xfc, 0x21, 0x15, 0xe6, 0x32, 0x54, 0x56, 0x7b, 0x08, 0x90, 0xb0, 0x94, 0xe4, 0xa3, 0x9a, 0x21, - 0xe5, 0xe3, 0x53, 0x45, 0x91, 0x90, 0x33, 0x5e, 0x2c, 0x6b, 0xc0, 0x00, 0xef, 0xce, 0x5d, 0x4a, 0xeb, 0x1d, 0x7a, - 0xe4, 0xbd, 0x47, 0xbc, 0x80, 0xbd, 0x29, 0x61, 0x8f, 0x3b, 0x04, 0x69, 0x5f, 0x33, 0x14, 0xf2, 0x6f, 0x86, 0x92, - 0xc6, 0xfe, 0x7d, 0xcb, 0xe9, 0x41, 0xcf, 0xc8, 0xf4, 0x91, 0x0b, 0x7f, 0xae, 0xf1, 0xf6, 0x83, 0x7b, 0xb6, 0x61, - 0x3c, 0xad, 0x24, 0x30, 0x64, 0x13, 0x77, 0xf3, 0x92, 0x57, 0x6c, 0xb1, 0x7c, 0x77, 0xfe, 0x3a, 0x59, 0xa3, 0x20, - 0x70, 0x0b, 0x3e, 0xd0, 0x32, 0x52, 0x69, 0x90, 0x94, 0x14, 0xaf, 0xce, 0x81, 0x49, 0xa7, 0x9b, 0x5a, 0x25, 0x6a, - 0xd5, 0xa0, 0x57, 0x7d, 0x8a, 0x61, 0x59, 0xd2, 0xb6, 0xc4, 0x42, 0xb3, 0xdf, 0x87, 0x01, 0x26, 0x3f, 0x46, 0xce, - 0xb8, 0xbd, 0x03, 0xba, 0x07, 0x45, 0x6d, 0x19, 0x27, 0x41, 0x52, 0xaa, 0x20, 0x80, 0x74, 0xbf, 0xce, 0x63, 0x79, - 0xd5, 0x31, 0xd1, 0x61, 0xd1, 0xaa, 0x11, 0xc8, 0x09, 0x75, 0x63, 0x04, 0x86, 0x90, 0x3d, 0x53, 0xb1, 0xf4, 0xd0, - 0xeb, 0x30, 0x54, 0x7d, 0xee, 0xc7, 0xb0, 0xa6, 0xd5, 0x98, 0x25, 0x0f, 0x92, 0xcc, 0xa8, 0xfa, 0x46, 0xdf, 0xa2, - 0xd5, 0x59, 0xcf, 0xf1, 0x9e, 0x37, 0xd3, 0xd0, 0x4d, 0x65, 0xff, 0xd0, 0xd8, 0x81, 0x7f, 0x5b, 0x46, 0xa2, 0x5a, - 0x72, 0x96, 0xf6, 0x4a, 0xe6, 0x53, 0x8f, 0x02, 0x54, 0xdf, 0xf1, 0xee, 0xd2, 0x80, 0x28, 0x39, 0x3a, 0x77, 0x9b, - 0x1b, 0x70, 0xa9, 0x3e, 0xd0, 0x38, 0x3d, 0x86, 0x62, 0x60, 0xe7, 0xb7, 0xaf, 0xa7, 0xeb, 0x10, 0x23, 0x87, 0x51, - 0xe0, 0x28, 0xbd, 0xf4, 0x2e, 0x79, 0xb5, 0xe2, 0xc6, 0x15, 0xb6, 0xbb, 0x97, 0x96, 0xdf, 0x25, 0xdb, 0xb0, 0x3a, - 0xc9, 0xfe, 0x18, 0xd9, 0xd8, 0xc7, 0x74, 0xac, 0x8e, 0xd1, 0xb9, 0x73, 0x00, 0x5c, 0xb9, 0x94, 0xc0, 0xdd, 0x4a, - 0xae, 0x8e, 0x7f, 0xe5, 0xf6, 0x54, 0x4e, 0x37, 0xbd, 0x2e, 0x5f, 0x3e, 0x39, 0xbb, 0x8a, 0x07, 0xad, 0xd0, 0x50, - 0x66, 0xe9, 0xb2, 0x4a, 0xea, 0x02, 0x79, 0xd6, 0xf1, 0x5c, 0xb8, 0xeb, 0x2f, 0xbd, 0x8d, 0xd0, 0x80, 0x3d, 0x43, - 0x58, 0xcd, 0xa5, 0xa1, 0x3f, 0x97, 0xb3, 0x1e, 0x7b, 0x8b, 0x26, 0x13, 0xed, 0x2d, 0x7a, 0x4c, 0x69, 0x1c, 0x27, - 0xec, 0x0f, 0x38, 0x35, 0xde, 0x87, 0x74, 0xb5, 0x80, 0xd5, 0xc3, 0x2f, 0x0c, 0xc8, 0xcc, 0x01, 0x6e, 0xf7, 0xfc, - 0x73, 0xca, 0xd7, 0xbc, 0x8a, 0x42, 0x75, 0x93, 0x07, 0xd5, 0x94, 0x6c, 0x59, 0x07, 0x1b, 0xf6, 0xcf, 0x0a, 0x41, - 0x2d, 0x80, 0xe5, 0xd4, 0x74, 0xd9, 0xec, 0x7d, 0x12, 0xda, 0xb6, 0x5b, 0x4a, 0x78, 0x6f, 0x61, 0x4f, 0xec, 0xce, - 0xf2, 0x34, 0x29, 0x0f, 0xe3, 0x7f, 0x4c, 0xc8, 0x74, 0xc8, 0x5d, 0xb5, 0x92, 0x96, 0x29, 0xa6, 0xca, 0xde, 0x6f, - 0x1c, 0xbb, 0x39, 0x63, 0x24, 0x3e, 0x41, 0x0d, 0x1f, 0x2e, 0x3b, 0x7a, 0xb4, 0xe8, 0xed, 0x07, 0x47, 0x1a, 0x98, - 0xfa, 0x41, 0x46, 0x6e, 0x2a, 0x63, 0x1d, 0x00, 0x25, 0x4b, 0xf4, 0x67, 0xcb, 0x2e, 0x2d, 0x2a, 0x44, 0xa1, 0xc2, - 0xed, 0xec, 0x0f, 0xf7, 0x32, 0xab, 0x14, 0x11, 0xed, 0xde, 0x95, 0xe0, 0x0c, 0x71, 0x47, 0xbc, 0xe5, 0xa4, 0x01, - 0xc5, 0x68, 0xd1, 0x41, 0x4b, 0x8a, 0xb6, 0x47, 0xeb, 0xd5, 0x52, 0xca, 0xf3, 0xcc, 0x89, 0xec, 0x28, 0x60, 0xfd, - 0x70, 0x38, 0xf4, 0xed, 0x67, 0x55, 0xa4, 0xdd, 0x8f, 0xd9, 0x02, 0x77, 0x00, 0xf7, 0x5b, 0x16, 0xa6, 0x18, 0xa2, - 0xf3, 0x97, 0xd4, 0x18, 0x5d, 0x3f, 0x0a, 0x41, 0x1b, 0x8c, 0x21, 0x4f, 0x98, 0x5c, 0x93, 0x84, 0x86, 0x34, 0x46, - 0xad, 0x51, 0x20, 0x39, 0x27, 0xa6, 0x91, 0x98, 0x2d, 0x58, 0x4f, 0x23, 0x29, 0x5d, 0x44, 0xc8, 0x4c, 0x50, 0xd1, - 0x83, 0x22, 0x58, 0x92, 0x91, 0x16, 0xa9, 0xdc, 0x8b, 0x8e, 0xe2, 0x3d, 0x1f, 0x41, 0x73, 0xcd, 0xad, 0x1a, 0xd2, - 0x83, 0xe5, 0x8d, 0x86, 0x82, 0xac, 0xd2, 0xf1, 0x92, 0xfb, 0xa8, 0x0e, 0x22, 0x83, 0xa6, 0xad, 0xdf, 0xf6, 0x97, - 0xf1, 0x58, 0x93, 0x79, 0x46, 0x24, 0x18, 0x32, 0x0c, 0x39, 0x8c, 0x91, 0x7b, 0xab, 0xd2, 0xd3, 0x0f, 0x32, 0xf4, - 0xbb, 0xc5, 0x08, 0x60, 0xe2, 0x2b, 0x61, 0xb2, 0x2e, 0x77, 0x6a, 0xd4, 0x79, 0x97, 0x71, 0x22, 0x63, 0xe1, 0xfe, - 0xa3, 0xb0, 0x36, 0x24, 0x5a, 0xaf, 0x6e, 0xec, 0xf9, 0xc7, 0x0d, 0x7e, 0x52, 0x9a, 0x22, 0x6a, 0x4d, 0x52, 0xa7, - 0x03, 0x75, 0x4b, 0x1c, 0x83, 0xa3, 0x7c, 0x5c, 0xbc, 0xf0, 0xa0, 0xa5, 0x72, 0x43, 0x49, 0xac, 0x44, 0xdf, 0xdc, - 0x23, 0xfb, 0x02, 0x1a, 0x7b, 0x0a, 0xba, 0xd9, 0xe2, 0xa8, 0x56, 0xc6, 0x50, 0x8a, 0x39, 0x1c, 0xf6, 0xa1, 0xac, - 0x61, 0xa5, 0x3a, 0xb6, 0x5e, 0x1a, 0x77, 0xe3, 0x81, 0xc8, 0x50, 0x3b, 0x34, 0x0e, 0x71, 0x5f, 0x33, 0x23, 0x37, - 0x43, 0x13, 0xde, 0x21, 0x63, 0x70, 0x27, 0x8e, 0x97, 0x1a, 0x4b, 0xc2, 0x48, 0x88, 0x41, 0xbf, 0xb8, 0x17, 0xb3, - 0x45, 0x15, 0x24, 0x88, 0x6b, 0x1b, 0x15, 0x60, 0xe3, 0x15, 0xa2, 0x42, 0x7b, 0x6c, 0xeb, 0x78, 0x9e, 0x19, 0xb9, - 0x02, 0xc3, 0xc4, 0x1b, 0xd9, 0x8d, 0x9e, 0xa7, 0x72, 0xfc, 0x17, 0x61, 0xf5, 0x33, 0x16, 0x6c, 0xdd, 0x8a, 0x82, - 0x3f, 0x41, 0xe8, 0xe1, 0x41, 0xfb, 0x79, 0x89, 0x75, 0xfc, 0x8f, 0xad, 0xdf, 0x50, 0xd3, 0xaa, 0xd3, 0xd0, 0x0f, - 0xc7, 0x0f, 0x9d, 0x46, 0x07, 0xf9, 0xa7, 0xaf, 0x2e, 0x2d, 0x6e, 0x9a, 0xee, 0x6a, 0x5c, 0xbb, 0xaf, 0x50, 0x7d, - 0x38, 0xb6, 0x55, 0x17, 0xec, 0x0f, 0xe3, 0x38, 0xdc, 0x80, 0xc7, 0xc3, 0xf3, 0xe0, 0x06, 0x3c, 0xb8, 0xbf, 0x34, - 0xa6, 0xc7, 0xb3, 0xe7, 0x4b, 0xef, 0x2e, 0xc3, 0xb9, 0xc8, 0x35, 0x26, 0x7b, 0xea, 0xd7, 0xb6, 0x8b, 0x23, 0x8d, - 0xc0, 0xe8, 0xe8, 0xcd, 0x74, 0x41, 0x8d, 0x6b, 0x92, 0x51, 0x6b, 0x50, 0x7e, 0x42, 0x38, 0xbd, 0x7f, 0x7f, 0x6b, - 0x74, 0x84, 0x42, 0xc4, 0x8b, 0xc0, 0x7f, 0xdf, 0xc1, 0xdb, 0x7a, 0xd8, 0x99, 0x56, 0x67, 0xb9, 0xc4, 0x53, 0xd8, - 0x57, 0xa3, 0x5b, 0xd7, 0xe3, 0xc8, 0x28, 0xbd, 0xfc, 0xe0, 0x25, 0xc6, 0xc9, 0x4d, 0x7e, 0xc4, 0xb1, 0xaa, 0xdb, - 0x8b, 0xd5, 0x9f, 0x07, 0x41, 0x11, 0xfe, 0xf1, 0x82, 0x8c, 0x0f, 0x91, 0x8e, 0x72, 0x2a, 0x96, 0x62, 0x5a, 0x51, - 0x8d, 0x03, 0x50, 0x34, 0xfa, 0x25, 0xf4, 0xd5, 0x34, 0x18, 0x9b, 0xe7, 0x4a, 0x18, 0xdf, 0xf1, 0xbf, 0x1f, 0xbc, - 0xfb, 0x05, 0x9b, 0xe5, 0x2e, 0x18, 0xd6, 0x7d, 0x18, 0xa9, 0x4f, 0x02, 0xa8, 0xac, 0x9e, 0x65, 0x35, 0xd1, 0x76, - 0x50, 0xc7, 0xab, 0x99, 0xed, 0xbf, 0xef, 0x1c, 0x42, 0x4f, 0xab, 0x99, 0x52, 0x40, 0xe5, 0x96, 0x77, 0x88, 0x87, - 0xfa, 0x12, 0xbe, 0x8f, 0xf5, 0x55, 0xcc, 0xaf, 0xa8, 0xfa, 0x32, 0x56, 0x51, 0x10, 0x9a, 0x1f, 0x30, 0x34, 0xfc, - 0x90, 0x3c, 0xe3, 0x86, 0x83, 0xb9, 0x5f, 0x42, 0xff, 0xb2, 0xbe, 0x3f, 0x24, 0xf6, 0xb5, 0x8f, 0xdb, 0x75, 0xf3, - 0x35, 0xa7, 0x74, 0x18, 0x25, 0x78, 0x8e, 0xe3, 0xe6, 0xd0, 0x59, 0x1b, 0xed, 0xe8, 0xd4, 0x17, 0x69, 0x1d, 0x5d, - 0x60, 0xe8, 0xfb, 0xcc, 0x25, 0x5e, 0x39, 0xe2, 0xa0, 0x8f, 0xc4, 0x0d, 0x47, 0xdd, 0x5e, 0xd5, 0x8e, 0xd1, 0x31, - 0x06, 0x79, 0x29, 0x04, 0x90, 0x1c, 0xaa, 0xa7, 0xcd, 0xa2, 0x4d, 0x57, 0xce, 0x06, 0xe5, 0x9f, 0xeb, 0x5e, 0x3c, - 0xa0, 0x05, 0xa3, 0xba, 0xe1, 0x2f, 0x1e, 0xd2, 0xb8, 0xa1, 0xe5, 0x28, 0x2a, 0x25, 0x45, 0xa0, 0xb4, 0x8d, 0x0a, - 0x7a, 0xb3, 0x40, 0xf9, 0x60, 0xe9, 0x8f, 0x85, 0x2c, 0x75, 0x10, 0x2c, 0xe5, 0x34, 0xf5, 0x4a, 0x19, 0xd8, 0x63, - 0x23, 0xfe, 0xd3, 0x19, 0x1a, 0x44, 0xe6, 0xe6, 0x81, 0x1d, 0xe2, 0xe5, 0xa8, 0xa4, 0xa1, 0xbc, 0x61, 0xa0, 0x20, - 0xa8, 0xa9, 0x60, 0x11, 0xa4, 0xa8, 0x31, 0xed, 0x51, 0x31, 0xc8, 0xdc, 0xea, 0xb8, 0x81, 0x2e, 0x5f, 0x25, 0xb1, - 0x4b, 0xb5, 0xdb, 0x20, 0x57, 0x15, 0x3f, 0x06, 0xcf, 0x44, 0x5a, 0x07, 0xe9, 0x05, 0x8a, 0xa0, 0x2b, 0x8a, 0x48, - 0xaf, 0xca, 0x78, 0x11, 0xd6, 0xa2, 0xdc, 0x6a, 0xf4, 0xa0, 0x61, 0x18, 0x49, 0x85, 0xb7, 0x8d, 0x28, 0xc5, 0x7e, - 0x66, 0x5f, 0x61, 0x14, 0x3e, 0xe8, 0x50, 0x46, 0x9e, 0x2c, 0xda, 0xba, 0xf7, 0x6e, 0xd2, 0x88, 0x45, 0xa2, 0xce, - 0x6b, 0x1e, 0x99, 0xd2, 0x41, 0x93, 0x7c, 0x74, 0x5e, 0xce, 0xbc, 0x61, 0x32, 0xb2, 0x53, 0x72, 0x5c, 0x6a, 0x05, - 0x18, 0xb1, 0xf9, 0xdb, 0x6f, 0x1d, 0xc7, 0x33, 0x9f, 0x8e, 0x7e, 0x24, 0x3c, 0x5f, 0x66, 0x9e, 0x79, 0xba, 0x2d, - 0x0a, 0x97, 0x5c, 0x98, 0x53, 0xa1, 0x52, 0x83, 0x21, 0xf0, 0x57, 0x31, 0x78, 0x51, 0x26, 0xb8, 0x39, 0xb5, 0xeb, - 0x3e, 0xba, 0x8c, 0x88, 0x0e, 0xdf, 0x54, 0x68, 0xe6, 0xeb, 0xd7, 0xc9, 0x9d, 0x5c, 0x28, 0xa7, 0xd7, 0xaa, 0xc0, - 0xcb, 0x52, 0x65, 0x50, 0x8c, 0x51, 0xa5, 0xf4, 0xbc, 0xa0, 0x51, 0x9d, 0xa8, 0x14, 0x1c, 0x9a, 0xb1, 0xc0, 0x7f, - 0x48, 0xec, 0x2e, 0x79, 0xe8, 0x54, 0x00, 0x64, 0xca, 0xa2, 0xa1, 0xa3, 0x02, 0xf9, 0xdd, 0xc7, 0xd6, 0x8c, 0xb9, - 0x6a, 0x75, 0x59, 0x83, 0x14, 0x45, 0xdb, 0x53, 0x82, 0x34, 0x74, 0x87, 0x8b, 0x6d, 0x8a, 0x10, 0x6f, 0x0e, 0xc5, - 0x20, 0xa0, 0x15, 0x1a, 0x5f, 0x62, 0xaa, 0x95, 0x16, 0xf5, 0x80, 0xc2, 0xcb, 0x56, 0xc1, 0xdf, 0x72, 0xc1, 0x7d, - 0x81, 0x86, 0x43, 0x4c, 0x80, 0x00, 0x0c, 0x64, 0xb5, 0xfc, 0xfb, 0xa8, 0xa4, 0x98, 0xe9, 0x7b, 0xb5, 0xf9, 0x84, - 0xf7, 0xa5, 0x69, 0x72, 0x46, 0x30, 0x49, 0x71, 0x17, 0x32, 0x64, 0x11, 0xe1, 0xde, 0x2b, 0x3a, 0xa0, 0x6b, 0x2b, - 0x9a, 0x39, 0xf5, 0x88, 0x24, 0xb4, 0x05, 0x84, 0xd8, 0xe0, 0xc3, 0x6c, 0x59, 0x0e, 0x8d, 0x60, 0xd6, 0xc0, 0x8c, - 0xf9, 0x5e, 0xcb, 0x08, 0xa2, 0x92, 0x55, 0x2f, 0xbf, 0x07, 0x0e, 0xb4, 0xec, 0x4d, 0x60, 0xd1, 0x49, 0xda, 0x54, - 0x18, 0x08, 0x33, 0xf7, 0xe3, 0x07, 0xcf, 0x55, 0x32, 0x34, 0x7d, 0xac, 0x49, 0x0b, 0x8f, 0x86, 0x1b, 0x07, 0x5c, - 0xf9, 0xf8, 0x5c, 0xa2, 0x90, 0x37, 0xca, 0xb0, 0x2b, 0x77, 0x0e, 0xa8, 0x8f, 0x4c, 0x8d, 0x32, 0x04, 0x39, 0x01, - 0x19, 0xf0, 0xa0, 0xe3, 0x20, 0xf9, 0x3f, 0x20, 0x19, 0x19, 0x9c, 0xc0, 0xbd, 0x32, 0x23, 0x94, 0x2d, 0x28, 0xfc, - 0x91, 0x65, 0xdb, 0x07, 0xb4, 0xe7, 0x33, 0x9a, 0x14, 0x07, 0x92, 0x8d, 0x12, 0x3c, 0x8f, 0x7e, 0xa1, 0x84, 0x26, - 0x68, 0x93, 0x67, 0xe8, 0x23, 0xd9, 0x18, 0x29, 0x44, 0x26, 0x02, 0x07, 0x95, 0x03, 0xb1, 0x75, 0xc1, 0x40, 0x3e, - 0xb3, 0xe3, 0xce, 0xb8, 0xfd, 0x51, 0x70, 0x9d, 0x08, 0xdb, 0x1c, 0x7e, 0xa8, 0xd5, 0x61, 0xec, 0xa7, 0x81, 0xeb, - 0x16, 0xac, 0x6e, 0x95, 0x9e, 0xa1, 0xab, 0x8e, 0xf8, 0x4d, 0x4e, 0x8d, 0x98, 0xb6, 0xe9, 0xae, 0x6e, 0xb7, 0x9b, - 0xea, 0x55, 0xb6, 0xa0, 0x2e, 0x63, 0xf7, 0x5a, 0x55, 0x6b, 0xc6, 0xf2, 0xb0, 0xd0, 0xca, 0xec, 0xf3, 0x9f, 0xc5, - 0xd0, 0x99, 0x68, 0x3a, 0x34, 0x02, 0x25, 0x57, 0x51, 0xc4, 0xd3, 0x87, 0xd5, 0x35, 0xd7, 0x36, 0x99, 0xf8, 0x2b, - 0xa7, 0x8f, 0xaf, 0x1d, 0x37, 0xdf, 0x11, 0x46, 0xbd, 0xe7, 0x8e, 0x1b, 0x70, 0xae, 0x46, 0xbc, 0x1c, 0x3d, 0xf3, - 0x94, 0x57, 0xcb, 0xbb, 0xd2, 0x1c, 0x05, 0xcf, 0xb5, 0x9f, 0x5b, 0x4a, 0x3d, 0x2d, 0x4b, 0x1e, 0xb3, 0x0f, 0xb6, - 0x91, 0xdb, 0x30, 0xd6, 0x9b, 0x74, 0x43, 0xc6, 0x3b, 0x0e, 0xf8, 0x64, 0xa5, 0xa8, 0x2b, 0xfd, 0x9e, 0xaa, 0x49, - 0x0a, 0x1b, 0xcd, 0x6c, 0x37, 0xd4, 0x78, 0x17, 0x30, 0x4d, 0x87, 0xb7, 0x02, 0xc9, 0x81, 0x07, 0xe5, 0xda, 0x12, - 0xa6, 0x78, 0xdc, 0x9c, 0x0a, 0x48, 0x32, 0xac, 0xa6, 0x21, 0x37, 0xbf, 0x2a, 0xa4, 0x21, 0xa1, 0xce, 0xd5, 0x01, - 0x68, 0x95, 0x92, 0x07, 0x38, 0x94, 0x43, 0x01, 0xe6, 0xca, 0xa1, 0x67, 0x68, 0x50, 0x08, 0x46, 0xe8, 0xcd, 0xdb, - 0xe8, 0xf0, 0xd4, 0xe1, 0x43, 0x69, 0x5c, 0xe6, 0x14, 0xc4, 0x2f, 0x1f, 0xfb, 0x48, 0x3d, 0x1a, 0xeb, 0x4e, 0x3e, - 0x51, 0x87, 0xe7, 0x4b, 0xc8, 0xa5, 0x09, 0xdd, 0x27, 0x9c, 0x54, 0x33, 0x21, 0x0b, 0xf9, 0x37, 0x79, 0xaa, 0x46, - 0xb1, 0xa0, 0xf6, 0xea, 0xb9, 0x91, 0xec, 0x8e, 0x3e, 0xcb, 0x51, 0xf8, 0x6a, 0x1c, 0x6e, 0xb5, 0xc2, 0xae, 0x07, - 0x21, 0x2f, 0xbe, 0x70, 0x73, 0xbf, 0xf9, 0x9a, 0x53, 0xd0, 0xfd, 0xa9, 0x03, 0xcf, 0x6d, 0xf1, 0x8a, 0x66, 0x77, - 0x54, 0x07, 0x16, 0xed, 0xfd, 0xfb, 0xa0, 0x1c, 0xb7, 0xf5, 0x59, 0x07, 0xee, 0xfe, 0x91, 0xd8, 0x8d, 0x81, 0xbc, - 0x41, 0x19, 0xef, 0x67, 0x3f, 0xa5, 0x0f, 0x45, 0x42, 0x36, 0xac, 0x31, 0x40, 0x8e, 0x5c, 0x98, 0xf5, 0xb8, 0x31, - 0x67, 0xa7, 0x5d, 0x1e, 0x4a, 0xd0, 0xdd, 0xd6, 0xfe, 0xe3, 0x7a, 0x84, 0xb3, 0xb8, 0x15, 0x60, 0xf2, 0x77, 0x6e, - 0x2c, 0xbb, 0xaa, 0xdb, 0x0b, 0x87, 0x9e, 0x1e, 0xa9, 0xe0, 0xbd, 0xd1, 0x9c, 0x64, 0x5a, 0xb5, 0xbd, 0xda, 0x9f, - 0xfd, 0x92, 0x7f, 0xab, 0x74, 0xbf, 0x6d, 0x09, 0x39, 0x72, 0xb1, 0x82, 0x5d, 0x67, 0x92, 0xc2, 0xf6, 0xd7, 0x2d, - 0x77, 0xcc, 0x69, 0x70, 0xe2, 0x66, 0x4b, 0xe4, 0x3b, 0x7c, 0x1b, 0xc8, 0x26, 0x50, 0x94, 0xfd, 0x38, 0xc0, 0x3e, - 0x8c, 0xa9, 0xb4, 0x49, 0x46, 0x2b, 0x6f, 0xf4, 0xbe, 0x7d, 0x57, 0x28, 0x63, 0xcf, 0x8a, 0x05, 0xb9, 0x8a, 0x84, - 0x1c, 0xb0, 0x1e, 0xcb, 0x54, 0x42, 0x87, 0xc6, 0x73, 0x17, 0xd1, 0x97, 0x45, 0x74, 0xef, 0xe5, 0xbe, 0x4f, 0x62, - 0x9b, 0xd6, 0xdb, 0x29, 0x8f, 0xe4, 0x7f, 0xc4, 0xf8, 0x43, 0x56, 0x05, 0x79, 0x00, 0x1e, 0xef, 0xaf, 0x36, 0x74, - 0x9d, 0xa7, 0x41, 0x99, 0x71, 0x10, 0x45, 0x40, 0xe9, 0x72, 0x53, 0xe4, 0x9c, 0x6e, 0x68, 0x94, 0x4a, 0xd9, 0x16, - 0x83, 0xc0, 0xc8, 0x56, 0x35, 0xea, 0xc5, 0xfc, 0x10, 0x9a, 0x26, 0xa3, 0x3f, 0x9e, 0x49, 0x59, 0x0d, 0xe5, 0xdc, - 0xc5, 0x3a, 0x39, 0xb6, 0x8c, 0x7d, 0x0d, 0xd1, 0x07, 0x87, 0xad, 0xfa, 0x11, 0x33, 0x0f, 0x79, 0xf7, 0x50, 0x80, - 0x81, 0xf9, 0xae, 0x27, 0xdf, 0x94, 0xd2, 0xad, 0xca, 0x52, 0x69, 0x04, 0xa1, 0x0a, 0x6c, 0xb2, 0x37, 0x3c, 0x1a, - 0xe8, 0x89, 0x92, 0x8b, 0x91, 0xc1, 0x14, 0x48, 0x00, 0xd5, 0xb4, 0x0f, 0x7f, 0x4d, 0x2d, 0x94, 0x8c, 0xf4, 0x52, - 0x60, 0x0e, 0xe9, 0xbf, 0x21, 0x21, 0x60, 0x32, 0x00, 0xab, 0x2f, 0xfc, 0x66, 0x12, 0xff, 0x98, 0x0f, 0x7c, 0x04, - 0x9f, 0x30, 0x51, 0x23, 0x52, 0xfe, 0x41, 0x79, 0x9f, 0x8e, 0x9c, 0x29, 0x59, 0x3b, 0x2b, 0x05, 0x0e, 0x15, 0x57, - 0x53, 0x18, 0xc2, 0xd3, 0x83, 0xb0, 0x88, 0xa1, 0x1b, 0xc8, 0x7a, 0xb0, 0xe3, 0x09, 0xd3, 0x88, 0xda, 0x64, 0xaa, - 0x86, 0x92, 0xf6, 0x47, 0xc1, 0xe2, 0xc0, 0x9a, 0x00, 0xe4, 0x58, 0x68, 0x5a, 0x74, 0x19, 0x91, 0x79, 0xb0, 0x14, - 0x8e, 0xc0, 0xa9, 0x09, 0xb9, 0x9e, 0x55, 0xe6, 0x3d, 0x4f, 0x0a, 0x0e, 0xe2, 0x09, 0xf6, 0xce, 0x18, 0xf1, 0x4e, - 0x9e, 0x5d, 0xed, 0x4f, 0xb9, 0xde, 0x05, 0x2f, 0xb9, 0x8c, 0x20, 0x97, 0x39, 0x7e, 0x31, 0x98, 0x86, 0xfb, 0x07, - 0x30, 0x17, 0x19, 0x82, 0x7c, 0xe8, 0x50, 0x82, 0x3b, 0x2c, 0x46, 0x9b, 0xd5, 0xc0, 0xc3, 0x8d, 0x22, 0x4b, 0x26, - 0x83, 0x80, 0x08, 0x4c, 0xab, 0x7c, 0x47, 0x05, 0x70, 0x15, 0x17, 0xda, 0x98, 0xa2, 0xb8, 0x5e, 0x51, 0xed, 0x38, - 0xa3, 0xbd, 0x64, 0x33, 0xf3, 0x71, 0x9a, 0x96, 0x36, 0xd4, 0x6a, 0xe2, 0xd4, 0x91, 0x14, 0xcd, 0xd0, 0x79, 0x73, - 0x91, 0x8a, 0x64, 0xa6, 0x0f, 0xe6, 0x0f, 0x1d, 0x09, 0x6c, 0x94, 0x56, 0x30, 0xc8, 0xf9, 0x1a, 0x3b, 0x73, 0x97, - 0xb6, 0xbe, 0xce, 0xda, 0x30, 0xe7, 0xd3, 0x55, 0x3f, 0x4d, 0x09, 0x54, 0x3b, 0x4d, 0xfd, 0xd9, 0x8a, 0xd8, 0x2f, - 0xd2, 0x2e, 0xcb, 0x42, 0x93, 0xe5, 0xde, 0x8f, 0x1f, 0xee, 0xe3, 0x61, 0xa1, 0xba, 0x0b, 0x73, 0x29, 0x47, 0x38, - 0xb2, 0x58, 0x8b, 0xd5, 0x31, 0xfb, 0x19, 0x25, 0x1b, 0xcb, 0x7d, 0x0f, 0x4a, 0xb2, 0xe3, 0xe5, 0xa5, 0x34, 0x97, - 0x7a, 0xf1, 0x5d, 0x0c, 0x96, 0x03, 0xfc, 0x59, 0xa1, 0x9a, 0xe8, 0x5d, 0x59, 0xad, 0xf4, 0x9f, 0x75, 0xc9, 0x45, - 0x5d, 0x39, 0xe3, 0xda, 0x93, 0x21, 0x4c, 0x13, 0x9a, 0xef, 0x18, 0x62, 0x53, 0xc5, 0x44, 0x49, 0x34, 0xd2, 0x36, - 0x70, 0xbc, 0x7f, 0x5e, 0x9f, 0x45, 0x2a, 0x72, 0xd9, 0x2f, 0xd7, 0x71, 0xc7, 0x2f, 0x40, 0x15, 0xc0, 0x0d, 0x42, - 0x0f, 0x72, 0x02, 0xc3, 0xd8, 0x39, 0x3d, 0xd2, 0x88, 0xc2, 0x29, 0xe9, 0x4e, 0x59, 0x5a, 0x87, 0x37, 0x34, 0xde, - 0xa5, 0x07, 0x51, 0x1a, 0x15, 0xf1, 0x53, 0xd2, 0x1b, 0x9b, 0xd1, 0xa9, 0xae, 0xd1, 0x6f, 0x9a, 0x8b, 0x18, 0x1b, - 0x58, 0x50, 0xef, 0xff, 0x74, 0x00, 0x4a, 0x4c, 0xe6, 0x2d, 0x63, 0x8e, 0x89, 0x90, 0x32, 0xb7, 0x92, 0xef, 0x93, - 0x88, 0xca, 0x3c, 0x66, 0x38, 0xe3, 0x17, 0x19, 0x23, 0xea, 0x66, 0x71, 0x7c, 0x6a, 0xdd, 0x82, 0x49, 0x37, 0xf3, - 0xae, 0xcc, 0x40, 0x1a, 0x44, 0x9e, 0x6a, 0xe9, 0x29, 0xa8, 0x9e, 0x2e, 0xab, 0xae, 0x5e, 0x29, 0xf2, 0xf9, 0x1f, - 0x0c, 0xc3, 0xe1, 0x00, 0xe0, 0xc0, 0xea, 0x73, 0xae, 0xf6, 0xda, 0x9f, 0xad, 0x69, 0xeb, 0x80, 0xd3, 0x13, 0x92, - 0xa7, 0x3f, 0x04, 0xe8, 0x1a, 0xcc, 0x32, 0x54, 0xe7, 0x3c, 0x54, 0xfd, 0xed, 0xa2, 0x2d, 0x0e, 0xc7, 0x0c, 0x04, - 0xda, 0x9b, 0x7b, 0xdc, 0xe2, 0xf7, 0x2c, 0x91, 0xce, 0xc3, 0x04, 0x5b, 0x34, 0xea, 0xf6, 0x48, 0x4e, 0xec, 0x56, - 0x0f, 0x96, 0x3b, 0x0e, 0x07, 0x86, 0x9e, 0xed, 0x22, 0x2a, 0x0d, 0x12, 0xec, 0x7e, 0x2e, 0x51, 0x01, 0x91, 0x0e, - 0xba, 0xc3, 0xe4, 0xfb, 0x1e, 0x4b, 0x6b, 0xea, 0xcf, 0xdd, 0x68, 0xe0, 0x0a, 0x76, 0xb8, 0xc2, 0x4a, 0x5d, 0x6e, - 0xdc, 0x4d, 0x87, 0xb3, 0xce, 0xb1, 0x50, 0xb9, 0x1d, 0x1d, 0x7c, 0xbc, 0xde, 0x58, 0x7b, 0xe7, 0x88, 0x1c, 0xa0, - 0xb2, 0x71, 0x18, 0x70, 0xa9, 0x86, 0x9a, 0xa9, 0x0c, 0x81, 0xd6, 0x8d, 0x61, 0x96, 0xc3, 0x29, 0xfa, 0x3e, 0x75, - 0xec, 0x99, 0x62, 0x23, 0x95, 0x4b, 0xfb, 0xd0, 0x34, 0x35, 0x07, 0x9d, 0xbc, 0x3b, 0x05, 0x42, 0x7f, 0xc5, 0xe0, - 0xe1, 0x81, 0x6c, 0xff, 0xf1, 0xdc, 0xff, 0x7a, 0x73, 0x2e, 0xb6, 0x97, 0x39, 0x70, 0x08, 0x93, 0x7d, 0xd4, 0x12, - 0x0a, 0xa0, 0x48, 0xe6, 0xa6, 0x7a, 0x90, 0xab, 0x77, 0x03, 0xfa, 0x84, 0x8b, 0xb1, 0x49, 0xda, 0xa7, 0xc7, 0x1b, - 0x8c, 0x7c, 0x9e, 0x36, 0xbd, 0x76, 0x21, 0x55, 0xbe, 0xd8, 0x9b, 0xed, 0x17, 0x27, 0x9b, 0xe0, 0x24, 0x27, 0xca, - 0x8e, 0x6d, 0x16, 0xc3, 0x3b, 0xed, 0xd2, 0xbf, 0x6f, 0x5b, 0xb9, 0x81, 0x4b, 0x38, 0xb4, 0x43, 0x15, 0xcc, 0x7b, - 0x70, 0xe8, 0xf5, 0x83, 0x0d, 0x8e, 0xea, 0x41, 0x77, 0x60, 0xfa, 0xb4, 0xd6, 0x09, 0x06, 0x84, 0xef, 0x56, 0x30, - 0x0a, 0x01, 0xc7, 0x5b, 0xd7, 0x2e, 0x94, 0x7b, 0x3e, 0xe0, 0x07, 0x41, 0x85, 0x33, 0x43, 0x68, 0x7e, 0x10, 0x39, - 0xa5, 0x3d, 0xa5, 0xa4, 0xba, 0xba, 0x35, 0x0e, 0x37, 0xe0, 0xb3, 0x81, 0xe2, 0x68, 0xbb, 0xf1, 0x4e, 0x12, 0x87, - 0xf9, 0x28, 0x65, 0xe6, 0xd2, 0xfb, 0xce, 0x09, 0x30, 0xf1, 0x4e, 0xed, 0xf4, 0x09, 0x9e, 0xe8, 0x5b, 0x1f, 0x55, - 0xb5, 0x7d, 0xb1, 0xe7, 0x9b, 0xab, 0xee, 0x90, 0x43, 0x94, 0x10, 0x62, 0xf6, 0xa9, 0x73, 0xcc, 0x73, 0x3e, 0x4b, - 0x07, 0x13, 0xf6, 0xdc, 0x16, 0x40, 0xab, 0x46, 0x05, 0xba, 0x72, 0x40, 0x5e, 0xc2, 0x57, 0xb7, 0x4e, 0xe8, 0xd2, - 0x41, 0x7a, 0x2b, 0xbf, 0x5c, 0x35, 0x89, 0x40, 0xf7, 0xc2, 0x7b, 0x8f, 0xe6, 0x4e, 0x74, 0x9c, 0x89, 0x3b, 0xb8, - 0xe8, 0x27, 0xce, 0x69, 0x7c, 0x24, 0xee, 0x12, 0xf9, 0x2c, 0xa6, 0x01, 0x31, 0x4f, 0x84, 0xf8, 0xab, 0x9f, 0xb9, - 0x84, 0x8d, 0x0a, 0x66, 0xea, 0x6e, 0x91, 0xd3, 0xca, 0x16, 0x13, 0x28, 0xdc, 0x5f, 0x74, 0xc3, 0xad, 0x59, 0xbe, - 0x13, 0x0b, 0x30, 0x2d, 0x03, 0x5f, 0xda, 0x39, 0x20, 0x45, 0x44, 0x7a, 0x4f, 0xde, 0xce, 0xff, 0x9b, 0xda, 0x7b, - 0xc5, 0x7f, 0xb4, 0xb9, 0x44, 0x71, 0x3a, 0x6d, 0x0a, 0x4b, 0xe1, 0xdb, 0x3d, 0x02, 0x21, 0x32, 0x46, 0x04, 0x9a, - 0x31, 0x7f, 0xd0, 0x0e, 0x73, 0x0a, 0xbc, 0xc3, 0x01, 0x70, 0x14, 0xb6, 0xd4, 0x0f, 0x36, 0x78, 0x70, 0x8f, 0x77, - 0xbd, 0x94, 0x3a, 0x56, 0x0e, 0x08, 0xcb, 0x1d, 0x85, 0xe3, 0x20, 0x83, 0x40, 0xd5, 0x21, 0xf6, 0x0e, 0xca, 0x3a, - 0x1d, 0xdd, 0x3a, 0x0c, 0xa9, 0xd0, 0x3b, 0xdf, 0x2a, 0x32, 0x1f, 0xb3, 0x5a, 0xe3, 0xa0, 0xfa, 0x00, 0x4e, 0xc0, - 0x6a, 0x46, 0x1c, 0x3d, 0xcd, 0xcb, 0x3d, 0xcd, 0xbc, 0x80, 0x00, 0x67, 0xf8, 0x83, 0x1d, 0xce, 0xd9, 0x3b, 0xef, - 0x81, 0xd2, 0x0d, 0x80, 0xda, 0xc4, 0x69, 0x59, 0xb8, 0x15, 0xbf, 0x5a, 0x7d, 0x23, 0x79, 0x7b, 0x6e, 0x9f, 0x8e, - 0x78, 0x0f, 0x0f, 0x5e, 0x2a, 0x5a, 0xc8, 0x60, 0x65, 0x82, 0xad, 0x06, 0xc2, 0xca, 0x10, 0x0b, 0xfa, 0x68, 0x5e, - 0xab, 0xee, 0x6a, 0x84, 0xea, 0xff, 0xea, 0x29, 0x98, 0xb2, 0x05, 0xaf, 0x38, 0xa9, 0xe9, 0x86, 0x93, 0xb4, 0xd4, - 0x8a, 0xa3, 0xf9, 0xb1, 0x13, 0x06, 0x05, 0xb1, 0x1d, 0x22, 0xfe, 0xf4, 0x7f, 0x96, 0x28, 0x4b, 0xb8, 0xd5, 0x1c, - 0x51, 0xb6, 0xf4, 0x8e, 0x23, 0xe2, 0xdf, 0x8f, 0x78, 0x57, 0x07, 0x11, 0xaa, 0xc6, 0x7c, 0x52, 0x64, 0xfe, 0x2b, - 0xce, 0xf2, 0x46, 0xb8, 0xdb, 0xcc, 0xee, 0xeb, 0x9d, 0x2f, 0xe4, 0x22, 0x39, 0x3f, 0xcc, 0x2d, 0xdb, 0xce, 0xcb, - 0x4b, 0x3b, 0x55, 0xd2, 0xd6, 0xf3, 0xd3, 0xf2, 0x43, 0x8c, 0x23, 0x22, 0x2d, 0xcb, 0x30, 0xba, 0xf3, 0xec, 0x1c, - 0xbe, 0xff, 0x4e, 0xb9, 0xfa, 0xfe, 0xb3, 0x75, 0xc5, 0xb1, 0x35, 0x2e, 0xdf, 0xf1, 0x50, 0xea, 0xf8, 0xcc, 0x30, - 0xd4, 0xda, 0x40, 0x30, 0xb1, 0x95, 0x6d, 0x18, 0x03, 0x40, 0xef, 0x47, 0xb6, 0x18, 0xfa, 0x0b, 0xce, 0xa5, 0xd5, - 0xcd, 0x0b, 0xb9, 0x64, 0x7e, 0xe0, 0x1e, 0xe3, 0x03, 0xef, 0xfa, 0x83, 0xeb, 0x11, 0x3b, 0x91, 0x01, 0x0c, 0xa9, - 0x18, 0x5c, 0xe4, 0x3d, 0xe6, 0xf3, 0xae, 0x14, 0x21, 0xe4, 0x21, 0x4b, 0x01, 0xae, 0x5d, 0xfd, 0xb9, 0x2c, 0xcf, - 0xbc, 0x9f, 0xcf, 0xdb, 0x1c, 0x70, 0x58, 0xa8, 0xbe, 0x2c, 0x60, 0x1c, 0xfe, 0xa1, 0x18, 0x33, 0x81, 0x59, 0x1b, - 0x5e, 0x3f, 0xeb, 0x39, 0x47, 0x53, 0x33, 0x6a, 0x3b, 0xa5, 0x9e, 0xe5, 0xcb, 0xaa, 0xcd, 0x16, 0xcb, 0x90, 0x1b, - 0x1a, 0x1f, 0x27, 0x0d, 0x12, 0xe3, 0xaf, 0x09, 0xb4, 0x5c, 0x24, 0x6d, 0x44, 0x62, 0xd5, 0x8a, 0x56, 0x14, 0x2b, - 0xa3, 0x58, 0x88, 0x95, 0xfc, 0x56, 0xc9, 0xd3, 0x88, 0x39, 0xe5, 0xf1, 0xac, 0xdf, 0x95, 0xa3, 0x11, 0x50, 0xe1, - 0x60, 0x95, 0x4f, 0x7b, 0x6c, 0xed, 0x77, 0xf6, 0x3b, 0x28, 0xa5, 0xc4, 0x4e, 0x20, 0xd8, 0x27, 0x53, 0x1c, 0x00, - 0x2b, 0x9b, 0x23, 0xfb, 0x1b, 0x4e, 0xbf, 0x7a, 0xeb, 0x08, 0x68, 0x5d, 0x76, 0x4e, 0x75, 0xb4, 0x43, 0xef, 0x0b, - 0x32, 0x8d, 0x63, 0x41, 0x7e, 0x5a, 0x89, 0xcd, 0xe0, 0x31, 0x3a, 0x08, 0xd3, 0x2f, 0xac, 0x7d, 0xd5, 0xc8, 0x36, - 0x58, 0x62, 0xb6, 0xec, 0x58, 0xec, 0x5a, 0x27, 0x56, 0xce, 0xa8, 0x77, 0xef, 0xf9, 0x02, 0x9f, 0x54, 0x5b, 0xc9, - 0x0a, 0x38, 0x33, 0x81, 0x75, 0x14, 0x80, 0x6b, 0xec, 0x43, 0xea, 0x03, 0x8a, 0x83, 0xfa, 0x8a, 0xe3, 0xb3, 0x04, - 0x8b, 0x12, 0x42, 0x60, 0x9f, 0x74, 0xeb, 0x86, 0x4a, 0x38, 0x39, 0x4b, 0xda, 0x8f, 0xf0, 0x14, 0xc6, 0x0d, 0x2a, - 0x05, 0x9b, 0x8b, 0xf1, 0x45, 0xc5, 0x32, 0x85, 0xb3, 0x18, 0xd3, 0x61, 0xff, 0xb4, 0x4a, 0x58, 0x46, 0x1f, 0x1f, - 0x16, 0x16, 0x6e, 0xa6, 0x10, 0x4b, 0x4a, 0xfa, 0xfe, 0x80, 0xcd, 0xd7, 0x52, 0xff, 0xbf, 0xe6, 0x0a, 0x2a, 0xd8, - 0x8a, 0xb9, 0xe3, 0xf0, 0x77, 0xa8, 0xe0, 0xed, 0x2d, 0xf3, 0xa4, 0x6a, 0x6b, 0xeb, 0xbe, 0xa4, 0x16, 0x08, 0x2f, - 0x79, 0xfa, 0x89, 0xc3, 0x1d, 0xde, 0x8d, 0x33, 0x26, 0xc3, 0xab, 0x7b, 0x80, 0x24, 0x21, 0x20, 0xa1, 0x75, 0x5f, - 0x77, 0x0f, 0x06, 0x77, 0xb4, 0xc6, 0xf7, 0x20, 0xf1, 0x9e, 0x6f, 0xc6, 0xdb, 0x84, 0x5f, 0xa6, 0x7f, 0x69, 0x55, - 0xc7, 0x6a, 0xec, 0x83, 0x2a, 0xc6, 0xf5, 0x0f, 0xcf, 0xfd, 0xe9, 0x01, 0xb3, 0xcf, 0xfd, 0xcc, 0x26, 0x9a, 0x44, - 0x9f, 0xde, 0x5f, 0x4a, 0x5c, 0x78, 0xab, 0xf1, 0x96, 0xbf, 0xb4, 0xe2, 0xc2, 0xf9, 0x4a, 0xb7, 0xdb, 0x85, 0xa3, - 0xc3, 0x46, 0xe2, 0x69, 0xa3, 0x26, 0x80, 0x4c, 0xdf, 0x8a, 0xa9, 0xa4, 0x0b, 0x2b, 0xc8, 0xb4, 0x4f, 0xd2, 0x8d, - 0xc6, 0x53, 0x90, 0x4a, 0xb3, 0x58, 0x3d, 0x99, 0x19, 0xda, 0x68, 0x3d, 0x1c, 0x67, 0xd0, 0xff, 0x92, 0x18, 0xca, - 0x7a, 0xd9, 0xb6, 0x30, 0x5b, 0xa6, 0xba, 0xae, 0x3f, 0x6e, 0xa4, 0x95, 0xcc, 0xaa, 0x57, 0xd0, 0xf1, 0xf5, 0xfe, - 0x6d, 0x05, 0x4f, 0x24, 0x8a, 0x0f, 0x7b, 0xb7, 0x90, 0x68, 0x2d, 0x51, 0x2c, 0xe2, 0xfd, 0x32, 0x1d, 0xc7, 0x00, - 0xfc, 0xc1, 0xd0, 0x2d, 0x1d, 0xa7, 0xe9, 0xb1, 0xb2, 0x77, 0x68, 0x1f, 0x4a, 0x8a, 0x62, 0xb9, 0x48, 0xf8, 0x98, - 0x2d, 0xe0, 0xb8, 0x58, 0xa8, 0x86, 0xf6, 0x08, 0x16, 0x6d, 0x89, 0x2d, 0x7a, 0x4a, 0x8f, 0xa3, 0x1c, 0x23, 0xa6, - 0x51, 0xca, 0x97, 0xd1, 0xe3, 0x69, 0x4a, 0x00, 0x6d, 0x36, 0x64, 0x37, 0xef, 0x49, 0x12, 0xd6, 0xe4, 0x36, 0xb9, - 0x00, 0xb6, 0x7f, 0xe6, 0x54, 0xca, 0x5d, 0x1c, 0x44, 0x29, 0xed, 0xdc, 0xfc, 0x6e, 0x0e, 0xbc, 0x96, 0xeb, 0x22, - 0x31, 0xc6, 0xc8, 0x93, 0x2b, 0xa1, 0xa8, 0x65, 0xda, 0xf2, 0xae, 0x39, 0x12, 0xfc, 0xc2, 0x6b, 0xed, 0xad, 0x04, - 0x32, 0xd6, 0x65, 0xf8, 0x66, 0x74, 0x13, 0xb4, 0xf5, 0x9f, 0xec, 0x4d, 0xd7, 0x1b, 0xc4, 0xf2, 0xf3, 0xab, 0xba, - 0xea, 0xc8, 0xb3, 0xff, 0x50, 0xfb, 0x4e, 0x08, 0x2a, 0xe7, 0x26, 0x0c, 0xeb, 0x49, 0x7c, 0x2e, 0x3a, 0xde, 0x9d, - 0x48, 0x92, 0x16, 0xba, 0x3e, 0x93, 0x8e, 0x06, 0x0d, 0x93, 0x54, 0x50, 0x2e, 0x96, 0x81, 0xdf, 0x66, 0x29, 0xd1, - 0x8c, 0x88, 0x74, 0xaa, 0x56, 0x9f, 0x4c, 0x5f, 0xd4, 0x40, 0x5c, 0xaf, 0x02, 0x2b, 0x89, 0xfa, 0x4a, 0xff, 0x6d, - 0x0e, 0x35, 0x95, 0x1c, 0x3c, 0xf6, 0x7b, 0x03, 0xa3, 0x68, 0x52, 0x3d, 0xa9, 0xbb, 0x54, 0x38, 0xed, 0x04, 0x95, - 0x72, 0xe5, 0x29, 0x35, 0xe0, 0xa9, 0x5d, 0x1c, 0xf9, 0x99, 0x1f, 0x4c, 0x77, 0xc9, 0x9f, 0xb8, 0x17, 0xbf, 0xb0, - 0x0d, 0xa9, 0xfa, 0xcb, 0x1f, 0x6a, 0x03, 0xb2, 0x39, 0x09, 0xf5, 0xde, 0x8f, 0x43, 0x46, 0x35, 0xf7, 0x5b, 0xc7, - 0xe6, 0xf2, 0xa7, 0xdf, 0xde, 0xbd, 0xb9, 0xf0, 0x1b, 0xb4, 0x06, 0x65, 0xdd, 0xed, 0xaf, 0x6b, 0x78, 0x4a, 0xc5, - 0xbb, 0x2d, 0xc3, 0xcd, 0x92, 0xd1, 0x03, 0x90, 0x0f, 0xea, 0x9d, 0xff, 0xcc, 0xb5, 0x35, 0x4f, 0x75, 0x43, 0x73, - 0xb5, 0x08, 0x95, 0x33, 0x7f, 0x63, 0x18, 0xa9, 0x55, 0x4f, 0xf7, 0x64, 0x79, 0x63, 0x46, 0x03, 0xf7, 0x80, 0xa1, - 0x32, 0xc0, 0x8d, 0x96, 0x2e, 0x86, 0xd2, 0x5b, 0xd1, 0x97, 0xb6, 0xc5, 0xa6, 0x74, 0x5f, 0x6c, 0x4b, 0xeb, 0x62, - 0xb7, 0x71, 0x05, 0xdb, 0x92, 0xfe, 0x71, 0xfd, 0x1b, 0x7a, 0xa6, 0xd0, 0x63, 0xec, 0x2c, 0x3e, 0xe3, 0x65, 0xac, - 0xf5, 0x8d, 0x14, 0x59, 0xc1, 0x5b, 0xe3, 0x22, 0xd6, 0xc6, 0x0f, 0x25, 0x7b, 0x85, 0x71, 0x5f, 0x16, 0x58, 0x92, - 0x35, 0x1d, 0x0c, 0x8c, 0x54, 0x95, 0x56, 0xd2, 0x6d, 0x69, 0xf6, 0xdf, 0x2d, 0x5d, 0xc5, 0xc6, 0x42, 0xf3, 0x4b, - 0xaf, 0x74, 0x7a, 0x43, 0x62, 0x4d, 0xf6, 0xf3, 0x83, 0x0e, 0xc0, 0x8a, 0xd6, 0x45, 0x55, 0x91, 0x61, 0xbe, 0x56, - 0x91, 0x66, 0xd8, 0x13, 0x5c, 0x09, 0xd0, 0x40, 0xf5, 0x99, 0xa3, 0xf6, 0x21, 0x8e, 0x24, 0x56, 0xa3, 0x53, 0x0d, - 0xd9, 0x17, 0x45, 0x6c, 0x55, 0xbb, 0xa5, 0x46, 0xa9, 0x1a, 0x5d, 0xa2, 0x82, 0xca, 0x6f, 0x47, 0x8f, 0x88, 0x68, - 0x39, 0x6b, 0xf4, 0x21, 0x3e, 0x1f, 0x4d, 0xaf, 0x2b, 0x4e, 0x69, 0x80, 0x34, 0x48, 0x21, 0xb1, 0xa8, 0x74, 0xc1, - 0xcf, 0x04, 0xa4, 0xe5, 0x05, 0xfa, 0xd1, 0x55, 0x0c, 0x93, 0x33, 0x3c, 0x30, 0xf9, 0xad, 0xa3, 0x44, 0x7e, 0xb2, - 0xda, 0xe1, 0x37, 0xfc, 0xa5, 0xc5, 0x75, 0xa1, 0xf1, 0x96, 0x2b, 0xbf, 0x54, 0xcd, 0x55, 0x4c, 0xa1, 0x4b, 0x9f, - 0xc9, 0x6a, 0x86, 0x0c, 0xa6, 0xae, 0x62, 0x28, 0x01, 0x81, 0x6f, 0x40, 0x4a, 0x95, 0x41, 0x87, 0x10, 0x42, 0x6f, - 0xd0, 0x2a, 0x44, 0x74, 0x19, 0x36, 0x9f, 0x90, 0xaa, 0xb9, 0xce, 0x65, 0xf5, 0x68, 0xfe, 0x20, 0x26, 0xc1, 0x34, - 0xfc, 0x41, 0x23, 0x69, 0xb4, 0x07, 0x89, 0xc3, 0xa4, 0xd7, 0x21, 0xf4, 0x83, 0x37, 0xbd, 0x23, 0x0c, 0xdf, 0xfa, - 0xa4, 0xd3, 0xe3, 0x56, 0x92, 0xcb, 0xbf, 0x86, 0x95, 0x67, 0xa6, 0xd7, 0x26, 0xfc, 0x11, 0xfe, 0xa9, 0x0f, 0x66, - 0x75, 0x7b, 0x7b, 0x34, 0xc3, 0x6e, 0x68, 0x0c, 0x7f, 0x77, 0xc0, 0x5b, 0xf8, 0xc1, 0xf4, 0x35, 0x27, 0x76, 0x47, - 0xaf, 0x59, 0xb8, 0xce, 0xe7, 0xd1, 0xf8, 0x59, 0x9a, 0x17, 0xac, 0x3c, 0x79, 0x70, 0xdf, 0xfa, 0xde, 0x67, 0x12, - 0x19, 0x2f, 0x3f, 0x75, 0x79, 0xad, 0x2d, 0x27, 0x83, 0xf2, 0xc2, 0x52, 0xf7, 0xc3, 0x1e, 0xa7, 0x2f, 0xb5, 0xf6, - 0x97, 0x7a, 0xed, 0xb3, 0xcf, 0xa6, 0x26, 0x8f, 0x31, 0x3c, 0x1d, 0x4d, 0xdd, 0xd3, 0xc2, 0xfa, 0x16, 0x59, 0x21, - 0x36, 0xc7, 0xb7, 0xcb, 0xd1, 0xd3, 0x59, 0x6d, 0x2f, 0xae, 0xd0, 0xb4, 0x93, 0xd3, 0xa9, 0x13, 0x37, 0xaf, 0xa3, - 0x58, 0xd2, 0xb4, 0x8f, 0xef, 0xc7, 0x72, 0x87, 0xeb, 0x8a, 0x7a, 0x40, 0xd0, 0xa8, 0xa0, 0x17, 0x4c, 0xf5, 0xf8, - 0x74, 0x23, 0x40, 0x5d, 0x78, 0x3a, 0xb1, 0x4e, 0x53, 0xfd, 0x3d, 0xe0, 0x65, 0x60, 0x9a, 0x06, 0x5b, 0x3f, 0x54, - 0x92, 0x20, 0x97, 0x19, 0x6f, 0xfb, 0xf6, 0xfc, 0xf5, 0x3e, 0x5e, 0x58, 0x6a, 0x05, 0xf3, 0x5b, 0x7c, 0x0e, 0x52, - 0xb3, 0x80, 0x3b, 0x2a, 0x59, 0x84, 0x23, 0x88, 0x96, 0x77, 0xc8, 0x53, 0xc7, 0x01, 0xe9, 0xa0, 0x3a, 0x67, 0x24, - 0xe6, 0xf3, 0x5f, 0xed, 0x7b, 0x26, 0xf5, 0x7d, 0x0f, 0x5b, 0xaf, 0xde, 0x1d, 0x48, 0x39, 0xf4, 0x49, 0xf5, 0x19, - 0x68, 0x32, 0xf7, 0xdd, 0x56, 0x3a, 0x7d, 0xa3, 0xcf, 0xd6, 0xb5, 0xbb, 0x50, 0xf3, 0xd3, 0x54, 0xfa, 0xc4, 0x5e, - 0x39, 0x1b, 0xf5, 0x19, 0x94, 0x25, 0x73, 0x01, 0x04, 0x49, 0x8b, 0x40, 0x07, 0x3a, 0x71, 0xb6, 0x29, 0xd3, 0x40, - 0x74, 0x49, 0x6b, 0xce, 0xf8, 0x61, 0x9e, 0x9d, 0xe4, 0xd6, 0x7e, 0xcf, 0x49, 0x5c, 0x85, 0x73, 0xa8, 0xa0, 0xa0, - 0x79, 0x3c, 0xd1, 0x36, 0xf8, 0xaf, 0x17, 0xba, 0xc9, 0x89, 0x7c, 0x1e, 0xe6, 0x9c, 0xb6, 0x8c, 0x31, 0x42, 0x03, - 0x70, 0xd1, 0xf4, 0xea, 0x28, 0x60, 0xb9, 0x0b, 0x84, 0xdf, 0xf2, 0x79, 0xb7, 0xdd, 0xb6, 0xaa, 0x05, 0xa9, 0x76, - 0x62, 0x17, 0xd5, 0xcc, 0x32, 0x45, 0x06, 0xce, 0x00, 0x4f, 0xb6, 0x6f, 0x0b, 0xd9, 0xf8, 0xa0, 0xbd, 0xe9, 0xd2, - 0xe9, 0x51, 0x16, 0xf0, 0x83, 0x94, 0x93, 0x16, 0x9e, 0x1d, 0x43, 0xb1, 0x4d, 0x79, 0xb9, 0x2f, 0xf8, 0xd4, 0x35, - 0x86, 0xd4, 0x50, 0xda, 0x6c, 0x19, 0x29, 0xbc, 0x9b, 0x37, 0x06, 0x5c, 0xd2, 0xe2, 0xbd, 0x88, 0x31, 0xe0, 0xe1, - 0xfa, 0xa2, 0x45, 0x88, 0x27, 0x08, 0x73, 0xb8, 0x61, 0x86, 0x01, 0x74, 0x22, 0xe0, 0x60, 0x3a, 0xbd, 0xbd, 0x0e, - 0x7e, 0x4f, 0x56, 0x68, 0x4b, 0xaf, 0xe6, 0x0d, 0xb7, 0xab, 0x51, 0xba, 0xa1, 0x6d, 0x06, 0xb3, 0x7e, 0x3e, 0xf9, - 0x0d, 0xe5, 0xaa, 0xb3, 0x9a, 0xbf, 0x5c, 0xb0, 0x68, 0x75, 0x36, 0x73, 0x27, 0x9d, 0x1a, 0xdd, 0x53, 0xd5, 0x7a, - 0xea, 0x41, 0xb3, 0x37, 0xf4, 0x16, 0xd4, 0x14, 0x9a, 0x25, 0xc6, 0x1a, 0x3b, 0x1f, 0xfe, 0x47, 0xb6, 0xf0, 0x35, - 0x6b, 0x0f, 0xb4, 0xb6, 0x72, 0x7f, 0x6d, 0xc7, 0xd7, 0x08, 0x0e, 0xc3, 0x28, 0xc4, 0x09, 0xea, 0xd6, 0x5a, 0x52, - 0xe8, 0x56, 0xa7, 0x43, 0x54, 0x10, 0x93, 0xff, 0xa5, 0x37, 0xf3, 0x2e, 0x3e, 0x75, 0x0c, 0x9d, 0xab, 0x7f, 0x55, - 0x5c, 0x1d, 0x9b, 0xa6, 0xd9, 0xea, 0x5d, 0x3f, 0x17, 0x3e, 0xcc, 0xb4, 0xdf, 0x15, 0x2f, 0x3a, 0x42, 0x81, 0xc7, - 0x0f, 0x1e, 0xf6, 0xf5, 0x95, 0x15, 0xa4, 0x53, 0xcf, 0x27, 0xcc, 0x47, 0x4f, 0xd1, 0x31, 0x70, 0x43, 0x16, 0x13, - 0xef, 0xe3, 0x3a, 0x8b, 0xff, 0x59, 0xf6, 0xe1, 0x4c, 0xdb, 0x69, 0x54, 0x57, 0x8a, 0xc7, 0xb5, 0x08, 0xe8, 0xf3, - 0xe9, 0xe3, 0x12, 0x03, 0xd4, 0x5e, 0xac, 0x8a, 0x63, 0xb3, 0x41, 0x37, 0xbc, 0x2f, 0x84, 0xac, 0x57, 0x3a, 0xe3, - 0x3e, 0x2d, 0x12, 0x40, 0x5c, 0x7f, 0x44, 0x5d, 0x8b, 0xf9, 0xfa, 0xf2, 0xcd, 0xd1, 0xa6, 0xc7, 0x8c, 0x86, 0xc0, - 0x84, 0x59, 0xfb, 0x93, 0x51, 0x4a, 0xa7, 0x4f, 0xd1, 0x8a, 0xcf, 0x4d, 0xe1, 0x99, 0x6b, 0x75, 0x6d, 0x14, 0xe9, - 0x3f, 0x8a, 0xba, 0xf7, 0x31, 0x9c, 0x35, 0xaf, 0xbf, 0x60, 0x37, 0x07, 0xa3, 0x1f, 0x06, 0xcd, 0x41, 0x89, 0x45, - 0xbc, 0x7a, 0x12, 0x1f, 0x73, 0xbc, 0x26, 0x01, 0x3e, 0xe7, 0x39, 0x40, 0xff, 0x1c, 0x53, 0xcc, 0x25, 0x8c, 0xe3, - 0x63, 0x07, 0x54, 0x5b, 0x5b, 0x39, 0x24, 0xff, 0x66, 0xf6, 0x02, 0xb5, 0x59, 0xd7, 0x32, 0xa8, 0xbf, 0x83, 0xbc, - 0xda, 0xf4, 0xc2, 0xca, 0x41, 0xe7, 0x2b, 0x4b, 0xfa, 0xda, 0x04, 0xdd, 0xe2, 0xb2, 0xec, 0x80, 0xcf, 0xbc, 0xde, - 0x5d, 0x11, 0xbf, 0x14, 0xcc, 0x5b, 0xf8, 0x72, 0x1b, 0x9a, 0x70, 0x77, 0xe9, 0xa7, 0xc1, 0x09, 0xcd, 0x91, 0xdf, - 0x26, 0xa3, 0x0f, 0xdf, 0x7a, 0x76, 0xf5, 0xb2, 0x0e, 0xfc, 0x7f, 0xc3, 0x20, 0x10, 0x79, 0xa7, 0xd0, 0x2d, 0x69, - 0x9d, 0x7a, 0x14, 0x4b, 0x57, 0xca, 0x3e, 0xae, 0x5c, 0x7d, 0x74, 0x9b, 0xff, 0x1f, 0xae, 0xe0, 0x5b, 0xa3, 0xf8, - 0x49, 0x0c, 0xd0, 0x81, 0x22, 0x24, 0x3d, 0x22, 0xba, 0x78, 0xd6, 0xe2, 0xf1, 0x5b, 0x50, 0x33, 0xd8, 0xfa, 0x16, - 0xec, 0x04, 0x83, 0x90, 0x3d, 0x62, 0x9d, 0x0d, 0x1d, 0xb8, 0xfc, 0xad, 0x17, 0x65, 0x0e, 0x91, 0xde, 0x7c, 0x57, - 0x38, 0x75, 0x6d, 0xe5, 0x7d, 0xff, 0x97, 0xfa, 0xda, 0x64, 0x9e, 0xf3, 0xeb, 0x54, 0xf2, 0x85, 0xd3, 0x45, 0x57, - 0x21, 0xc6, 0xf1, 0xbb, 0x2b, 0x36, 0xde, 0x19, 0xf7, 0xc5, 0x45, 0xe4, 0xb4, 0xba, 0xf6, 0xd6, 0x4d, 0x0f, 0xba, - 0x71, 0x45, 0xf4, 0x18, 0xbf, 0xc4, 0x4c, 0xf7, 0xe6, 0x87, 0xc4, 0x3a, 0x7e, 0x37, 0xae, 0xf4, 0x5c, 0x4c, 0xe1, - 0x3e, 0x24, 0xf0, 0x3d, 0x7a, 0xb5, 0x42, 0x5c, 0x66, 0xdd, 0xf0, 0x82, 0x08, 0x50, 0x24, 0x00, 0x2b, 0x25, 0x09, - 0xa2, 0x25, 0x81, 0xe5, 0x70, 0xf2, 0xde, 0x56, 0x78, 0x6d, 0x7a, 0x77, 0x88, 0x16, 0x35, 0x2e, 0x54, 0x0c, 0x8f, - 0xbb, 0xa7, 0x93, 0xb9, 0x15, 0xa8, 0x57, 0xec, 0x41, 0x4c, 0x00, 0xa6, 0x05, 0x30, 0x56, 0x84, 0xcf, 0x6b, 0x44, - 0x1c, 0x00, 0x8a, 0x04, 0x0e, 0x30, 0xe2, 0x00, 0xfe, 0xbb, 0x9f, 0xf1, 0xa3, 0xf9, 0x85, 0x60, 0x59, 0xf4, 0x27, - 0xd3, 0x4f, 0xfb, 0x0c, 0x47, 0xe4, 0xf2, 0xe6, 0x21, 0x08, 0xb2, 0xda, 0x1c, 0xec, 0x8a, 0x1f, 0x60, 0x1b, 0xb7, - 0x27, 0xbc, 0xdc, 0x10, 0x5d, 0x3a, 0xab, 0xa4, 0xb4, 0x0b, 0xbe, 0xc0, 0xa5, 0x6f, 0xba, 0xbf, 0xa4, 0x87, 0xd5, - 0xc2, 0x17, 0xe3, 0x9e, 0xd5, 0x30, 0x3f, 0x78, 0xf1, 0xe8, 0xff, 0xac, 0x7a, 0xdd, 0x61, 0x63, 0x1c, 0xfe, 0x31, - 0xe0, 0x87, 0xa0, 0xf9, 0x49, 0xf6, 0xde, 0x47, 0xb7, 0xf6, 0xbd, 0x24, 0x39, 0x99, 0x1e, 0x56, 0x18, 0x4e, 0x3f, - 0x5e, 0x60, 0x55, 0x06, 0x3f, 0x97, 0x25, 0xd5, 0x5d, 0x85, 0x5f, 0x5c, 0x13, 0x61, 0x70, 0x0e, 0xef, 0xf8, 0x02, - 0x40, 0x5a, 0xcc, 0x70, 0x25, 0x5d, 0xeb, 0xf5, 0x77, 0x2f, 0xf8, 0xd6, 0x69, 0x92, 0x48, 0x20, 0x72, 0x5a, 0xc9, - 0xe1, 0x6c, 0x08, 0x4a, 0x4e, 0xca, 0xc3, 0x9c, 0x32, 0x38, 0x4b, 0x95, 0xd3, 0xa2, 0xc0, 0x9f, 0xda, 0xd9, 0xdd, - 0xba, 0xbc, 0x58, 0xd1, 0x1a, 0x4b, 0xf5, 0xbe, 0x0c, 0x35, 0x44, 0xb0, 0xd8, 0xf2, 0x69, 0x4b, 0x98, 0xfd, 0x0d, - 0x66, 0x53, 0x83, 0x08, 0xbf, 0xcf, 0x53, 0x42, 0x57, 0xde, 0x44, 0x04, 0x26, 0x54, 0x1f, 0x9a, 0x22, 0x46, 0x7a, - 0x44, 0xa7, 0x45, 0x42, 0x52, 0xab, 0x34, 0x42, 0x63, 0x0d, 0x89, 0x7e, 0xbf, 0x75, 0xcf, 0xab, 0xe5, 0x38, 0x1e, - 0xa3, 0xf2, 0x47, 0xd1, 0x6f, 0x30, 0x23, 0x17, 0xa4, 0xdd, 0xb0, 0x2b, 0x62, 0x98, 0xb2, 0x60, 0x18, 0xa8, 0xb2, - 0x41, 0x49, 0xe0, 0xb6, 0x62, 0xdb, 0xbf, 0xe3, 0xfb, 0x30, 0x22, 0xda, 0x4d, 0xc0, 0xcf, 0x3c, 0xa1, 0x76, 0x63, - 0x01, 0x1d, 0x7a, 0xc0, 0x6f, 0x58, 0xc3, 0x77, 0x4d, 0x14, 0xe9, 0x04, 0x4e, 0xd0, 0xb2, 0x48, 0xe2, 0xd3, 0xbd, - 0xf1, 0xff, 0x2f, 0x85, 0x54, 0x9f, 0xf7, 0xf7, 0xb7, 0x8d, 0x48, 0x0d, 0x3d, 0x15, 0xa8, 0xc8, 0xb8, 0x02, 0x5b, - 0xf6, 0x78, 0x29, 0x72, 0xc0, 0xc4, 0xe4, 0x5f, 0xb1, 0xc1, 0x4a, 0xe7, 0x8d, 0xe3, 0xd3, 0xbf, 0x60, 0x5a, 0x9c, - 0xed, 0x61, 0x16, 0xf3, 0x30, 0xfe, 0x4b, 0x47, 0x0f, 0x7a, 0xac, 0x87, 0x12, 0x2b, 0xe1, 0xc7, 0x65, 0x3e, 0xdc, - 0xf3, 0x8d, 0x59, 0xbe, 0xde, 0x1f, 0x2e, 0xec, 0x59, 0x89, 0xce, 0x8f, 0x7e, 0x89, 0xc5, 0x38, 0x32, 0xfe, 0x1b, - 0x6d, 0xc9, 0xe6, 0x36, 0xe0, 0x4e, 0x32, 0xa7, 0x77, 0x47, 0x47, 0x23, 0x0b, 0x72, 0x86, 0x25, 0xba, 0xbb, 0xe5, - 0x92, 0xdc, 0x65, 0xce, 0x2e, 0xfb, 0xfc, 0xeb, 0x7d, 0x76, 0xe1, 0x45, 0x7b, 0x4d, 0x9a, 0x4f, 0xd2, 0x06, 0x94, - 0x16, 0xb8, 0x3f, 0x9b, 0xdd, 0x22, 0x2a, 0x11, 0x32, 0x84, 0xf8, 0x82, 0x3b, 0x22, 0x05, 0xfb, 0x1d, 0xdb, 0x54, - 0x3c, 0xd0, 0x8d, 0xa8, 0xd7, 0x83, 0x97, 0x76, 0xdd, 0xf6, 0x8d, 0x01, 0x37, 0x4c, 0xd6, 0x2a, 0x46, 0xb5, 0xa0, - 0x59, 0x98, 0xde, 0x4e, 0x3e, 0x48, 0x55, 0x57, 0x12, 0x7a, 0x18, 0x1a, 0xf8, 0x14, 0xfb, 0x5a, 0xd7, 0x19, 0xbd, - 0x0c, 0x88, 0x7e, 0xc6, 0x0e, 0x3d, 0xf6, 0x03, 0xb3, 0xfc, 0x20, 0xe8, 0x62, 0xa9, 0x97, 0x40, 0x04, 0x34, 0x78, - 0x4d, 0x23, 0x56, 0x41, 0x9c, 0xb5, 0xd1, 0x61, 0xab, 0xa6, 0x07, 0x72, 0x8a, 0xbf, 0x58, 0x42, 0x28, 0x11, 0x5f, - 0x4d, 0xd3, 0xd2, 0x56, 0xe6, 0xe8, 0x2f, 0x0f, 0xc2, 0x5a, 0x90, 0x68, 0xea, 0x8c, 0xed, 0xad, 0xd2, 0x71, 0xf3, - 0x96, 0x97, 0x27, 0x24, 0xd0, 0xb6, 0x15, 0x61, 0x9e, 0x7f, 0xf2, 0x9f, 0xa6, 0xd6, 0x75, 0x0d, 0x5e, 0x99, 0x98, - 0xbf, 0x13, 0xb9, 0x95, 0xd3, 0xd1, 0x0f, 0x4d, 0xaa, 0x57, 0x0f, 0xb8, 0xc2, 0x7b, 0x33, 0xfe, 0xf3, 0x80, 0xd4, - 0xee, 0x38, 0x87, 0x33, 0x10, 0xa2, 0x79, 0x4e, 0x80, 0xd2, 0xa0, 0xe3, 0xe6, 0x20, 0x98, 0x95, 0x01, 0xc9, 0xce, - 0xea, 0x56, 0x7a, 0x8d, 0xcb, 0xd6, 0x89, 0x83, 0x74, 0xfb, 0x17, 0x62, 0xf2, 0x2c, 0xa5, 0x2b, 0x98, 0xe5, 0x65, - 0x42, 0x57, 0x2d, 0x06, 0x0a, 0x13, 0x39, 0x22, 0xfb, 0xbf, 0x62, 0x45, 0x1f, 0xac, 0xdf, 0x86, 0x8b, 0xb1, 0x23, - 0x24, 0xfb, 0x69, 0x16, 0xad, 0x91, 0xd2, 0xc8, 0x64, 0xc3, 0xe4, 0x52, 0x20, 0x57, 0x02, 0x09, 0x35, 0xea, 0x38, - 0x94, 0x83, 0x01, 0x9d, 0xda, 0x39, 0x28, 0x21, 0xec, 0x4b, 0x14, 0x50, 0x62, 0x44, 0x2a, 0x14, 0xfb, 0x39, 0x3a, - 0x4b, 0x19, 0x62, 0x66, 0x3a, 0x02, 0xee, 0x53, 0xa3, 0x84, 0x64, 0x32, 0x68, 0x00, 0xbd, 0xa5, 0x1d, 0xd4, 0x0f, - 0x70, 0x58, 0x64, 0xc4, 0xa5, 0x09, 0x80, 0xcf, 0x29, 0x6c, 0x6b, 0xff, 0x1e, 0x94, 0x2f, 0x5b, 0x17, 0x3d, 0xc8, - 0xd4, 0x45, 0x20, 0x74, 0x32, 0x8b, 0x05, 0x2a, 0xc3, 0xe5, 0xf0, 0xfb, 0xd4, 0x61, 0xaf, 0xa9, 0xd3, 0x4e, 0x91, - 0xc4, 0x5d, 0x9a, 0x69, 0xe8, 0xfb, 0x61, 0xdd, 0xdb, 0x34, 0xa9, 0xd8, 0x11, 0x78, 0x6b, 0x19, 0xcf, 0x42, 0xbb, - 0x51, 0x8c, 0x7d, 0x40, 0xde, 0xc8, 0xd0, 0xf9, 0x7f, 0x1b, 0x9b, 0x7e, 0xe0, 0x17, 0x9e, 0xa6, 0xcf, 0x9c, 0xf4, - 0xf3, 0xb0, 0x20, 0xbb, 0xc1, 0x4e, 0x45, 0x61, 0x45, 0x89, 0x2f, 0x50, 0x65, 0x53, 0x0d, 0xdd, 0x6b, 0x51, 0x28, - 0x92, 0x14, 0x72, 0x74, 0x61, 0x3c, 0xb9, 0x3c, 0x49, 0xb6, 0x5a, 0x46, 0xa5, 0x48, 0x12, 0xae, 0x4d, 0x48, 0xd6, - 0x09, 0x25, 0xda, 0xe7, 0xb1, 0xce, 0x48, 0xda, 0x8c, 0x0b, 0x76, 0xd6, 0x82, 0x6b, 0x53, 0xbb, 0xb9, 0x38, 0x65, - 0x1e, 0x6a, 0xfe, 0x44, 0x15, 0xa6, 0xcc, 0x9a, 0xa7, 0xb2, 0x36, 0xb9, 0x6a, 0xc8, 0x34, 0xf2, 0xa1, 0xbe, 0x0f, - 0xa9, 0x5e, 0x1c, 0x4e, 0x44, 0xc9, 0xf5, 0x89, 0x4b, 0x07, 0x00, 0xc4, 0x70, 0x9c, 0xf9, 0x65, 0xc9, 0x41, 0x14, - 0x70, 0xa2, 0x94, 0x29, 0xd9, 0x32, 0xb8, 0x1f, 0xc0, 0xbe, 0xb2, 0x1d, 0x05, 0x4a, 0xe6, 0xd8, 0x71, 0xed, 0x6f, - 0x4a, 0x48, 0x01, 0xfb, 0xa9, 0x92, 0x83, 0x71, 0x1d, 0x86, 0xea, 0x1c, 0xcc, 0x1d, 0x69, 0x17, 0xde, 0x57, 0x0c, - 0x5d, 0x9c, 0x8b, 0x22, 0x12, 0x2a, 0x09, 0x1f, 0x0f, 0x30, 0x9f, 0x17, 0x29, 0xec, 0x63, 0x42, 0xf4, 0x94, 0x43, - 0x54, 0x6a, 0xb5, 0x55, 0x0e, 0xf2, 0x82, 0x69, 0x63, 0x2a, 0xfb, 0x48, 0x1a, 0x40, 0xfc, 0x24, 0x6e, 0x50, 0xaa, - 0x6a, 0x9d, 0x76, 0x2b, 0x9a, 0xdb, 0x1a, 0x39, 0xb8, 0x6a, 0xbf, 0x31, 0xad, 0x2a, 0xb0, 0x13, 0x72, 0x2a, 0xa7, - 0x61, 0xeb, 0x4e, 0xc6, 0xbf, 0xdd, 0xaf, 0xa6, 0xbf, 0xfc, 0xb2, 0x14, 0x95, 0x60, 0x84, 0xcc, 0x64, 0x80, 0x6f, - 0x84, 0x10, 0xbc, 0x68, 0x6f, 0x3d, 0x54, 0xb6, 0x45, 0x1c, 0x47, 0x1d, 0x87, 0x15, 0x24, 0x10, 0xe6, 0x73, 0xb9, - 0x3b, 0x5b, 0x8d, 0x2e, 0xf6, 0xee, 0xa8, 0x7c, 0x95, 0x27, 0x89, 0x55, 0xc1, 0x4e, 0x49, 0xf1, 0x31, 0x00, 0x58, - 0x92, 0x27, 0x82, 0x15, 0xe4, 0x8e, 0x37, 0x0d, 0x7c, 0x98, 0xf0, 0x24, 0xf9, 0xbf, 0xbe, 0x09, 0xfc, 0x4c, 0x71, - 0xc9, 0xf2, 0x6d, 0x79, 0x30, 0x59, 0xce, 0x56, 0x2d, 0x05, 0x44, 0x23, 0x02, 0x13, 0x87, 0x7c, 0x9c, 0x5f, 0x27, - 0xd9, 0xbb, 0x0c, 0xf1, 0xa9, 0xf9, 0xa0, 0x27, 0x34, 0xcf, 0xfc, 0x26, 0x34, 0xf4, 0xb8, 0x52, 0x05, 0x5a, 0x02, - 0x42, 0x13, 0xf7, 0x8f, 0xd7, 0x86, 0x0e, 0xa6, 0x59, 0x7f, 0x41, 0xc0, 0x00, 0xab, 0xbc, 0xad, 0xa0, 0x0a, 0x73, - 0x3b, 0x12, 0xde, 0xd4, 0x0d, 0xe1, 0x2b, 0x67, 0xc6, 0xd1, 0xc9, 0x14, 0x3e, 0x19, 0x10, 0x40, 0x7c, 0x54, 0x6f, - 0x44, 0x43, 0x7c, 0x33, 0xcf, 0xaa, 0x3a, 0xb7, 0xb0, 0x55, 0xec, 0x97, 0xf0, 0x47, 0xaf, 0x61, 0x2f, 0xac, 0x8c, - 0x97, 0xc8, 0x15, 0x3f, 0xeb, 0xe8, 0xf8, 0x39, 0x68, 0x53, 0x43, 0xeb, 0x51, 0xa5, 0x0a, 0x15, 0xc7, 0x0c, 0x23, - 0x8a, 0x05, 0x9e, 0x63, 0x8c, 0x4f, 0xe8, 0x9e, 0xdb, 0xf2, 0xd7, 0xc8, 0xb0, 0xf9, 0x2f, 0x87, 0xf2, 0x75, 0xe6, - 0x98, 0xd0, 0x33, 0xe5, 0x4c, 0x85, 0x33, 0x1c, 0x61, 0xac, 0x37, 0xbe, 0xc1, 0xdc, 0x55, 0x33, 0xb6, 0xb5, 0x3a, - 0x93, 0xa2, 0xe9, 0x52, 0x54, 0x9f, 0x41, 0x43, 0xbc, 0xeb, 0xc6, 0xc0, 0xc2, 0xdd, 0x9f, 0x03, 0x42, 0x6e, 0x0e, - 0x85, 0xab, 0xda, 0x8c, 0x10, 0x6a, 0x09, 0xd4, 0x67, 0x85, 0xb0, 0x92, 0x56, 0x49, 0x4a, 0x4d, 0x31, 0xcf, 0x1f, - 0xc1, 0x7a, 0xaf, 0xf9, 0xff, 0x97, 0x19, 0xd1, 0xf7, 0xcb, 0xfe, 0x33, 0x7e, 0x41, 0xf4, 0x8c, 0x15, 0x4b, 0x26, - 0xfa, 0xf6, 0xba, 0x60, 0xc0, 0x09, 0xdf, 0x5e, 0xc3, 0xa9, 0xb5, 0xae, 0xdd, 0x4f, 0x0f, 0xe1, 0xfe, 0xbc, 0x51, - 0x2c, 0x9d, 0x22, 0x84, 0x58, 0xca, 0xcb, 0xcc, 0x54, 0xd2, 0x8a, 0x99, 0x17, 0x1d, 0x40, 0x9a, 0x77, 0x61, 0x76, - 0x9b, 0x72, 0x94, 0x25, 0x81, 0x67, 0x15, 0x30, 0xcd, 0xb0, 0x9d, 0x13, 0xa8, 0x5f, 0x1c, 0xff, 0x1d, 0xeb, 0xfe, - 0x0b, 0xe7, 0xa0, 0xee, 0xcf, 0x4f, 0x21, 0x91, 0x05, 0x4a, 0x94, 0x8c, 0x9a, 0x6e, 0x47, 0x75, 0x27, 0xeb, 0xdd, - 0x0b, 0x53, 0x22, 0x26, 0x5d, 0xf9, 0xdc, 0xcf, 0xed, 0x03, 0x68, 0x68, 0xab, 0x50, 0x55, 0x77, 0x65, 0xe3, 0x7c, - 0x45, 0x4b, 0x36, 0x20, 0xfd, 0x56, 0xfa, 0xe2, 0x06, 0x99, 0x97, 0x25, 0x51, 0x56, 0x91, 0xb3, 0xa4, 0xdb, 0xd3, - 0x39, 0x0a, 0x99, 0xe3, 0x7c, 0xe5, 0x85, 0xad, 0x95, 0xf6, 0xb5, 0x2a, 0xdb, 0x70, 0xa9, 0xa4, 0x68, 0x11, 0xcc, - 0x7a, 0x9f, 0xa3, 0xfe, 0x2e, 0x6f, 0x92, 0x89, 0x62, 0x54, 0x55, 0xbc, 0xae, 0x44, 0x2f, 0x7e, 0x7e, 0x0d, 0xc7, - 0x84, 0x7e, 0xf5, 0x07, 0xbd, 0xa5, 0xea, 0xde, 0x77, 0x98, 0xca, 0xec, 0xcd, 0x21, 0x88, 0xd2, 0x0d, 0xe9, 0xd5, - 0x5f, 0x89, 0x8f, 0xeb, 0xed, 0x89, 0x60, 0x39, 0x5d, 0x57, 0xf6, 0xeb, 0x7c, 0x5c, 0x0a, 0x73, 0x1e, 0xa9, 0x97, - 0xa6, 0xc1, 0xaf, 0x54, 0x51, 0x61, 0xce, 0xfa, 0xc7, 0x6c, 0x0a, 0xce, 0x4b, 0xd7, 0x32, 0x84, 0x1c, 0x91, 0xd0, - 0xc8, 0x91, 0x60, 0xce, 0xbf, 0x50, 0x8c, 0x5f, 0xb4, 0x49, 0xec, 0x8e, 0x5f, 0xc9, 0x6e, 0xa8, 0xe9, 0xa7, 0xcf, - 0xb9, 0x4b, 0x27, 0x54, 0x50, 0x7b, 0x82, 0x4b, 0xb0, 0xc0, 0xfb, 0x2b, 0x9b, 0x74, 0x31, 0xaa, 0xaa, 0x57, 0xe7, - 0xf3, 0x8f, 0x86, 0x38, 0x4c, 0x05, 0x14, 0x16, 0x6f, 0x32, 0x87, 0x76, 0x86, 0xd7, 0x74, 0x98, 0x67}; + 0x1b, 0x31, 0x92, 0xa3, 0x10, 0xd8, 0x38, 0x10, 0x90, 0xc0, 0xfe, 0x07, 0x45, 0x14, 0x95, 0x10, 0x40, 0xad, 0x0b, + 0x78, 0x32, 0xfa, 0x5c, 0x35, 0x22, 0x99, 0xac, 0xc5, 0x71, 0xac, 0xdb, 0x3d, 0x54, 0xbb, 0xb7, 0xad, 0x16, 0x21, + 0x84, 0xd0, 0x03, 0xc3, 0x2e, 0xef, 0xbd, 0x45, 0x8d, 0x9e, 0xad, 0xd2, 0x46, 0x2b, 0x2c, 0xc0, 0xad, 0x22, 0xd6, + 0xa2, 0xa0, 0x8b, 0xc3, 0x14, 0xeb, 0x29, 0x7f, 0x9e, 0xd1, 0x3d, 0x73, 0xac, 0xd2, 0x23, 0x34, 0xf6, 0x49, 0xee, + 0xbd, 0x9a, 0xda, 0xd7, 0x3f, 0x4d, 0x45, 0x29, 0x7a, 0xf4, 0x60, 0x05, 0x50, 0xa4, 0x94, 0x13, 0xd4, 0x08, 0x3e, + 0x72, 0x9c, 0xf6, 0x26, 0x4e, 0xf6, 0x92, 0xf5, 0x35, 0x34, 0x09, 0x2a, 0xdc, 0xa5, 0x40, 0x3f, 0x12, 0x3a, 0x1c, + 0x10, 0xe9, 0x8b, 0xad, 0xca, 0x14, 0xd5, 0xfa, 0xaa, 0xbf, 0x9c, 0xd6, 0xb4, 0x1c, 0xd5, 0x7e, 0x72, 0xec, 0x50, + 0x01, 0x27, 0x9c, 0x71, 0x3a, 0xf5, 0x90, 0xda, 0x6c, 0xdf, 0xaf, 0x5e, 0xa7, 0x5f, 0xbf, 0x16, 0x69, 0x27, 0xdb, + 0x11, 0x52, 0x4a, 0x3f, 0x12, 0xc0, 0xa5, 0x21, 0xec, 0x3e, 0x19, 0x52, 0xee, 0x0c, 0xcf, 0xb0, 0x20, 0xf6, 0xf0, + 0xde, 0xca, 0x4d, 0x63, 0xf8, 0x3e, 0xd5, 0xb4, 0x77, 0x53, 0x9d, 0x32, 0x57, 0xf7, 0x86, 0xe7, 0x10, 0xf1, 0x05, + 0xc1, 0xa9, 0x76, 0xee, 0x6c, 0x8e, 0x40, 0x85, 0xec, 0x4c, 0x39, 0x81, 0x5b, 0x74, 0x8d, 0xc1, 0x89, 0x53, 0xf9, + 0x09, 0xd5, 0x00, 0xeb, 0x99, 0xd6, 0xb7, 0xd4, 0x55, 0x45, 0xe9, 0x72, 0x01, 0x72, 0xc9, 0x35, 0xad, 0x1c, 0xa8, + 0xb1, 0x2e, 0x88, 0x2f, 0xf4, 0x5a, 0x02, 0x89, 0xde, 0xfd, 0x61, 0x35, 0x70, 0xff, 0xf4, 0xd3, 0x43, 0x0b, 0x39, + 0xc2, 0x28, 0x6a, 0xeb, 0xff, 0x83, 0xe0, 0xad, 0xe0, 0x02, 0xa9, 0x15, 0x2f, 0x7f, 0x6f, 0xa6, 0x65, 0xda, 0x33, + 0xb4, 0x77, 0x27, 0x17, 0x84, 0x52, 0xac, 0x48, 0xa5, 0x20, 0x01, 0x29, 0xe3, 0x23, 0x17, 0xc4, 0x0a, 0x42, 0xf4, + 0x33, 0xff, 0x2d, 0x7e, 0xbb, 0xc3, 0x74, 0x63, 0x46, 0x9a, 0xc1, 0x00, 0x47, 0x18, 0x42, 0x02, 0x41, 0xa2, 0x08, + 0x80, 0x64, 0x15, 0xe8, 0xfe, 0xff, 0xdd, 0x03, 0x74, 0xf7, 0x80, 0x28, 0xcc, 0xac, 0x03, 0xb0, 0xbc, 0xa2, 0x93, + 0xc1, 0x79, 0x2c, 0xf7, 0xce, 0x47, 0xce, 0x47, 0x1b, 0xc9, 0xd8, 0x28, 0x31, 0x36, 0x55, 0xae, 0x2c, 0x30, 0x36, + 0x08, 0x15, 0x0a, 0xfe, 0x57, 0x1c, 0xcd, 0x2c, 0x09, 0xee, 0xb0, 0xf5, 0x7b, 0x59, 0x87, 0xea, 0x7d, 0xd2, 0x4a, + 0x38, 0xc6, 0xf8, 0x62, 0x9a, 0x66, 0xdd, 0x96, 0xa1, 0xea, 0x5b, 0x9a, 0xce, 0xe9, 0x5b, 0xcd, 0x15, 0xd7, 0x18, + 0x84, 0xa4, 0x90, 0xb9, 0x4e, 0x04, 0x7b, 0xcf, 0x4c, 0x26, 0xce, 0x88, 0x03, 0xc8, 0x29, 0x18, 0x43, 0x8d, 0x25, + 0x03, 0x29, 0x71, 0x5e, 0x43, 0x7b, 0xe1, 0x04, 0xd3, 0xa5, 0x3d, 0x4c, 0xea, 0x2c, 0xb9, 0x90, 0x83, 0xa8, 0x71, + 0x0c, 0xe0, 0x10, 0x7e, 0xf4, 0x02, 0xbd, 0x19, 0x04, 0x06, 0x2c, 0x6d, 0x5a, 0xe3, 0x2a, 0xd8, 0xde, 0x8d, 0x60, + 0x79, 0xd6, 0x6c, 0x18, 0x42, 0xd2, 0xc6, 0xfb, 0x8b, 0xeb, 0x6b, 0xb4, 0x56, 0xf0, 0x1f, 0xca, 0xe7, 0xfe, 0x3d, + 0x8c, 0xc8, 0x97, 0x8a, 0x2d, 0xb3, 0xed, 0x90, 0xa8, 0x0f, 0x07, 0x10, 0x97, 0xe1, 0xad, 0x74, 0x54, 0x6d, 0x97, + 0xf3, 0x2c, 0xd8, 0xf1, 0x71, 0x96, 0x7c, 0x90, 0x67, 0xbe, 0x7f, 0x7d, 0x5d, 0xca, 0xcc, 0x38, 0xcb, 0x59, 0xfb, + 0x6d, 0xda, 0x06, 0x29, 0x22, 0xf6, 0xc3, 0x85, 0x4a, 0x6f, 0xfa, 0x98, 0xdd, 0x71, 0xd2, 0xe0, 0x25, 0x8e, 0x11, + 0xbf, 0x6c, 0xd3, 0x02, 0xa8, 0x14, 0x34, 0x7a, 0xda, 0x25, 0xe5, 0xda, 0xff, 0x51, 0x7e, 0x74, 0xbb, 0x59, 0xfa, + 0xb6, 0x23, 0x4c, 0x62, 0xa4, 0x43, 0xcb, 0x98, 0x5e, 0xda, 0xe6, 0x70, 0x61, 0xcc, 0x6b, 0xd0, 0xba, 0xf8, 0x71, + 0x9d, 0xe9, 0x81, 0x80, 0x8e, 0x80, 0x77, 0x1b, 0x54, 0x89, 0x17, 0xcf, 0xbe, 0xf1, 0xeb, 0xa1, 0x03, 0xb7, 0xdb, + 0xc8, 0xd6, 0xc7, 0xbf, 0x0a, 0x05, 0xcd, 0x2d, 0x70, 0xf9, 0xd1, 0xd1, 0x3f, 0xdc, 0x4e, 0xaf, 0xc5, 0xa2, 0x3d, + 0x7f, 0x83, 0xf5, 0x5c, 0x3d, 0x04, 0x93, 0x1e, 0x56, 0x69, 0x9c, 0xb9, 0x0d, 0x62, 0xbf, 0xae, 0x40, 0xda, 0x2a, + 0x31, 0x85, 0xf2, 0x2c, 0x05, 0xb2, 0x32, 0xeb, 0x11, 0xe2, 0xf9, 0x3e, 0xd4, 0x08, 0xa6, 0xbc, 0x57, 0x55, 0xdc, + 0xa5, 0xf6, 0xb7, 0x43, 0xa3, 0x17, 0xfd, 0x3b, 0x2d, 0x62, 0x60, 0xfe, 0x6a, 0x12, 0x9b, 0xba, 0x05, 0x86, 0x80, + 0x32, 0x67, 0x60, 0x9a, 0x48, 0x05, 0x84, 0xd9, 0x98, 0x9d, 0x61, 0x3d, 0xce, 0x3f, 0xe4, 0xfa, 0xde, 0xe4, 0x00, + 0xf9, 0x36, 0x86, 0xf6, 0x61, 0x6b, 0xb1, 0xd2, 0xeb, 0x04, 0x64, 0x26, 0x6d, 0x23, 0x04, 0x51, 0x0c, 0xea, 0xdc, + 0x2a, 0xbb, 0xcd, 0x1b, 0x2f, 0xa8, 0xd3, 0x5c, 0x44, 0xce, 0xee, 0x12, 0x64, 0x1d, 0x7f, 0xdf, 0x4b, 0x4a, 0x0f, + 0xc8, 0x44, 0x1c, 0xc2, 0xef, 0x01, 0x83, 0x20, 0x03, 0x66, 0x51, 0x64, 0x51, 0xb2, 0x8c, 0xee, 0xdd, 0x57, 0x74, + 0xcd, 0x87, 0xa4, 0x76, 0x69, 0x1d, 0x37, 0x83, 0x51, 0x32, 0x85, 0xde, 0x30, 0x65, 0x80, 0x3a, 0x63, 0xfb, 0xb6, + 0x49, 0x9c, 0xad, 0xc5, 0x73, 0xcc, 0x00, 0x66, 0xc8, 0x08, 0xab, 0x06, 0x3c, 0xc4, 0x65, 0x09, 0x65, 0xad, 0x8c, + 0x44, 0x10, 0xb9, 0xc3, 0xc6, 0xf7, 0x7b, 0xc5, 0x86, 0x58, 0x73, 0x63, 0x9d, 0x69, 0xf0, 0x8d, 0x87, 0x6f, 0xc1, + 0xac, 0x8e, 0xb1, 0xd4, 0x55, 0x72, 0x32, 0x00, 0x69, 0x57, 0xa0, 0x4f, 0x5e, 0xa4, 0x2f, 0x24, 0xbc, 0xb7, 0xc0, + 0x17, 0xe3, 0x80, 0x0d, 0x28, 0xb6, 0x5c, 0xee, 0x3a, 0x11, 0x9f, 0x04, 0x4b, 0xc7, 0x34, 0xe5, 0xf0, 0x00, 0xb2, + 0x4a, 0x46, 0x2f, 0x2d, 0x16, 0x66, 0x8e, 0x3a, 0xfe, 0x58, 0xa4, 0x87, 0xa9, 0x87, 0x9e, 0x50, 0x68, 0x63, 0x4f, + 0x22, 0x28, 0x02, 0x57, 0xc5, 0x3f, 0x9d, 0x18, 0x24, 0x58, 0xf5, 0x6a, 0x2f, 0x1b, 0x93, 0xeb, 0x94, 0x08, 0xa9, + 0xa6, 0x95, 0x3a, 0x2d, 0x67, 0x72, 0x6d, 0x24, 0x4e, 0x40, 0x4c, 0x16, 0xb1, 0x70, 0x6b, 0xa3, 0x22, 0x73, 0x94, + 0xb3, 0x74, 0xda, 0x2e, 0xb0, 0x19, 0x4b, 0x4b, 0x77, 0x1e, 0x61, 0xe8, 0x13, 0x74, 0x99, 0x69, 0x79, 0xce, 0x51, + 0xda, 0x99, 0x06, 0xd3, 0x58, 0xe1, 0x82, 0xc9, 0x75, 0x36, 0x65, 0xe4, 0x91, 0xe3, 0x31, 0xea, 0xfa, 0xa4, 0x18, + 0xff, 0x4a, 0x40, 0x02, 0x1b, 0x3a, 0x64, 0x45, 0xc1, 0xae, 0x56, 0x55, 0x3e, 0x28, 0x6b, 0x4e, 0xdd, 0x5e, 0x1d, + 0x4c, 0xa2, 0x79, 0x41, 0x0d, 0xcf, 0x6b, 0x5a, 0x39, 0xd9, 0x8c, 0x6b, 0x31, 0xc7, 0xc9, 0x9b, 0x2d, 0xbc, 0x6f, + 0xbb, 0xae, 0x84, 0xbf, 0xca, 0x6a, 0xcd, 0xad, 0x57, 0xa5, 0x54, 0xf7, 0x59, 0xb8, 0x8f, 0xf0, 0x95, 0x5c, 0xec, + 0x2d, 0xb5, 0x3a, 0x12, 0x8d, 0x54, 0x17, 0x6b, 0x47, 0x37, 0x73, 0x76, 0x5c, 0x96, 0xed, 0x31, 0x69, 0x90, 0x7e, + 0xba, 0x49, 0x3a, 0xe2, 0xe2, 0x6c, 0x26, 0x2e, 0xea, 0x79, 0x6c, 0x16, 0x7e, 0x6d, 0xea, 0x7b, 0x85, 0xc9, 0xaa, + 0xb1, 0xc5, 0x67, 0x4c, 0x00, 0x2f, 0x77, 0x9e, 0x70, 0xaa, 0x46, 0xf7, 0x31, 0xc1, 0x4d, 0x61, 0x53, 0x10, 0x53, + 0x90, 0x81, 0x09, 0xf9, 0xad, 0x7a, 0x4d, 0x53, 0xeb, 0xcc, 0x48, 0x08, 0xc5, 0xb8, 0xb4, 0x06, 0x82, 0x54, 0x47, + 0x05, 0x69, 0x16, 0x82, 0x37, 0x90, 0xa7, 0x71, 0xa1, 0x2c, 0x64, 0x6e, 0xc9, 0x3e, 0x75, 0x95, 0x1e, 0xf6, 0xda, + 0x4b, 0xdc, 0x78, 0xb2, 0x2a, 0xef, 0x01, 0xac, 0xad, 0xd1, 0x4a, 0xae, 0xe6, 0x71, 0x90, 0x1e, 0x47, 0x18, 0xc1, + 0xf0, 0xf8, 0xd8, 0x0e, 0xed, 0x03, 0x29, 0x5f, 0xc8, 0x70, 0x56, 0x5a, 0xfd, 0x10, 0xca, 0x4d, 0x1f, 0x04, 0x00, + 0x10, 0x6f, 0xd2, 0xdb, 0xbd, 0x63, 0xc1, 0x8a, 0xf6, 0x0f, 0xc0, 0x89, 0x46, 0x4d, 0xea, 0xb8, 0xc2, 0xd8, 0x43, + 0x7d, 0x83, 0xc3, 0xfc, 0xc7, 0x5e, 0xba, 0x56, 0xbf, 0xdd, 0xe0, 0x4e, 0x8d, 0xef, 0xc6, 0x82, 0x4c, 0x62, 0x06, + 0x32, 0x94, 0x22, 0x2b, 0xe1, 0xe7, 0xf6, 0x5c, 0x6e, 0xe5, 0x94, 0x26, 0xf3, 0xad, 0x32, 0x49, 0xa8, 0x0f, 0x6d, + 0x1a, 0x42, 0x4a, 0x7f, 0xb6, 0x74, 0x3b, 0xfd, 0x5b, 0x92, 0xff, 0x7d, 0x90, 0x86, 0x8e, 0xf4, 0x28, 0x68, 0xd6, + 0xb6, 0x52, 0xda, 0x27, 0x76, 0xc9, 0x0b, 0xc4, 0x58, 0xb1, 0x97, 0x22, 0xa6, 0xe4, 0x63, 0x76, 0x4b, 0x3b, 0xe9, + 0x54, 0xad, 0x86, 0x8f, 0x1a, 0x8a, 0x83, 0x80, 0x60, 0x7d, 0x30, 0x55, 0x84, 0x6e, 0x7a, 0xe1, 0x90, 0x5f, 0x8b, + 0xc5, 0xd5, 0x80, 0xaf, 0xa8, 0x29, 0xae, 0xb5, 0x97, 0x04, 0x29, 0x32, 0x7a, 0x6b, 0x55, 0x14, 0x8e, 0xfe, 0xca, + 0x34, 0xea, 0x03, 0x2e, 0x0e, 0xda, 0x45, 0x19, 0x32, 0xc6, 0x92, 0x6a, 0x97, 0x9c, 0xee, 0xdd, 0xbc, 0x9a, 0xea, + 0xe7, 0x20, 0xe5, 0xe9, 0xce, 0x59, 0x18, 0x2e, 0xb3, 0x28, 0x4a, 0x82, 0x2b, 0x82, 0xa5, 0x9d, 0x0e, 0x6f, 0x24, + 0x55, 0x54, 0x17, 0x01, 0xd3, 0x99, 0xee, 0x54, 0x2a, 0x1e, 0xb3, 0xc8, 0x7a, 0x18, 0x82, 0x1a, 0xde, 0x0f, 0x61, + 0x92, 0x54, 0x1f, 0x53, 0x53, 0xb2, 0xf7, 0xe3, 0xc3, 0xb3, 0xa5, 0xe3, 0xbc, 0x1e, 0x00, 0x2a, 0x8a, 0x98, 0x4c, + 0x49, 0xb0, 0x75, 0x50, 0xa8, 0xbf, 0x18, 0x96, 0xe5, 0x02, 0x93, 0xb8, 0x1e, 0xb6, 0xaa, 0x8c, 0x25, 0xd4, 0x20, + 0xbd, 0x68, 0xe0, 0xd7, 0x12, 0x6b, 0xbc, 0x9b, 0xb0, 0x51, 0x23, 0x16, 0x6d, 0x33, 0x01, 0xeb, 0x20, 0xd6, 0x76, + 0x49, 0x88, 0xcf, 0x0e, 0x20, 0x53, 0x11, 0x22, 0x16, 0xc7, 0xec, 0x12, 0xdc, 0xa7, 0x72, 0x50, 0x60, 0x54, 0xe7, + 0x57, 0xd5, 0x53, 0x72, 0xeb, 0x53, 0x0e, 0xfa, 0x9b, 0x96, 0xc2, 0xe8, 0x56, 0x52, 0xe4, 0x49, 0x7d, 0x5d, 0x14, + 0xf5, 0xe9, 0x18, 0x9b, 0x85, 0xa5, 0x36, 0x17, 0xc3, 0x41, 0xa7, 0xb4, 0xe5, 0x8c, 0xb0, 0x08, 0x34, 0xaa, 0x8d, + 0x80, 0x2d, 0x17, 0xbc, 0xa4, 0x1c, 0x6b, 0x0a, 0x3b, 0x6d, 0x65, 0x4a, 0x99, 0xe1, 0x8a, 0x34, 0x36, 0x2e, 0x69, + 0x67, 0x92, 0x9f, 0x1b, 0x40, 0x4f, 0x86, 0xd9, 0xa9, 0x7c, 0x7a, 0x5b, 0x33, 0x49, 0x84, 0x8b, 0x33, 0xa4, 0xbb, + 0xdc, 0x9e, 0xb2, 0x93, 0x36, 0x02, 0x80, 0x3a, 0x77, 0x48, 0x1a, 0x53, 0xe8, 0x62, 0xbc, 0xaf, 0x88, 0xa8, 0x40, + 0xac, 0x2f, 0xd7, 0xf0, 0x1f, 0x3f, 0x4b, 0xae, 0x9e, 0x65, 0x62, 0x92, 0x37, 0xca, 0xb6, 0x51, 0xe4, 0xbd, 0xac, + 0x80, 0x7c, 0x0f, 0xc3, 0xaa, 0x31, 0x63, 0xce, 0xd0, 0xa2, 0x64, 0xbf, 0xba, 0xa7, 0x46, 0x33, 0xc8, 0x93, 0x7a, + 0xa0, 0x79, 0x73, 0xb6, 0x0b, 0x27, 0x49, 0x4b, 0x85, 0x61, 0x57, 0x77, 0xe5, 0x02, 0x66, 0x55, 0x82, 0xb7, 0x23, + 0xf5, 0xba, 0x98, 0x21, 0xbf, 0xbe, 0xca, 0x1d, 0x02, 0x6c, 0x93, 0xd0, 0xd8, 0x9a, 0x72, 0xed, 0xe0, 0x6a, 0x99, + 0x00, 0x3a, 0xfa, 0x61, 0x1c, 0x80, 0x41, 0x89, 0xa6, 0x8a, 0x72, 0x2e, 0x86, 0xfd, 0x2c, 0x4c, 0x54, 0x6e, 0x72, + 0xcd, 0x75, 0x4b, 0xa9, 0xa6, 0x57, 0xc0, 0x2b, 0x41, 0xae, 0x2c, 0xcd, 0x3c, 0x91, 0xc6, 0x23, 0x8c, 0x5d, 0x15, + 0xfc, 0x47, 0x02, 0xe3, 0xda, 0x12, 0xe4, 0xf6, 0x5c, 0x9c, 0x5b, 0xe7, 0x19, 0x96, 0x34, 0x6a, 0x40, 0x4a, 0x69, + 0x35, 0x67, 0x34, 0xff, 0x49, 0xf1, 0xb5, 0xfa, 0xe8, 0xd6, 0x00, 0xce, 0x9d, 0xc8, 0x52, 0xbb, 0x58, 0xad, 0x15, + 0xd7, 0x47, 0xfb, 0x84, 0xad, 0xe2, 0x30, 0x51, 0x7a, 0x13, 0xc8, 0xd6, 0x72, 0x92, 0x82, 0x64, 0x8b, 0x81, 0x9d, + 0x60, 0x84, 0x33, 0x54, 0x56, 0xbd, 0x88, 0x8e, 0x9f, 0x7d, 0x80, 0x41, 0xc4, 0x7e, 0xe9, 0xb3, 0xee, 0xc2, 0xd5, + 0x6e, 0xb3, 0x5c, 0xac, 0x62, 0xfd, 0x8b, 0x9c, 0x74, 0x52, 0x0d, 0x5a, 0x13, 0x1e, 0xf7, 0xac, 0xde, 0x7e, 0x13, + 0x66, 0x3d, 0xae, 0x27, 0xb0, 0x89, 0x57, 0x41, 0xb7, 0x50, 0xcc, 0x53, 0x8e, 0x38, 0xf8, 0x4f, 0x41, 0x29, 0x98, + 0xe0, 0xf6, 0x4d, 0x39, 0xcc, 0xf9, 0xb7, 0x0e, 0x92, 0x6c, 0x2d, 0x97, 0x1a, 0xa3, 0x64, 0x00, 0x97, 0xd9, 0x18, + 0x7f, 0x55, 0x33, 0x58, 0xe8, 0xb6, 0x7b, 0x9a, 0xa5, 0xa9, 0x8a, 0x8a, 0xbd, 0xaa, 0x34, 0x6d, 0xbe, 0xb3, 0xa9, + 0x47, 0xa2, 0x15, 0xdc, 0x94, 0x98, 0xd1, 0x21, 0x77, 0xc2, 0x5f, 0x7d, 0xe3, 0x39, 0x4c, 0x12, 0x06, 0xa0, 0x8d, + 0xc0, 0x1f, 0x17, 0x92, 0x60, 0x49, 0x7e, 0x92, 0xb4, 0x74, 0x07, 0xa9, 0x7f, 0x14, 0xf5, 0x17, 0x9c, 0x21, 0x97, + 0x77, 0x59, 0x0c, 0x86, 0x24, 0x6e, 0x24, 0xff, 0x1b, 0x2b, 0x85, 0x86, 0x12, 0x40, 0xd4, 0x3e, 0x3b, 0x22, 0x30, + 0xa9, 0xd8, 0xfb, 0x9f, 0x2b, 0x17, 0x79, 0x83, 0xd9, 0xbf, 0x8d, 0x51, 0x55, 0xa2, 0x72, 0x6f, 0xcf, 0x9d, 0x03, + 0x8d, 0xb1, 0x04, 0xba, 0x2e, 0x8f, 0x6b, 0x31, 0xb7, 0x10, 0xd6, 0xaa, 0x39, 0x36, 0x8f, 0x73, 0xc3, 0xa2, 0xc6, + 0x7e, 0x9a, 0xf5, 0x68, 0x0c, 0xc0, 0xd0, 0x2c, 0x00, 0xf8, 0xcc, 0x4e, 0x4a, 0xed, 0xd0, 0x71, 0x3e, 0xab, 0x6e, + 0x18, 0xea, 0xc3, 0x0c, 0x92, 0xc4, 0x35, 0x15, 0x41, 0x6a, 0xef, 0xdf, 0xd1, 0xa8, 0xf1, 0x40, 0xff, 0xe4, 0x28, + 0x3d, 0xc0, 0xdd, 0x53, 0x82, 0x43, 0x3a, 0x5e, 0xaf, 0x9e, 0xb9, 0x99, 0xca, 0x25, 0x40, 0x58, 0xef, 0x0f, 0x95, + 0x9c, 0xd2, 0xac, 0xa6, 0x23, 0x70, 0x16, 0xbc, 0x80, 0x54, 0x09, 0x89, 0xb4, 0xa8, 0xb4, 0x56, 0xe0, 0x40, 0x87, + 0xe2, 0x85, 0x48, 0x26, 0xc2, 0x98, 0x05, 0x2c, 0x94, 0xe2, 0xcf, 0xf8, 0x70, 0x79, 0xbd, 0x49, 0x9c, 0x57, 0x48, + 0x95, 0x4a, 0x74, 0xed, 0x58, 0x91, 0xe6, 0x0e, 0x6a, 0xa1, 0x2b, 0x66, 0x11, 0x56, 0x4c, 0xc2, 0x1a, 0xcf, 0x8f, + 0x09, 0xbc, 0xb3, 0xd9, 0x7f, 0x85, 0x81, 0x98, 0xde, 0x52, 0x67, 0xdd, 0x22, 0x42, 0xb3, 0xc6, 0x2b, 0x53, 0x0a, + 0xba, 0x1c, 0xd8, 0x87, 0x41, 0x79, 0x09, 0x58, 0x28, 0x34, 0x3a, 0x26, 0xf9, 0xe4, 0x8d, 0xed, 0x18, 0xb9, 0x06, + 0x78, 0xbb, 0xf8, 0x7c, 0x9c, 0x0b, 0x5a, 0xe1, 0x8a, 0xf1, 0x2c, 0x99, 0xf6, 0xab, 0xb0, 0x3f, 0x99, 0xaf, 0x52, + 0x99, 0xb2, 0x4d, 0x14, 0x77, 0xe8, 0x43, 0x49, 0x8c, 0xa4, 0x53, 0x39, 0x97, 0x1f, 0xb9, 0xd8, 0xcb, 0x57, 0xf0, + 0xe3, 0x91, 0xfc, 0x4a, 0x24, 0x07, 0xac, 0x1f, 0xca, 0xf2, 0x8d, 0xae, 0x79, 0xc6, 0x66, 0x6d, 0x73, 0x7b, 0xeb, + 0x24, 0xc3, 0x66, 0x8b, 0x1f, 0x54, 0x91, 0xbf, 0x13, 0x63, 0xe9, 0xc3, 0x65, 0x33, 0xe4, 0xbb, 0x84, 0x69, 0x70, + 0x41, 0x41, 0x70, 0x1d, 0x60, 0x21, 0x42, 0xfa, 0x20, 0xb9, 0x1a, 0x98, 0x4e, 0x0c, 0x64, 0x14, 0xeb, 0x09, 0xd2, + 0x9b, 0xed, 0xeb, 0x3e, 0x4f, 0x48, 0x90, 0x42, 0xa9, 0x37, 0x92, 0x8a, 0xa2, 0x66, 0x89, 0x8b, 0x58, 0xcd, 0x10, + 0x46, 0x9c, 0x9d, 0x96, 0x3a, 0x7d, 0x3d, 0x11, 0xce, 0x1c, 0x66, 0xf6, 0x94, 0x16, 0xaf, 0x5c, 0x09, 0x60, 0xa3, + 0xbf, 0x73, 0x68, 0xdd, 0xb4, 0xc3, 0x51, 0x52, 0xce, 0x25, 0x2b, 0xcb, 0xac, 0x15, 0x9f, 0x30, 0xa2, 0xa2, 0x77, + 0x1b, 0x93, 0x13, 0x60, 0xa2, 0x2c, 0x93, 0xd1, 0x8a, 0x8c, 0xa9, 0xb0, 0xa0, 0x77, 0x22, 0x6e, 0x5f, 0x4a, 0xcb, + 0xbe, 0xa8, 0x8f, 0x74, 0xae, 0xfa, 0xfd, 0xe1, 0x05, 0x45, 0x65, 0xb8, 0x73, 0x1a, 0x9b, 0x38, 0x4b, 0x03, 0x62, + 0xbe, 0x45, 0xf8, 0x32, 0xd4, 0x1a, 0x1b, 0xb0, 0x6e, 0xe4, 0x02, 0x32, 0x51, 0x63, 0xad, 0x49, 0x1f, 0x02, 0xd9, + 0x2a, 0x5f, 0x28, 0x9a, 0xe0, 0xa2, 0xd0, 0xe3, 0xd0, 0xc3, 0x89, 0x04, 0x0c, 0x9b, 0xc3, 0xf6, 0x57, 0x53, 0x6a, + 0xcd, 0x3a, 0xa2, 0x62, 0xee, 0x8d, 0x79, 0x75, 0xed, 0x30, 0x24, 0x42, 0x3f, 0x7d, 0x4e, 0x25, 0x6b, 0x3b, 0x85, + 0x3e, 0x48, 0x3c, 0x90, 0x7c, 0x06, 0x3e, 0x4a, 0x9e, 0xb2, 0x0d, 0x2b, 0x0f, 0xef, 0xa2, 0x3e, 0x5b, 0x05, 0x86, + 0x39, 0x57, 0xe5, 0x99, 0x52, 0x30, 0x39, 0x6b, 0x52, 0x1f, 0x73, 0x2a, 0x95, 0x2f, 0x37, 0x3e, 0x67, 0xc2, 0xbe, + 0xe8, 0x8c, 0xd0, 0xe9, 0xf9, 0x2b, 0x49, 0x0a, 0x3c, 0x1a, 0xf7, 0xe1, 0x00, 0x00, 0x8e, 0x95, 0x84, 0xd7, 0x0c, + 0x58, 0x04, 0xdd, 0xc8, 0xc1, 0x26, 0x16, 0x0c, 0x19, 0xbe, 0x12, 0x02, 0x3f, 0x5b, 0x12, 0xaf, 0xa1, 0xa5, 0x7b, + 0x9f, 0x0d, 0xc1, 0xa4, 0x90, 0x80, 0x9e, 0xa4, 0xba, 0x28, 0xd9, 0xd6, 0xcf, 0x93, 0xa7, 0x36, 0xaf, 0xaa, 0x5c, + 0xc2, 0x93, 0xf8, 0x5c, 0x50, 0x3f, 0x0d, 0x98, 0x45, 0xf5, 0x65, 0x80, 0x35, 0xe4, 0x56, 0x31, 0xa6, 0x72, 0x7c, + 0x8f, 0x10, 0xb2, 0x87, 0x66, 0x2c, 0xb4, 0xe2, 0x98, 0x01, 0xd0, 0x3e, 0xf2, 0x27, 0x88, 0xa4, 0x5b, 0x10, 0x98, + 0x6c, 0x06, 0x44, 0xd1, 0xa5, 0x9e, 0x8f, 0x00, 0x8c, 0x5b, 0x75, 0xec, 0x60, 0x4c, 0x8a, 0xa2, 0x1e, 0x52, 0x74, + 0xa4, 0x9a, 0x85, 0x61, 0xd5, 0x6f, 0x09, 0x26, 0xed, 0xd7, 0xfa, 0x2a, 0x6c, 0x87, 0x87, 0xa3, 0x2e, 0x6a, 0x7b, + 0x8d, 0xd3, 0x90, 0xd2, 0xf3, 0x6b, 0x36, 0x1d, 0x84, 0xba, 0x04, 0xd5, 0x58, 0x70, 0xe7, 0x14, 0x10, 0x29, 0xd6, + 0xb1, 0xac, 0x59, 0xcd, 0xb2, 0x95, 0x87, 0xff, 0xd8, 0xac, 0xa3, 0x6d, 0x46, 0xb8, 0x1a, 0x54, 0xd6, 0x03, 0xb4, + 0x4a, 0x9d, 0x8b, 0x85, 0x7f, 0x56, 0x43, 0xf8, 0xb8, 0x8a, 0x56, 0xbb, 0x88, 0xcc, 0xea, 0xec, 0xb2, 0x06, 0x41, + 0x72, 0x1e, 0x1c, 0x44, 0xd6, 0xd0, 0x72, 0x1b, 0x26, 0x60, 0x3e, 0x4a, 0x74, 0x06, 0x18, 0xdd, 0x6b, 0x84, 0x10, + 0xed, 0xc2, 0x44, 0x55, 0x20, 0x35, 0x30, 0xd8, 0x14, 0xfc, 0x61, 0x8c, 0xff, 0x28, 0x05, 0x28, 0x00, 0x71, 0x18, + 0xd9, 0x52, 0x5c, 0x17, 0x53, 0x4e, 0xfc, 0xa2, 0xcf, 0xb8, 0x2e, 0xda, 0x56, 0x7a, 0xec, 0x0f, 0x20, 0x25, 0xb7, + 0x48, 0x23, 0xe9, 0x04, 0x98, 0x99, 0x67, 0x05, 0x8d, 0x13, 0xca, 0x9f, 0x3e, 0xdb, 0x86, 0x4b, 0x86, 0x03, 0x55, + 0x3a, 0x6c, 0x82, 0x13, 0x03, 0x02, 0x14, 0x17, 0x8f, 0x36, 0x69, 0xe4, 0xf0, 0xa4, 0xf8, 0x92, 0x18, 0x0a, 0xe2, + 0x0d, 0x1d, 0x40, 0x67, 0x24, 0x31, 0x34, 0x9c, 0x43, 0x9b, 0x29, 0x9c, 0x6f, 0x99, 0x63, 0x40, 0x82, 0xea, 0x50, + 0xa1, 0x4b, 0x17, 0xed, 0xfb, 0x50, 0xdd, 0xd7, 0x87, 0xc4, 0xe9, 0xf9, 0xe5, 0x98, 0x6d, 0xed, 0x51, 0x8b, 0x91, + 0x69, 0x65, 0x10, 0xfb, 0x26, 0x59, 0xe4, 0xc5, 0x7c, 0x18, 0xe2, 0x69, 0x0b, 0x61, 0xb4, 0x81, 0xcc, 0x15, 0x25, + 0xd9, 0x46, 0xc4, 0x88, 0x19, 0xfd, 0xef, 0xb4, 0x67, 0x0c, 0xa9, 0xc4, 0xe3, 0x1c, 0x8f, 0x0e, 0xe0, 0x0b, 0x46, + 0x7f, 0x79, 0xb4, 0x23, 0x5b, 0xd8, 0xfc, 0x8e, 0xa0, 0xda, 0x05, 0xdd, 0x3e, 0x0a, 0xf2, 0x3c, 0xd6, 0xc9, 0x89, + 0x78, 0xc0, 0x28, 0xe5, 0x12, 0x57, 0xdf, 0xda, 0xaa, 0x85, 0xca, 0xc6, 0x34, 0xa7, 0x13, 0xbe, 0x2f, 0x2d, 0x1f, + 0x43, 0x98, 0x79, 0x60, 0xb5, 0xb7, 0x05, 0x6b, 0x42, 0x6f, 0xab, 0x9b, 0xf6, 0xa1, 0xd7, 0x1a, 0xc6, 0xad, 0x5c, + 0x4f, 0x38, 0xb7, 0x1e, 0x44, 0x41, 0xcf, 0xe1, 0x99, 0xae, 0xe7, 0x9d, 0x3d, 0xea, 0x9f, 0x95, 0x6b, 0xa1, 0x41, + 0xff, 0x60, 0x8c, 0xab, 0xae, 0x7e, 0xb5, 0x22, 0x4c, 0x38, 0x4b, 0xbc, 0xd9, 0x08, 0xbf, 0xe6, 0x28, 0x54, 0x12, + 0x87, 0x4f, 0x77, 0x13, 0xde, 0xd1, 0x8d, 0xe0, 0x0d, 0x23, 0xe2, 0x7d, 0xb9, 0x13, 0xa3, 0x23, 0xb7, 0xcb, 0x91, + 0xd4, 0xee, 0x57, 0x6f, 0x6a, 0xfa, 0x55, 0xd7, 0x94, 0xd5, 0x9f, 0xee, 0x9d, 0xbc, 0x49, 0x3c, 0x38, 0x3a, 0x45, + 0xe3, 0x0b, 0x46, 0x47, 0x37, 0x7f, 0xe9, 0x82, 0xfb, 0xfd, 0xca, 0xef, 0xa3, 0x10, 0xf7, 0xf1, 0x73, 0x99, 0x34, + 0x77, 0x7e, 0xc3, 0xc5, 0x7f, 0x2f, 0xe8, 0x6b, 0x8e, 0x18, 0xdb, 0x1d, 0xe1, 0x79, 0xe1, 0x76, 0xdf, 0xdb, 0x40, + 0xb3, 0x1d, 0xba, 0x68, 0xec, 0x61, 0x0a, 0xc3, 0x74, 0xb1, 0x86, 0x8e, 0xf2, 0x2d, 0x39, 0xdd, 0x5d, 0x3e, 0xf6, + 0xca, 0x9e, 0x7a, 0x99, 0x80, 0x8a, 0xda, 0x25, 0x9a, 0xdd, 0xf8, 0x6b, 0xd0, 0xa9, 0xdb, 0xcc, 0x36, 0xed, 0x2a, + 0xbf, 0xfd, 0x99, 0x0d, 0xad, 0x5b, 0xae, 0xfd, 0xef, 0xc1, 0x4d, 0xf9, 0xd8, 0xb6, 0xca, 0x17, 0x6a, 0xcf, 0xcd, + 0x4f, 0x69, 0x12, 0x21, 0xfa, 0x9b, 0xc9, 0xf2, 0x5f, 0x76, 0xf9, 0xfe, 0x5d, 0xfc, 0xd5, 0x34, 0x83, 0xf2, 0xfd, + 0x6a, 0x39, 0x59, 0x5a, 0x5b, 0x7c, 0xea, 0xda, 0xee, 0xd3, 0x17, 0x1f, 0x31, 0xad, 0x36, 0xac, 0x1c, 0xdb, 0x42, + 0x2c, 0xb2, 0x46, 0x0d, 0x4f, 0x59, 0xd7, 0x5e, 0x06, 0xd0, 0x36, 0x70, 0x8b, 0x79, 0xe4, 0x86, 0xcf, 0x35, 0x4f, + 0x36, 0x7b, 0x37, 0xdb, 0xbf, 0x9d, 0x2c, 0x72, 0x7b, 0xb5, 0x64, 0xdd, 0x96, 0x74, 0x17, 0x7f, 0xf2, 0x81, 0xc9, + 0x75, 0x35, 0xb8, 0xb1, 0x8f, 0x06, 0x96, 0x49, 0xea, 0xcf, 0xe1, 0x86, 0xe6, 0x9d, 0xfc, 0x77, 0x86, 0x56, 0x7f, + 0xc2, 0x66, 0xa6, 0x79, 0xc4, 0x2a, 0x77, 0x9b, 0x99, 0x31, 0x71, 0x6c, 0x9f, 0x4c, 0x36, 0xbc, 0x89, 0x1b, 0xc3, + 0xc6, 0x6a, 0xea, 0xff, 0x5f, 0xa0, 0x39, 0xc7, 0xa0, 0x9f, 0xb0, 0x88, 0xfb, 0x00, 0x76, 0xd0, 0x07, 0x92, 0x37, + 0xb2, 0xcd, 0x49, 0xc5, 0xb9, 0x98, 0xe7, 0x5b, 0x77, 0xca, 0x2c, 0x8a, 0x0c, 0x72, 0xa7, 0x6b, 0xfe, 0x8f, 0xea, + 0x57, 0x4b, 0x2f, 0xcb, 0x23, 0x09, 0xfe, 0xd9, 0xee, 0x32, 0xe5, 0x1f, 0xab, 0xed, 0x7e, 0x0e, 0xa9, 0x2b, 0xc4, + 0x60, 0xc6, 0x14, 0x58, 0x90, 0x68, 0x28, 0x33, 0xbb, 0x71, 0xf5, 0x7c, 0x62, 0x94, 0x19, 0x38, 0x84, 0xee, 0xaf, + 0xa3, 0x4b, 0x8f, 0xc1, 0xb6, 0x8f, 0x35, 0xf6, 0xb0, 0x0b, 0x13, 0xd8, 0x97, 0xc7, 0xd7, 0xd1, 0x2d, 0xdc, 0xb3, + 0xb8, 0xfb, 0x9c, 0x45, 0x40, 0x2d, 0x98, 0xd9, 0x89, 0xa4, 0x38, 0x69, 0x20, 0xeb, 0x07, 0x73, 0xc3, 0x6f, 0xef, + 0xda, 0xe5, 0x40, 0x4c, 0x91, 0xb9, 0xb4, 0xda, 0xa2, 0xff, 0x6a, 0x81, 0x1c, 0x77, 0x09, 0xcf, 0x0d, 0x98, 0x90, + 0xd2, 0x2f, 0x93, 0x21, 0x7c, 0xc2, 0x0e, 0xe4, 0x11, 0x23, 0x80, 0xd0, 0x06, 0xfe, 0x6a, 0x4f, 0x3d, 0x76, 0xc0, + 0xe6, 0xbe, 0x0a, 0x3a, 0xfe, 0x01, 0x44, 0x82, 0x68, 0xf4, 0x17, 0xa2, 0x97, 0xca, 0xda, 0x77, 0x85, 0xe6, 0xf1, + 0xd7, 0x66, 0x51, 0x65, 0x4a, 0xe3, 0x3d, 0xac, 0xb5, 0xf0, 0xed, 0x0e, 0x47, 0x3c, 0x68, 0xe1, 0x4a, 0x7f, 0x4d, + 0x55, 0x1e, 0x3a, 0xf1, 0xa8, 0x79, 0xcc, 0xaa, 0xfd, 0x22, 0x55, 0x1b, 0x91, 0x63, 0x56, 0x3a, 0x7a, 0xb5, 0xf2, + 0x02, 0xcb, 0xdf, 0xeb, 0x89, 0xdb, 0x3b, 0x19, 0x86, 0x10, 0xec, 0x18, 0x7d, 0xbe, 0x27, 0xd6, 0x1c, 0x2b, 0x18, + 0xfe, 0xe8, 0x1c, 0x18, 0x8c, 0xa7, 0xe5, 0x9e, 0x8e, 0xf4, 0x46, 0x59, 0xdf, 0x3d, 0x0f, 0xb2, 0x76, 0x51, 0xf2, + 0x5a, 0x0c, 0xd9, 0x5a, 0x37, 0x10, 0x82, 0x54, 0xa3, 0xca, 0x65, 0x2a, 0xf7, 0xdd, 0x67, 0xaa, 0xef, 0x52, 0x46, + 0xde, 0x0f, 0x93, 0xa6, 0xf7, 0x04, 0x75, 0xd3, 0x64, 0x56, 0xbe, 0x8e, 0x04, 0xf2, 0x6b, 0x19, 0xdf, 0x42, 0xce, + 0x0b, 0xf3, 0x36, 0x8d, 0xb7, 0x20, 0x41, 0xa6, 0xa2, 0xc8, 0x6a, 0x50, 0xed, 0x12, 0x80, 0x46, 0xf7, 0x4c, 0xfe, + 0x65, 0x16, 0x55, 0x41, 0x10, 0x15, 0xf5, 0x4f, 0x3f, 0xeb, 0x04, 0x87, 0xaf, 0x3f, 0x33, 0x4d, 0xa6, 0xea, 0x81, + 0x16, 0x35, 0x33, 0x0a, 0xba, 0x3c, 0xaa, 0x4c, 0x97, 0x20, 0x10, 0x8d, 0xa2, 0x33, 0x67, 0xdf, 0xd2, 0xb6, 0xbb, + 0x21, 0xa9, 0xd2, 0xe5, 0xc4, 0x01, 0xd8, 0x60, 0xed, 0x8d, 0xf7, 0xfd, 0xeb, 0xa6, 0x89, 0xab, 0x46, 0xdd, 0xe4, + 0x73, 0x55, 0xb3, 0x6e, 0x2d, 0x86, 0xbe, 0xb5, 0x37, 0xc9, 0x78, 0x45, 0x57, 0x27, 0x9d, 0x08, 0xec, 0x7b, 0x5e, + 0x87, 0xba, 0x6a, 0x4e, 0x86, 0xab, 0x9e, 0x08, 0xae, 0x9d, 0xd9, 0x6d, 0x6e, 0xb2, 0xa8, 0xac, 0x50, 0x30, 0x9e, + 0x4b, 0xa9, 0xcf, 0x88, 0xdc, 0xaf, 0x68, 0x72, 0xe7, 0xb2, 0xba, 0xe6, 0xbc, 0x80, 0x08, 0xe6, 0xe5, 0x08, 0x58, + 0x0a, 0x3e, 0x90, 0x53, 0x61, 0x99, 0xf9, 0x38, 0xcd, 0xdf, 0x6e, 0xba, 0xc8, 0x05, 0x12, 0x87, 0x5f, 0x0b, 0x2a, + 0x59, 0xfb, 0x76, 0x5a, 0xec, 0x30, 0x89, 0xab, 0x05, 0x4b, 0x6a, 0xff, 0xde, 0x3e, 0x03, 0x2a, 0xb7, 0xb9, 0xa7, + 0xf9, 0xcf, 0x45, 0x65, 0x4b, 0xa0, 0xad, 0x9a, 0xf6, 0x63, 0xd2, 0x7e, 0x7c, 0x80, 0x09, 0x69, 0x66, 0x27, 0x64, + 0x64, 0x2f, 0x69, 0x28, 0x35, 0x8c, 0x6c, 0xf2, 0xf7, 0x32, 0x07, 0xe2, 0x65, 0x93, 0x01, 0x08, 0xeb, 0x51, 0x40, + 0xeb, 0xb1, 0xc3, 0xf7, 0xd9, 0x72, 0x82, 0x72, 0xa2, 0x94, 0xd6, 0x0f, 0x8c, 0x95, 0xf9, 0xab, 0xf1, 0x51, 0xc5, + 0xba, 0xe5, 0xa9, 0x83, 0x3a, 0xf3, 0x3c, 0x7f, 0x3a, 0x0e, 0x11, 0x55, 0xbe, 0xa5, 0xa2, 0x80, 0xe3, 0xab, 0xb3, + 0x08, 0xf6, 0x42, 0x14, 0x61, 0x76, 0xbe, 0xba, 0x8a, 0x5a, 0x9c, 0xfb, 0xd8, 0x9d, 0x7b, 0xd3, 0x37, 0x82, 0xcb, + 0x9d, 0x8f, 0xec, 0x19, 0x8c, 0x22, 0xb7, 0x53, 0xac, 0x42, 0xc0, 0x91, 0xc1, 0x79, 0x7c, 0x3d, 0xde, 0x08, 0xf5, + 0xf7, 0x3a, 0x66, 0xc6, 0x59, 0x30, 0xa4, 0xe3, 0xa3, 0x67, 0x84, 0x0d, 0x7d, 0x48, 0xc5, 0x20, 0xfd, 0x30, 0xcc, + 0xfb, 0xd4, 0x9b, 0xc7, 0x51, 0xa8, 0x68, 0x3a, 0x2e, 0x4a, 0xc0, 0xcb, 0x12, 0x5a, 0x5b, 0x24, 0xdb, 0xee, 0x1d, + 0xcc, 0x74, 0xd9, 0x73, 0xb1, 0x15, 0x3a, 0x44, 0x47, 0xbc, 0xa2, 0x6e, 0xd3, 0x54, 0xa6, 0xf0, 0x2c, 0xb6, 0x82, + 0x5c, 0xe6, 0xbc, 0xb3, 0x49, 0xe0, 0xcf, 0xa7, 0xae, 0x21, 0x8f, 0x57, 0xb0, 0xca, 0xf6, 0x01, 0x58, 0x6b, 0xf8, + 0x6e, 0xfa, 0x40, 0xd4, 0x86, 0x51, 0xa6, 0x4e, 0x57, 0x2a, 0x90, 0xfd, 0xc2, 0x56, 0x8c, 0xbd, 0xac, 0x88, 0xf1, + 0xfa, 0x4d, 0x0c, 0x4c, 0xa6, 0x05, 0xbf, 0x27, 0x70, 0xcb, 0xf3, 0x17, 0x04, 0xd6, 0xc2, 0x73, 0x6a, 0x7c, 0x5b, + 0xcc, 0xf1, 0x9e, 0x91, 0xc2, 0xe9, 0xeb, 0x11, 0xa9, 0xbd, 0xa7, 0x78, 0x6a, 0xc2, 0xbd, 0x77, 0xea, 0xdd, 0x7e, + 0xf8, 0xd3, 0x10, 0x34, 0xfd, 0x11, 0x63, 0x62, 0xd9, 0xa2, 0x7d, 0xdd, 0xe7, 0x77, 0x1b, 0x9a, 0xf3, 0x9f, 0x8a, + 0x54, 0x84, 0x44, 0xa1, 0x24, 0xc6, 0x2a, 0x99, 0x2e, 0x1b, 0x54, 0x49, 0xc0, 0xa2, 0x42, 0x8b, 0x05, 0x0c, 0x4c, + 0x94, 0x55, 0xb0, 0x22, 0x55, 0x3d, 0x7b, 0xbd, 0xad, 0x96, 0x1f, 0xcd, 0x17, 0x47, 0xc8, 0x5c, 0x84, 0x6a, 0x83, + 0x7f, 0x84, 0x27, 0x1d, 0x39, 0xba, 0x58, 0x75, 0x80, 0xbc, 0xd4, 0xe2, 0xdc, 0x72, 0xb6, 0x28, 0xa2, 0x4a, 0x87, + 0xce, 0xbd, 0x9b, 0xde, 0x18, 0x7b, 0x39, 0x8a, 0x9f, 0xd5, 0xcc, 0xc6, 0x8b, 0x93, 0x60, 0xce, 0x7d, 0x81, 0x80, + 0xc7, 0x3b, 0x46, 0x6b, 0x83, 0xb3, 0xaa, 0xe1, 0x09, 0xea, 0xe0, 0xfe, 0x67, 0x6f, 0x13, 0xc9, 0x3e, 0x6b, 0xa0, + 0xe2, 0xc6, 0x8e, 0x5e, 0x57, 0xfb, 0x44, 0x4e, 0xa8, 0x15, 0xf2, 0x39, 0xea, 0x9b, 0xf0, 0xd9, 0xbf, 0x3a, 0xd8, + 0x47, 0xd5, 0xba, 0x3d, 0xe6, 0x71, 0x1c, 0xce, 0x66, 0x3e, 0x6b, 0x6e, 0xaa, 0xf6, 0x7e, 0xa5, 0x87, 0xd2, 0x8a, + 0x86, 0x1e, 0x2c, 0xf3, 0x0e, 0x7b, 0x4f, 0x41, 0x90, 0xc3, 0x2a, 0x38, 0xdc, 0x9f, 0xc5, 0x68, 0x0b, 0x2b, 0xa3, + 0xae, 0xcb, 0xda, 0x01, 0xca, 0x66, 0x3a, 0xce, 0xd4, 0x95, 0x44, 0x26, 0xc3, 0xb4, 0x57, 0xef, 0xe2, 0x43, 0xfe, + 0xb8, 0x7d, 0x57, 0xd1, 0x52, 0x1a, 0x5e, 0xee, 0x8f, 0x44, 0x17, 0x02, 0x13, 0x46, 0x74, 0xf9, 0x7e, 0x2b, 0xd5, + 0x5e, 0x8f, 0x94, 0x71, 0xa5, 0x38, 0x9c, 0x0b, 0x03, 0xb4, 0x5e, 0xd3, 0xe8, 0xe2, 0x9f, 0x2c, 0x0c, 0x4b, 0x04, + 0xd1, 0xe2, 0x92, 0x6f, 0x4b, 0x09, 0xef, 0x5e, 0x32, 0x64, 0x57, 0x6c, 0xf0, 0x09, 0x80, 0x0a, 0xf4, 0xce, 0x01, + 0xce, 0xe2, 0x78, 0x01, 0xda, 0x12, 0xd2, 0x60, 0x5e, 0xc9, 0x96, 0x86, 0xa9, 0xab, 0x67, 0x09, 0x50, 0x88, 0x50, + 0xab, 0xdb, 0x58, 0x5b, 0xe3, 0x2c, 0x53, 0x33, 0x80, 0x7c, 0x12, 0xeb, 0x0d, 0xd4, 0x2a, 0xf0, 0xfe, 0xe7, 0x2f, + 0x1f, 0x33, 0x5c, 0x2a, 0x7d, 0x69, 0x1b, 0xa8, 0x84, 0xa8, 0x6c, 0x42, 0x12, 0xe7, 0xb7, 0x10, 0xa7, 0xa3, 0xc1, + 0x5a, 0xaf, 0xf6, 0x6a, 0x91, 0x93, 0xb6, 0x9b, 0x44, 0xf9, 0x4a, 0x51, 0x0e, 0x2c, 0xe0, 0xeb, 0x43, 0x2f, 0xb2, + 0xc2, 0xb6, 0xbe, 0x6f, 0x92, 0x03, 0xbe, 0x8c, 0x0f, 0xd9, 0xc8, 0xd1, 0x45, 0xa9, 0x81, 0x00, 0x5f, 0x91, 0x1c, + 0x19, 0x94, 0xdb, 0xb8, 0xc8, 0xa0, 0x1c, 0x7c, 0x29, 0xee, 0x23, 0x6d, 0x49, 0xa9, 0x03, 0xae, 0x87, 0x29, 0x04, + 0xe8, 0x25, 0x94, 0x49, 0xac, 0x10, 0xe4, 0x91, 0x0c, 0xbe, 0xcd, 0x5c, 0x86, 0xee, 0xd0, 0xbc, 0x0e, 0x13, 0xa9, + 0x3d, 0x89, 0xe8, 0x25, 0xa9, 0x0b, 0xa3, 0x18, 0x46, 0xca, 0x67, 0x39, 0x99, 0x8e, 0x71, 0x2e, 0x11, 0x35, 0x5d, + 0x60, 0x87, 0xf3, 0xda, 0x11, 0x10, 0xa9, 0xf2, 0xcd, 0xd7, 0xd5, 0x6d, 0x5d, 0x99, 0x0d, 0xba, 0x56, 0x38, 0x90, + 0xb2, 0x9f, 0x2b, 0xd2, 0x68, 0xd8, 0x5f, 0x20, 0x46, 0x13, 0x8d, 0x7e, 0xc8, 0x5f, 0x39, 0xc5, 0xf4, 0xa7, 0xf1, + 0xc5, 0xcf, 0xab, 0x0f, 0x0e, 0x94, 0xa7, 0x23, 0x06, 0x8d, 0xf8, 0x2e, 0x55, 0xf4, 0xe1, 0xa6, 0x8d, 0x71, 0xd3, + 0x3c, 0xee, 0x59, 0x2c, 0x10, 0xfb, 0x5f, 0x70, 0x76, 0xb9, 0x93, 0xc7, 0x4b, 0x62, 0x1c, 0x18, 0x3a, 0x71, 0x4f, + 0x89, 0x6f, 0x91, 0xc0, 0x9a, 0x3c, 0x84, 0x22, 0x8d, 0x8e, 0xb0, 0x2f, 0xb4, 0x17, 0x33, 0xf8, 0x0e, 0xc2, 0x4d, + 0xcf, 0xf6, 0x05, 0x52, 0x5f, 0xc9, 0xa4, 0xd0, 0x32, 0x84, 0x15, 0x34, 0x63, 0x29, 0x25, 0x15, 0xf4, 0xb4, 0x4b, + 0xf0, 0xde, 0xe1, 0xc8, 0x20, 0x28, 0x4a, 0x30, 0x81, 0x7a, 0x94, 0x99, 0xdb, 0x63, 0x2f, 0x7e, 0xf9, 0xc5, 0x90, + 0x9a, 0x9f, 0xf1, 0x05, 0x11, 0x99, 0xbc, 0x43, 0xd8, 0x63, 0xee, 0x61, 0x49, 0xe0, 0x13, 0xbb, 0x5e, 0xcf, 0x24, + 0xf6, 0x90, 0x4f, 0xf3, 0x62, 0xd6, 0x79, 0x14, 0x36, 0x7f, 0x04, 0xa5, 0x04, 0xbb, 0x9e, 0xaf, 0xd4, 0x20, 0x66, + 0x0c, 0x16, 0xa4, 0xea, 0x6d, 0x62, 0x77, 0x9e, 0xab, 0x5a, 0x8a, 0xd3, 0x7b, 0x13, 0xc3, 0xa3, 0xba, 0x68, 0xfb, + 0xe0, 0xce, 0x12, 0xc8, 0xb2, 0x56, 0x92, 0x31, 0x78, 0x0b, 0xb5, 0x5f, 0x01, 0x3e, 0x0c, 0xba, 0x99, 0x1e, 0x03, + 0x5b, 0xf1, 0x94, 0xf5, 0xfc, 0x10, 0x31, 0x38, 0x6b, 0xac, 0x41, 0xfb, 0xab, 0x2c, 0x34, 0x9e, 0x61, 0xaa, 0x47, + 0x17, 0x00, 0xae, 0x96, 0xf7, 0x5e, 0xfb, 0xb5, 0x90, 0xb6, 0xe2, 0x48, 0x01, 0x6a, 0xa7, 0x06, 0x8c, 0x31, 0x6b, + 0x74, 0xe4, 0x14, 0x52, 0xac, 0xff, 0x26, 0x12, 0x86, 0x24, 0xb6, 0xc2, 0xf0, 0x29, 0x1e, 0x14, 0xc1, 0x25, 0x6f, + 0x25, 0x33, 0xf4, 0x0c, 0x52, 0x2a, 0xeb, 0xfe, 0x8b, 0x9d, 0xaf, 0x1d, 0x26, 0x2c, 0xdd, 0x5c, 0x50, 0x3d, 0x72, + 0xea, 0xc2, 0x79, 0xe3, 0xe5, 0x0b, 0xfc, 0xda, 0x00, 0x25, 0x45, 0xce, 0xd5, 0x64, 0x52, 0xc0, 0x64, 0x7b, 0xf3, + 0x83, 0xd5, 0x47, 0x0f, 0x7b, 0x80, 0x47, 0x3c, 0x05, 0xcd, 0x1d, 0x2b, 0x1f, 0x94, 0xf4, 0xca, 0xd2, 0x4b, 0x54, + 0x75, 0x58, 0x81, 0xc4, 0x92, 0x15, 0xa4, 0x91, 0x63, 0x74, 0x43, 0x1c, 0x4c, 0xc5, 0xb7, 0x23, 0x40, 0x93, 0x73, + 0x88, 0x4d, 0x59, 0x49, 0x62, 0xde, 0x69, 0x27, 0x83, 0xde, 0x4b, 0x14, 0x0c, 0x97, 0x95, 0xa0, 0xd2, 0x7e, 0xaf, + 0x0f, 0x60, 0xcd, 0x11, 0x7c, 0xac, 0xa0, 0xc5, 0xb4, 0xba, 0x1d, 0xbd, 0xdb, 0x9a, 0x79, 0x08, 0x62, 0x91, 0x6c, + 0xb3, 0xb5, 0x9f, 0x16, 0x27, 0x74, 0x98, 0xec, 0x68, 0x86, 0x2e, 0x54, 0x5a, 0x62, 0xc5, 0x5a, 0x41, 0x7a, 0x3f, + 0xda, 0xa4, 0x65, 0x9d, 0x66, 0x08, 0x77, 0xf6, 0xbf, 0x4e, 0x6c, 0xf4, 0x39, 0x19, 0x2c, 0x58, 0x9d, 0xea, 0x4e, + 0x03, 0x05, 0x23, 0x30, 0x52, 0xc3, 0xfd, 0x8f, 0xdc, 0x09, 0x96, 0x53, 0xd9, 0xd2, 0x83, 0x1c, 0x4a, 0xac, 0x18, + 0xab, 0x08, 0xcc, 0xfe, 0xf9, 0xe0, 0x25, 0x31, 0xe4, 0x32, 0x35, 0xdc, 0x41, 0xee, 0xe9, 0x71, 0x95, 0x14, 0x6d, + 0x6b, 0xa4, 0x0e, 0xcc, 0x7d, 0x02, 0xa9, 0x44, 0x19, 0x7a, 0xf2, 0xb9, 0x4a, 0x4c, 0xd1, 0x4f, 0x73, 0x21, 0x49, + 0xcb, 0x33, 0xfe, 0x06, 0x2e, 0x64, 0xad, 0x13, 0x9c, 0x29, 0x23, 0xa5, 0x69, 0x1d, 0xf7, 0x0c, 0x12, 0xc9, 0xa0, + 0x91, 0xe7, 0x3c, 0xed, 0xc2, 0xf2, 0xbd, 0x49, 0xc4, 0x95, 0x1a, 0x22, 0x46, 0x3f, 0x87, 0x07, 0x94, 0xc7, 0x29, + 0xf9, 0xd7, 0x06, 0x7c, 0x3d, 0xe9, 0xc3, 0xbc, 0xd5, 0x9e, 0x1a, 0x9a, 0x23, 0x50, 0x62, 0x11, 0x09, 0xce, 0x6d, + 0xc9, 0x23, 0x5b, 0x65, 0xd1, 0xcc, 0xbb, 0xca, 0x10, 0x1c, 0x5b, 0x30, 0x9a, 0xc9, 0xd9, 0x11, 0x04, 0x1b, 0xb7, + 0x7b, 0xe9, 0x10, 0x4c, 0x3d, 0x2c, 0x56, 0x35, 0x41, 0x9a, 0x48, 0x7f, 0xd6, 0xf7, 0xcf, 0x96, 0x02, 0x69, 0xf8, + 0xa7, 0xc7, 0x88, 0x2d, 0x16, 0xa9, 0x0c, 0x28, 0xd0, 0x10, 0xaa, 0x23, 0x20, 0x0c, 0xc0, 0x58, 0xb3, 0xe6, 0x54, + 0x35, 0xe0, 0x13, 0xdb, 0xe6, 0xc3, 0x61, 0xad, 0x16, 0x5b, 0xee, 0x03, 0xda, 0x1b, 0xb9, 0x6a, 0x63, 0x84, 0xf4, + 0xfc, 0x53, 0x2d, 0xb8, 0x65, 0xfa, 0x26, 0x75, 0x6e, 0xdf, 0x5e, 0x46, 0x12, 0x1a, 0x0e, 0xbd, 0xf0, 0x1e, 0x5b, + 0x35, 0x9f, 0xb2, 0x68, 0x39, 0x3a, 0xd9, 0x2c, 0x6c, 0xb1, 0x4a, 0x33, 0x82, 0x1d, 0x60, 0xd3, 0x59, 0xeb, 0xca, + 0xe7, 0xc3, 0xa0, 0x13, 0xd2, 0x32, 0x91, 0x8d, 0xa8, 0xe0, 0xc3, 0x8c, 0x04, 0xb5, 0x43, 0xb2, 0x77, 0x38, 0x3b, + 0xcf, 0x15, 0x15, 0x5c, 0xe4, 0x5e, 0x89, 0xeb, 0x92, 0xd0, 0x80, 0x54, 0xa4, 0x03, 0xba, 0xcc, 0x95, 0x2d, 0x78, + 0x39, 0x87, 0x95, 0x2b, 0xc9, 0x35, 0x0d, 0x5e, 0x93, 0x47, 0x4d, 0x7e, 0xdf, 0x22, 0x02, 0x03, 0xd7, 0x61, 0xac, + 0x42, 0x54, 0xf3, 0x89, 0x90, 0x13, 0x79, 0x84, 0x89, 0x9c, 0xa6, 0x1b, 0x21, 0x8f, 0xd9, 0xcf, 0x36, 0xbf, 0x8d, + 0x54, 0xce, 0x4d, 0x43, 0x19, 0x40, 0x94, 0x9a, 0x38, 0x00, 0xf1, 0x73, 0xdb, 0x32, 0x34, 0xe1, 0xef, 0x3d, 0x48, + 0x8d, 0xe8, 0x75, 0x76, 0x06, 0x2c, 0xb7, 0xb5, 0x2c, 0x5a, 0xe5, 0x00, 0xe9, 0xfb, 0xcf, 0x02, 0xc8, 0x68, 0x62, + 0x51, 0x44, 0x6c, 0x59, 0xd5, 0x90, 0x93, 0x41, 0x7c, 0xdc, 0x9e, 0x63, 0x8c, 0x7d, 0x38, 0x88, 0xf2, 0xe9, 0xb9, + 0xda, 0x68, 0x5e, 0x06, 0xa8, 0xcd, 0x1a, 0x66, 0xb7, 0xcf, 0x28, 0x83, 0x3e, 0xca, 0x52, 0xde, 0xb7, 0x8a, 0x6e, + 0x5f, 0x52, 0x0e, 0x48, 0x3e, 0x9c, 0xcd, 0x9d, 0x2f, 0x91, 0x7d, 0xd5, 0x53, 0xb7, 0xf0, 0xa8, 0x93, 0x45, 0x87, + 0xcd, 0x7c, 0x80, 0x41, 0x99, 0xe1, 0x7b, 0x20, 0xad, 0x66, 0x93, 0x65, 0x4b, 0xd9, 0x2a, 0x03, 0xcf, 0x5e, 0xc6, + 0x27, 0x10, 0x61, 0x1e, 0x9b, 0xfc, 0x09, 0x3e, 0xd0, 0xd5, 0x83, 0x96, 0xdb, 0xd1, 0xd9, 0x64, 0xa0, 0x49, 0x43, + 0x97, 0xbd, 0xfd, 0x29, 0x5c, 0x0b, 0xe3, 0x29, 0x38, 0x24, 0xd1, 0xfa, 0xaa, 0xf9, 0x48, 0xcb, 0x68, 0x8f, 0xd7, + 0x19, 0x2a, 0x7d, 0xba, 0xa8, 0x4b, 0x78, 0x78, 0x39, 0x52, 0x9a, 0x50, 0xb3, 0xd4, 0x87, 0xa6, 0x33, 0x65, 0xf8, + 0xfa, 0x51, 0xf3, 0x06, 0x31, 0x9f, 0x86, 0x4d, 0xbd, 0xb0, 0xe5, 0x2f, 0x70, 0x02, 0xbf, 0xf8, 0xec, 0xc1, 0x78, + 0xc7, 0xa7, 0xe7, 0x38, 0x89, 0xc2, 0x52, 0x56, 0x95, 0xbd, 0x16, 0x41, 0x45, 0x6e, 0x82, 0xc1, 0x73, 0x8a, 0xd1, + 0xc5, 0xc8, 0x1f, 0xd4, 0x2d, 0xaa, 0x88, 0x29, 0x8f, 0x03, 0x54, 0xf2, 0xf1, 0xfd, 0x5a, 0xbc, 0xd4, 0x40, 0x1b, + 0xd2, 0x59, 0xce, 0xf0, 0x0d, 0xc7, 0x89, 0x94, 0xbe, 0xe4, 0xb2, 0x57, 0x5a, 0xc8, 0x16, 0x59, 0x44, 0x2b, 0x92, + 0x29, 0x50, 0x01, 0xbb, 0xaa, 0xa2, 0x78, 0x70, 0x42, 0x8c, 0x62, 0x76, 0x63, 0x30, 0xba, 0xe7, 0x1e, 0x72, 0xc6, + 0xd4, 0x41, 0x2e, 0x07, 0x11, 0xa3, 0x39, 0xfc, 0x93, 0x1c, 0x65, 0x61, 0x79, 0x19, 0x7d, 0x44, 0x96, 0xe1, 0x44, + 0x1a, 0x33, 0x68, 0xd4, 0x80, 0xb0, 0x79, 0x67, 0xfa, 0x7a, 0xa1, 0x3a, 0xec, 0x31, 0xdc, 0x75, 0x06, 0x84, 0xaf, + 0x9b, 0x9e, 0xb9, 0x8a, 0x60, 0x87, 0x47, 0xc0, 0xe4, 0xcb, 0x0f, 0x50, 0x4d, 0xcf, 0xfa, 0x37, 0xdf, 0x86, 0xfd, + 0x49, 0xf4, 0x36, 0xf9, 0x79, 0x59, 0xc4, 0x25, 0x9a, 0x4d, 0x86, 0xe3, 0x56, 0xa5, 0x2c, 0x49, 0x62, 0xc3, 0xc2, + 0xde, 0xb1, 0xeb, 0x46, 0x12, 0x15, 0x8b, 0xfe, 0x04, 0xc0, 0x73, 0x14, 0x58, 0xef, 0x33, 0x48, 0x8e, 0x64, 0x55, + 0x2d, 0x53, 0xb0, 0x0f, 0xd6, 0x01, 0x40, 0x3c, 0x79, 0xa5, 0x28, 0xf7, 0xec, 0xc4, 0x85, 0x64, 0x1d, 0x34, 0x70, + 0x24, 0x78, 0x8a, 0xa7, 0xd5, 0xf5, 0x38, 0x70, 0x5f, 0x1e, 0x99, 0x9f, 0x60, 0x95, 0xd0, 0x21, 0x50, 0x08, 0x12, + 0x44, 0xec, 0xc7, 0x6c, 0xe6, 0xc5, 0xde, 0xc1, 0x82, 0x4b, 0xdf, 0xb0, 0x81, 0xfa, 0x28, 0x8b, 0x58, 0x68, 0x39, + 0x8d, 0xb9, 0x50, 0x74, 0x10, 0x31, 0x81, 0xda, 0xe1, 0x08, 0xaa, 0x2a, 0xe3, 0xc3, 0xac, 0xe4, 0x71, 0x20, 0x8d, + 0x08, 0xb3, 0xdd, 0x88, 0xe5, 0xaa, 0x51, 0x15, 0x66, 0x62, 0xc6, 0x80, 0x5a, 0x9a, 0x32, 0xfb, 0xfb, 0xdc, 0xbe, + 0x83, 0xae, 0x77, 0xcc, 0xc3, 0xd6, 0x70, 0xb6, 0xf6, 0x8e, 0xaa, 0xce, 0xd9, 0x6a, 0x36, 0x32, 0xaa, 0x22, 0x2b, + 0xe9, 0x87, 0x93, 0x58, 0x3e, 0x2e, 0x58, 0xa1, 0x99, 0x61, 0xf0, 0x6f, 0x2f, 0x21, 0x60, 0x0d, 0x7e, 0x5a, 0x1b, + 0x78, 0x47, 0x8f, 0xfe, 0xc8, 0xda, 0xa7, 0x33, 0x0a, 0xd6, 0xf4, 0x96, 0x76, 0x1f, 0x78, 0xb2, 0x3c, 0xb7, 0xbe, + 0xb9, 0x2f, 0xda, 0xcc, 0x6a, 0x8e, 0xf2, 0xf7, 0x4e, 0x73, 0xb4, 0x7d, 0x56, 0xf6, 0x82, 0x65, 0xbc, 0x7b, 0xab, + 0x9c, 0x93, 0x0d, 0xbd, 0x7b, 0x77, 0xd9, 0x11, 0x4c, 0xa9, 0x7c, 0xa6, 0x9c, 0x7f, 0xd4, 0x6b, 0xc4, 0x38, 0xbd, + 0xc4, 0xe0, 0x1f, 0xdd, 0x95, 0xd8, 0x35, 0xa4, 0x08, 0xa7, 0xa1, 0xb2, 0x4b, 0x61, 0xb7, 0x1c, 0x76, 0xd8, 0xb9, + 0x75, 0x5c, 0x62, 0x9b, 0x71, 0xa2, 0x8d, 0xfd, 0x82, 0x96, 0x3e, 0x8d, 0x2d, 0x73, 0xee, 0x73, 0x6c, 0xec, 0x59, + 0x35, 0x2d, 0xb6, 0x6b, 0x8f, 0x11, 0x9d, 0xff, 0xd5, 0x6e, 0xed, 0x1f, 0xda, 0x42, 0xbc, 0xf4, 0xd3, 0x25, 0x45, + 0x66, 0xfa, 0x72, 0xbb, 0xa7, 0xe8, 0xe3, 0x0c, 0x95, 0x7d, 0xa3, 0x79, 0x10, 0x8b, 0xcd, 0xd8, 0xa6, 0x1f, 0xb6, + 0xa7, 0x6e, 0xc5, 0x6d, 0xae, 0x73, 0x6b, 0x75, 0x4b, 0xf3, 0x51, 0x2e, 0x87, 0xcb, 0x81, 0x9c, 0x89, 0xb8, 0x01, + 0xc3, 0x5f, 0xa6, 0x64, 0x61, 0x21, 0x9d, 0x81, 0x52, 0xa7, 0xfe, 0x5c, 0x64, 0x9e, 0xc4, 0x81, 0xd6, 0xa4, 0xa9, + 0x09, 0xd0, 0x5b, 0x33, 0x38, 0xb0, 0x7d, 0x64, 0x7e, 0xff, 0xc4, 0xbc, 0x2a, 0x24, 0xe2, 0xbc, 0xe3, 0x6f, 0x8d, + 0x61, 0x68, 0xab, 0x2c, 0x28, 0x5a, 0xef, 0x08, 0xa3, 0xd9, 0x9c, 0x13, 0xea, 0xb0, 0x38, 0x4d, 0xc3, 0xbe, 0x78, + 0x82, 0x00, 0x17, 0x02, 0x57, 0xe6, 0x3d, 0x9a, 0x30, 0x13, 0x4a, 0xe0, 0x3e, 0x06, 0x98, 0x55, 0x8f, 0xdf, 0x76, + 0xbe, 0x32, 0x39, 0x06, 0x43, 0x8a, 0xb4, 0x76, 0xd3, 0x52, 0x4a, 0x3d, 0x55, 0xae, 0xd1, 0xb8, 0x45, 0x3f, 0xb5, + 0xb7, 0xa7, 0xc2, 0xc7, 0xf9, 0x5a, 0xce, 0xdc, 0x05, 0x61, 0xa0, 0xaf, 0x5e, 0xe2, 0x30, 0x34, 0x36, 0x99, 0xe3, + 0xd1, 0x10, 0x45, 0x64, 0x96, 0x4a, 0xd6, 0xea, 0x97, 0xce, 0x9b, 0x33, 0xb1, 0x0c, 0xa4, 0xe4, 0x82, 0x42, 0xd3, + 0x0a, 0x11, 0x2c, 0x85, 0x1c, 0x1f, 0xc9, 0xff, 0xc4, 0x01, 0xb8, 0x70, 0x01, 0x81, 0xb9, 0xb7, 0xc9, 0xa2, 0x48, + 0x33, 0x9e, 0x59, 0x99, 0x31, 0x0b, 0x50, 0x96, 0x78, 0x40, 0xba, 0xbc, 0x75, 0x3c, 0x3d, 0xd2, 0xb1, 0x4d, 0xd2, + 0x69, 0x60, 0xca, 0x76, 0x15, 0x35, 0xfe, 0xcf, 0x9e, 0xcb, 0x51, 0x99, 0x68, 0xc4, 0x89, 0x8a, 0x22, 0x53, 0x70, + 0x30, 0x1c, 0x53, 0x25, 0xd9, 0x2b, 0xff, 0x30, 0xa2, 0x3b, 0x18, 0xc6, 0xa4, 0x7c, 0x53, 0x5b, 0x93, 0x23, 0xd3, + 0xf3, 0x47, 0xd4, 0x99, 0x90, 0xd4, 0x50, 0x5e, 0x7f, 0x9a, 0xcd, 0x0f, 0xcd, 0x9b, 0x08, 0xc7, 0x6c, 0x9c, 0xec, + 0x2a, 0x53, 0xa0, 0xce, 0xc0, 0x53, 0x86, 0xae, 0x2c, 0x29, 0x77, 0xbb, 0x19, 0xa8, 0x28, 0x30, 0xde, 0x24, 0x98, + 0xab, 0xc5, 0x89, 0x94, 0x37, 0x41, 0xea, 0x1c, 0xce, 0xa9, 0x07, 0x4f, 0x3b, 0x96, 0xbd, 0x5e, 0xb0, 0xa5, 0x81, + 0x27, 0xfb, 0x32, 0xac, 0x2f, 0x59, 0x56, 0xcc, 0x56, 0xb9, 0x6f, 0x27, 0x93, 0x37, 0xb1, 0x82, 0xe1, 0x0e, 0x31, + 0xc5, 0x85, 0xa9, 0xe7, 0xff, 0xec, 0xac, 0xff, 0xce, 0x05, 0x87, 0x65, 0xbf, 0x59, 0x83, 0x5d, 0x06, 0xa3, 0x98, + 0xc6, 0xab, 0x57, 0x18, 0x66, 0xd9, 0x60, 0x08, 0x1c, 0x29, 0x80, 0x50, 0x3c, 0x50, 0xb2, 0x38, 0xb7, 0x1f, 0xe8, + 0x11, 0xf7, 0xd3, 0xb7, 0x82, 0x92, 0x40, 0x49, 0x48, 0x7d, 0xfb, 0x36, 0xf7, 0xb2, 0xe7, 0xa3, 0x47, 0xd7, 0xb3, + 0xff, 0x37, 0xd7, 0xaf, 0x62, 0xbb, 0x9b, 0x66, 0xf5, 0xc0, 0x89, 0x36, 0xc0, 0x1f, 0x46, 0xec, 0x5e, 0xf9, 0x9e, + 0xd7, 0x7b, 0x6d, 0xab, 0x3c, 0xe3, 0x5d, 0xa9, 0xb2, 0x3a, 0x28, 0xb3, 0xb6, 0x6d, 0x0e, 0x9c, 0x33, 0xcb, 0x3f, + 0xb9, 0xe1, 0xc3, 0x87, 0xfb, 0x8d, 0x36, 0xfc, 0xe2, 0x7a, 0x67, 0xec, 0x8e, 0x53, 0x27, 0x30, 0x56, 0x1b, 0x83, + 0xef, 0xd0, 0xf9, 0xd3, 0x99, 0x1f, 0x74, 0x4c, 0x13, 0xef, 0xf1, 0x95, 0x2f, 0x1c, 0xc3, 0x4c, 0xdf, 0xe0, 0xa5, + 0x78, 0x76, 0x7b, 0x1a, 0x47, 0x87, 0x20, 0x87, 0x36, 0x99, 0x48, 0x52, 0x5b, 0x93, 0xaa, 0x14, 0x20, 0x56, 0xc8, + 0x12, 0x55, 0x06, 0x82, 0xa1, 0xe3, 0xb6, 0x4a, 0x1b, 0x0b, 0x2f, 0x9e, 0x9e, 0xfe, 0x5c, 0x7d, 0x26, 0x81, 0x6c, + 0x51, 0x5e, 0x8e, 0xf4, 0xc0, 0x01, 0x9b, 0xa4, 0x0f, 0x94, 0x39, 0xd6, 0xd6, 0xc2, 0x81, 0xa7, 0x76, 0x9d, 0xfc, + 0xb0, 0xf8, 0x1a, 0x4b, 0xef, 0xbe, 0x1d, 0x3d, 0xc8, 0xa1, 0xc4, 0xb4, 0x42, 0xc8, 0x79, 0x7f, 0x5f, 0x1c, 0x28, + 0xef, 0x99, 0x59, 0xc4, 0x2d, 0xcb, 0x73, 0xa0, 0xcc, 0xf8, 0x5a, 0x12, 0xc5, 0xcf, 0xb6, 0xd2, 0x9a, 0x29, 0x7e, + 0x7a, 0x49, 0x24, 0x40, 0xf0, 0x0f, 0xed, 0xee, 0xcc, 0xf6, 0xb3, 0xf3, 0xfc, 0x97, 0x30, 0xb3, 0x0f, 0xd3, 0xb7, + 0x5b, 0xe1, 0xa2, 0xe0, 0xe9, 0xe2, 0x87, 0xde, 0xde, 0x93, 0x55, 0xfd, 0xee, 0x85, 0x08, 0x6b, 0xd0, 0xc5, 0x94, + 0xe1, 0xc9, 0x50, 0x0c, 0x0f, 0xa6, 0x4e, 0x7c, 0xbc, 0x1d, 0xfb, 0x5a, 0x09, 0x94, 0x76, 0x07, 0x07, 0x20, 0xc7, + 0x76, 0x48, 0x4d, 0x5f, 0x85, 0xac, 0xf1, 0xa0, 0x17, 0x4d, 0xef, 0x8b, 0x1d, 0x64, 0x4a, 0xef, 0xeb, 0x6f, 0x55, + 0x4b, 0x1e, 0x16, 0x86, 0xa9, 0xf7, 0x5c, 0x77, 0x0d, 0x41, 0x8c, 0x2f, 0x67, 0xad, 0x66, 0x9d, 0xa4, 0x1d, 0xcb, + 0x46, 0x19, 0x11, 0x98, 0x8d, 0x49, 0xf1, 0x00, 0x7c, 0x25, 0x8e, 0x39, 0x7f, 0xbb, 0x78, 0xcd, 0x79, 0xc4, 0x8b, + 0x60, 0x5d, 0x10, 0x6a, 0xc4, 0x71, 0xe9, 0x7a, 0x99, 0xb0, 0x6c, 0x6c, 0x92, 0x47, 0xa2, 0xeb, 0x0e, 0x38, 0xe5, + 0x0b, 0xf8, 0xb2, 0x0e, 0xcd, 0x7d, 0x56, 0x59, 0xf8, 0xcc, 0x63, 0x6d, 0x87, 0x59, 0x55, 0x4a, 0x76, 0xe7, 0xf1, + 0xb1, 0x25, 0x87, 0x8d, 0x7c, 0x17, 0xd5, 0x5e, 0xa0, 0x09, 0x02, 0x07, 0x5a, 0xf5, 0x6c, 0xa2, 0x16, 0xdc, 0xe1, + 0x26, 0xc4, 0x8a, 0xc6, 0x2f, 0x01, 0x2c, 0x9a, 0x00, 0xb5, 0xc6, 0xc9, 0xae, 0xe3, 0x61, 0xaa, 0xa7, 0x1b, 0x73, + 0x7c, 0x23, 0x47, 0x14, 0x2d, 0x92, 0x26, 0x18, 0x70, 0x94, 0x07, 0x26, 0xc9, 0x5a, 0x56, 0xf4, 0x90, 0x3c, 0x1a, + 0x06, 0x4a, 0x0a, 0xa2, 0x76, 0x46, 0x18, 0xf6, 0x4b, 0x25, 0x5e, 0x16, 0x7c, 0xd0, 0xa2, 0x25, 0xce, 0xaf, 0xab, + 0x75, 0x7e, 0x5b, 0x1e, 0x65, 0x12, 0x8d, 0x86, 0x10, 0xbe, 0x85, 0x58, 0x1c, 0xc5, 0x17, 0x2b, 0x1a, 0x39, 0xc3, + 0x64, 0xa4, 0xc7, 0xbc, 0xc2, 0xb8, 0x21, 0x38, 0x7d, 0xfe, 0x4a, 0x17, 0x7e, 0xd5, 0x45, 0xab, 0x9c, 0x08, 0xfb, + 0x8b, 0x12, 0x9b, 0xee, 0x7d, 0x49, 0xa3, 0x7a, 0xdf, 0x4d, 0x88, 0xcc, 0x20, 0x70, 0xd4, 0xb5, 0x0a, 0xdd, 0xf5, + 0x0a, 0x54, 0x2e, 0xea, 0xb6, 0xb8, 0x8b, 0x71, 0x5c, 0x77, 0x7b, 0x16, 0x78, 0x69, 0x0f, 0x0e, 0xda, 0xe6, 0x99, + 0x60, 0xa2, 0x67, 0xff, 0x2c, 0xd9, 0xca, 0x56, 0xa8, 0xa4, 0xea, 0x48, 0x11, 0xaf, 0xa9, 0xd0, 0x18, 0xb8, 0xc2, + 0x44, 0xb7, 0x85, 0x4e, 0xef, 0x32, 0xdd, 0xce, 0x5e, 0xdb, 0x4f, 0x7d, 0x16, 0xc4, 0xf9, 0x88, 0x68, 0xc2, 0x0c, + 0x51, 0x5d, 0x20, 0x81, 0x6b, 0x52, 0x74, 0x88, 0xd3, 0x54, 0xb0, 0xa7, 0xcc, 0xe3, 0xc0, 0xc9, 0x2a, 0x83, 0xa5, + 0x69, 0x04, 0x51, 0xf7, 0xb9, 0xfb, 0xde, 0x1a, 0xad, 0x5c, 0x14, 0x18, 0xb8, 0xf3, 0x19, 0x88, 0x9a, 0x45, 0xe8, + 0xc9, 0x12, 0xd3, 0x7d, 0xb4, 0x76, 0x46, 0x8f, 0xa7, 0xf5, 0xb7, 0xc9, 0x76, 0x68, 0x46, 0xeb, 0x38, 0x56, 0x37, + 0xf4, 0xfd, 0x47, 0x07, 0x4e, 0x7d, 0x68, 0xe2, 0x64, 0x96, 0x3a, 0xf3, 0x12, 0x74, 0xe7, 0x9a, 0xe4, 0x08, 0x89, + 0x26, 0x8a, 0x94, 0x04, 0x27, 0x5a, 0xa0, 0xd2, 0x33, 0x20, 0xc0, 0x08, 0xf5, 0x97, 0x3a, 0xe3, 0xb5, 0x2e, 0x8e, + 0x7e, 0x1e, 0x32, 0x70, 0xe9, 0xc0, 0x42, 0xa9, 0x2a, 0x2a, 0x0a, 0x18, 0xee, 0x70, 0x1e, 0xfc, 0x8f, 0xac, 0x44, + 0x92, 0x8a, 0xd6, 0x2a, 0x21, 0xc7, 0x10, 0xb9, 0x60, 0x8c, 0x21, 0xd9, 0xa7, 0x88, 0x13, 0x45, 0x15, 0x6e, 0x63, + 0x93, 0x80, 0x46, 0xbc, 0x8a, 0x50, 0xc2, 0x5c, 0x57, 0x01, 0x32, 0xc0, 0x95, 0xd8, 0x8b, 0xfa, 0xdf, 0x91, 0x23, + 0xc3, 0x28, 0xb6, 0x21, 0x35, 0xb5, 0xca, 0xeb, 0xbc, 0x0b, 0x74, 0x70, 0x72, 0x73, 0x56, 0xe4, 0xa3, 0xc9, 0x70, + 0x20, 0xdf, 0x28, 0xc1, 0xf3, 0xe2, 0x7b, 0x04, 0x4d, 0x90, 0x52, 0xa8, 0x73, 0x46, 0xbe, 0x31, 0x42, 0x5e, 0xca, + 0x05, 0x0e, 0x5a, 0x41, 0xed, 0xce, 0x06, 0x03, 0xc7, 0x48, 0xb4, 0x63, 0xcf, 0x73, 0x5d, 0x92, 0xd1, 0x3c, 0x0e, + 0xc2, 0xda, 0x91, 0xb4, 0xca, 0x88, 0x13, 0x9e, 0x5a, 0xee, 0x64, 0xd3, 0x42, 0xff, 0x09, 0xc4, 0x8a, 0xbd, 0x54, + 0x1c, 0xc5, 0xa3, 0xef, 0x70, 0xbc, 0x1c, 0x7e, 0x1f, 0x44, 0xb9, 0xb7, 0x5b, 0xb1, 0xbb, 0xd5, 0xdb, 0x6a, 0x41, + 0xde, 0x5a, 0xd6, 0x55, 0xc8, 0xf0, 0x7c, 0x0f, 0x55, 0xdf, 0x49, 0xb5, 0x6f, 0x00, 0xf0, 0x39, 0xfc, 0xcc, 0x7c, + 0x96, 0x8e, 0xb7, 0xbb, 0xd8, 0x53, 0x7f, 0x15, 0xfb, 0xe7, 0xee, 0xcb, 0xe2, 0x55, 0xc6, 0xe8, 0xb5, 0xed, 0x8b, + 0x02, 0xf2, 0x5a, 0xc3, 0xcb, 0xf8, 0x4d, 0x97, 0xf3, 0xba, 0xea, 0xef, 0xd9, 0x1c, 0x05, 0x2f, 0xe8, 0x3e, 0x37, + 0x55, 0x39, 0x9f, 0xc9, 0xd3, 0xdc, 0x02, 0x35, 0x72, 0x1b, 0x68, 0x35, 0xb1, 0x1b, 0x92, 0xee, 0x8a, 0xae, 0x0b, + 0x38, 0x03, 0x7e, 0x4f, 0xad, 0x90, 0x51, 0x3d, 0x96, 0x96, 0x0a, 0xa9, 0x1f, 0x50, 0x0f, 0xb5, 0x57, 0x85, 0x2c, + 0x07, 0x1e, 0x24, 0xab, 0x25, 0x2c, 0xe1, 0xa4, 0x5c, 0x04, 0x48, 0x32, 0x6c, 0x96, 0xa1, 0x40, 0xbd, 0x19, 0x59, + 0x43, 0x41, 0x5d, 0x59, 0x03, 0x30, 0x57, 0x99, 0x09, 0x94, 0x29, 0x52, 0x5e, 0x95, 0x4a, 0x41, 0x82, 0xe6, 0x41, + 0x4b, 0x84, 0xde, 0xb5, 0xbc, 0xe2, 0xc2, 0x79, 0x98, 0x4d, 0xab, 0x06, 0x08, 0x3f, 0x76, 0xd0, 0x63, 0xf3, 0x20, + 0x55, 0xa5, 0x76, 0x72, 0xda, 0x87, 0x7f, 0x0b, 0x77, 0x4b, 0x0b, 0x6f, 0x45, 0x7e, 0xb9, 0x7d, 0x6e, 0xe1, 0x99, + 0xb4, 0xb8, 0x9e, 0xeb, 0xe9, 0xc5, 0x11, 0x44, 0xb4, 0xdb, 0x2e, 0x8d, 0x4f, 0x2f, 0x3d, 0xbd, 0x70, 0x5d, 0x9d, + 0x43, 0x4a, 0xa4, 0xb8, 0x8d, 0xd3, 0x07, 0xad, 0xde, 0x06, 0xd9, 0x6f, 0x77, 0xf9, 0x69, 0x95, 0x7c, 0x7e, 0x13, + 0xab, 0xff, 0xa5, 0xdf, 0x15, 0x47, 0x5b, 0x6d, 0x48, 0xa3, 0xae, 0xbb, 0xe0, 0xa7, 0x5b, 0xe0, 0x49, 0xe5, 0x66, + 0xf6, 0xf8, 0x2f, 0xac, 0x05, 0x8a, 0x1b, 0x6e, 0xb3, 0x8f, 0x06, 0x9e, 0xa6, 0x58, 0xbd, 0x6b, 0x9c, 0x5a, 0x41, + 0x43, 0x22, 0x5f, 0xc1, 0xb2, 0xbb, 0x17, 0x25, 0x85, 0x2d, 0xa3, 0x0a, 0x80, 0x64, 0xab, 0x66, 0x63, 0x75, 0xbc, + 0xd4, 0x39, 0x58, 0xfb, 0xca, 0x0b, 0x11, 0x3c, 0xfb, 0xa1, 0xb7, 0x2c, 0x96, 0xaf, 0x46, 0xe8, 0x97, 0x3f, 0x36, + 0xf3, 0xd2, 0xec, 0x69, 0x18, 0x83, 0xde, 0xc5, 0x16, 0xcf, 0x9c, 0xc9, 0x0b, 0xd0, 0x3f, 0xb1, 0xae, 0xec, 0xd8, + 0x4d, 0xa3, 0x0b, 0x93, 0x0e, 0xdc, 0x92, 0xa1, 0x88, 0x5d, 0x96, 0x6d, 0x13, 0x9f, 0xe7, 0x95, 0x6f, 0xd4, 0xcc, + 0x78, 0xa6, 0xf1, 0xe9, 0x5b, 0xf9, 0xd6, 0xcb, 0xe4, 0xf4, 0x71, 0x27, 0xea, 0x98, 0x40, 0x64, 0x12, 0x4d, 0x4e, + 0x50, 0x7f, 0x54, 0x7c, 0xdc, 0x13, 0x8e, 0x55, 0x48, 0x08, 0x6c, 0x6f, 0x3e, 0x7b, 0x13, 0xac, 0x7d, 0x56, 0xb3, + 0x90, 0xfd, 0xab, 0xac, 0x8c, 0x8f, 0x71, 0x67, 0xf5, 0xd1, 0xca, 0x4b, 0x87, 0x20, 0xca, 0xd5, 0x5b, 0xea, 0xda, + 0x63, 0x75, 0xdc, 0xaf, 0xf1, 0xe7, 0x8c, 0xfd, 0x2e, 0x75, 0xe1, 0x20, 0x52, 0x72, 0xd4, 0x6c, 0x24, 0x60, 0x2a, + 0x7a, 0x44, 0xa4, 0x2b, 0xe2, 0x03, 0xa4, 0x3d, 0xed, 0xbd, 0x14, 0xf5, 0x09, 0xb5, 0xf3, 0x59, 0x98, 0x85, 0x4d, + 0xed, 0x56, 0x0c, 0x83, 0x53, 0xda, 0x72, 0x6b, 0xf8, 0xd2, 0x99, 0x74, 0x9a, 0x8a, 0xd4, 0xa5, 0xa3, 0x2a, 0xaa, + 0x17, 0xbb, 0x02, 0x17, 0xe1, 0x24, 0x08, 0xf2, 0xf5, 0xab, 0x3f, 0x20, 0xa5, 0x53, 0x41, 0x9d, 0x05, 0x91, 0x49, + 0x7a, 0xf8, 0x48, 0x91, 0x50, 0x99, 0xb1, 0x4f, 0x0b, 0x23, 0x8e, 0x91, 0xa4, 0x2f, 0x14, 0x66, 0xd9, 0x7a, 0x50, + 0x4f, 0x94, 0xb0, 0xc6, 0xc8, 0x16, 0xa7, 0xaa, 0xaf, 0xb4, 0x2c, 0x51, 0xcc, 0x76, 0xed, 0xfc, 0x59, 0x5a, 0xd3, + 0xd8, 0x2e, 0x5a, 0x27, 0x99, 0xdf, 0x73, 0x0a, 0x79, 0x0d, 0xc7, 0xc7, 0x61, 0xd9, 0xeb, 0xf8, 0x61, 0xc0, 0x89, + 0x21, 0xc1, 0x8c, 0x6f, 0x0e, 0x4d, 0x99, 0x21, 0x22, 0xfd, 0x2c, 0xf8, 0x45, 0xc7, 0x0e, 0x40, 0x3a, 0x27, 0xb3, + 0x24, 0x59, 0xe5, 0xce, 0x50, 0x61, 0xe1, 0x15, 0x87, 0x45, 0xbb, 0xe8, 0xd3, 0xa5, 0xed, 0x36, 0x3c, 0x37, 0x2b, + 0x17, 0x09, 0xae, 0x00, 0x1e, 0xda, 0x74, 0x52, 0xf5, 0xba, 0xe8, 0xe6, 0x41, 0xb6, 0x99, 0x5b, 0x0f, 0x14, 0x0d, + 0x3e, 0x54, 0xec, 0xc9, 0x92, 0x4d, 0xa8, 0x64, 0xc9, 0x06, 0xd5, 0x8d, 0x64, 0x10, 0x82, 0x88, 0x45, 0xcb, 0xd8, + 0x9e, 0xa6, 0x67, 0x08, 0xa5, 0x45, 0x9c, 0x0f, 0x05, 0x7f, 0xb4, 0x16, 0xec, 0xeb, 0x81, 0xc5, 0xa6, 0xbb, 0x95, + 0x74, 0x9f, 0xe3, 0x8e, 0x66, 0x69, 0x3e, 0xf5, 0x79, 0x48, 0x2d, 0x98, 0x6b, 0x74, 0x15, 0x6d, 0x72, 0x8f, 0x7b, + 0x92, 0x26, 0x72, 0xa4, 0x4d, 0x26, 0x77, 0x08, 0x06, 0xa5, 0x81, 0xe1, 0x57, 0xc6, 0x57, 0xc5, 0x1b, 0xf0, 0x4e, + 0x82, 0xe7, 0x2b, 0xe1, 0x3e, 0x27, 0x52, 0x77, 0x5b, 0x99, 0x3f, 0x1e, 0xe1, 0x0c, 0x1e, 0x7f, 0xac, 0x42, 0x4c, + 0x3b, 0xa6, 0xfb, 0xde, 0xec, 0x78, 0xde, 0x2f, 0x67, 0x47, 0x48, 0x2e, 0x49, 0x14, 0x47, 0x9e, 0xfc, 0x6b, 0x4a, + 0xaf, 0x88, 0xd2, 0x26, 0x59, 0xc4, 0x8c, 0xe7, 0x3b, 0x89, 0x5c, 0x8d, 0x3b, 0xf4, 0x0e, 0x71, 0x0d, 0x0d, 0xa2, + 0x17, 0xdb, 0x6a, 0xab, 0x33, 0x93, 0x2b, 0x02, 0xf7, 0x4d, 0xe3, 0xc9, 0x0c, 0xe3, 0x65, 0xe8, 0x82, 0xfe, 0x34, + 0x6a, 0x93, 0xcf, 0x88, 0x50, 0xaa, 0xbc, 0x95, 0xbe, 0x10, 0x14, 0x50, 0x66, 0x84, 0x50, 0x41, 0x45, 0x8c, 0xb0, + 0x0f, 0x9e, 0x83, 0x88, 0x98, 0x66, 0xc1, 0x9c, 0xa2, 0xe8, 0x47, 0xfa, 0x0e, 0xc6, 0x77, 0x6a, 0xa3, 0xbc, 0x41, + 0x27, 0xc4, 0x05, 0x73, 0x88, 0x98, 0xb1, 0xf3, 0xc9, 0xec, 0x34, 0xa5, 0x0b, 0x93, 0xc5, 0xe4, 0xfc, 0x36, 0x96, + 0x28, 0xef, 0xfc, 0x1b, 0x29, 0xe7, 0x92, 0x6d, 0xa8, 0xc5, 0xa7, 0x6a, 0x52, 0x99, 0x45, 0xcb, 0x6d, 0x5d, 0xc1, + 0x63, 0x36, 0x94, 0x79, 0xc9, 0x55, 0x83, 0x75, 0xe5, 0xd7, 0x57, 0x97, 0xd4, 0xa6, 0xb2, 0x0f, 0x10, 0x96, 0x3b, + 0x5b, 0x39, 0xfd, 0x0c, 0x41, 0x2a, 0xcf, 0x4f, 0xed, 0xd7, 0xa7, 0x92, 0xe4, 0x85, 0xbd, 0xf5, 0x67, 0xd3, 0xfa, + 0x57, 0x6f, 0xf9, 0x22, 0x94, 0x1f, 0x04, 0xaf, 0x0d, 0xaa, 0x0a, 0xca, 0x63, 0x9d, 0x66, 0xe6, 0xfd, 0x92, 0x25, + 0x92, 0x15, 0x85, 0xdc, 0x56, 0x8f, 0x4e, 0xb0, 0x7e, 0xbc, 0x10, 0x8a, 0x79, 0x97, 0x63, 0x8b, 0xa8, 0xc7, 0x9e, + 0x51, 0x54, 0xdb, 0x59, 0x1b, 0x87, 0x82, 0x42, 0xad, 0xec, 0x62, 0xfc, 0x39, 0x0e, 0x0d, 0x4f, 0xbb, 0x72, 0x02, + 0xa2, 0x18, 0x74, 0x7b, 0x51, 0x7a, 0xbf, 0x23, 0x19, 0x93, 0x7c, 0xde, 0xce, 0x13, 0x9f, 0x88, 0x56, 0x31, 0x85, + 0x5d, 0xa5, 0x05, 0x3f, 0x07, 0x0f, 0x7d, 0xeb, 0xba, 0x75, 0xe8, 0x77, 0x63, 0x74, 0xd7, 0x6d, 0x27, 0xbe, 0x6e, + 0x04, 0xd9, 0xd8, 0x0b, 0xb9, 0xd4, 0xe5, 0x31, 0x15, 0x15, 0x04, 0xd6, 0x36, 0x86, 0xc7, 0x6b, 0xbd, 0x46, 0xc9, + 0x1f, 0xd8, 0x33, 0xc3, 0x46, 0x21, 0x97, 0xbe, 0x20, 0x9e, 0xa4, 0x48, 0x56, 0xc4, 0x3b, 0xa6, 0x7c, 0x1b, 0xaa, + 0xe5, 0x62, 0xc5, 0xd3, 0xf8, 0x07, 0xbb, 0x4c, 0x97, 0x8d, 0xd1, 0x24, 0x24, 0x3b, 0xb4, 0xc4, 0xc7, 0xec, 0x42, + 0x90, 0x90, 0x63, 0xf9, 0x1e, 0xa0, 0x00, 0x21, 0x79, 0x7a, 0x76, 0x1a, 0x01, 0xb5, 0xde, 0x62, 0xc5, 0x71, 0xe0, + 0x42, 0x77, 0xe5, 0xbf, 0xb4, 0x65, 0xe0, 0x16, 0x95, 0xb8, 0x41, 0x2d, 0x35, 0xee, 0x1b, 0xb4, 0xdb, 0xae, 0x6b, + 0x3f, 0x79, 0x13, 0xb3, 0x7c, 0x3b, 0x72, 0x5d, 0x82, 0xf4, 0x81, 0x77, 0x0f, 0x7e, 0xdb, 0xed, 0x81, 0x61, 0xd1, + 0x1e, 0x5c, 0xa0, 0x56, 0xbc, 0x23, 0xb0, 0xc3, 0x86, 0x94, 0x80, 0xad, 0x1b, 0x35, 0x2a, 0x77, 0xef, 0x46, 0xd0, + 0x20, 0xb9, 0x72, 0xcb, 0x79, 0xca, 0x2f, 0xc5, 0x9e, 0x0b, 0x66, 0xaa, 0x5e, 0xa7, 0x6d, 0x74, 0x80, 0xa7, 0x8e, + 0x0c, 0x45, 0xea, 0xce, 0x8d, 0x8e, 0x11, 0x52, 0x21, 0x52, 0xb3, 0xa8, 0xb8, 0xdf, 0xf9, 0x25, 0x8a, 0x36, 0x74, + 0x6f, 0x08, 0x79, 0x61, 0xab, 0xbe, 0x68, 0x59, 0x99, 0xb5, 0xce, 0x2f, 0x94, 0x1d, 0xa1, 0xa5, 0xa5, 0xe0, 0xc3, + 0xc6, 0xca, 0xa0, 0x11, 0x2e, 0x6d, 0x1a, 0x1b, 0x48, 0xd0, 0x79, 0x24, 0x82, 0xd5, 0x4c, 0x04, 0x74, 0x65, 0x57, + 0x3c, 0xfc, 0x35, 0xb3, 0xd5, 0x96, 0x5c, 0xda, 0x35, 0x4f, 0x95, 0x4e, 0x20, 0xe8, 0x59, 0xef, 0x5c, 0x58, 0x5f, + 0x97, 0x3e, 0x66, 0x35, 0x69, 0x52, 0xed, 0x5e, 0xb2, 0x53, 0x75, 0xe8, 0xbc, 0xe5, 0x6a, 0x71, 0xab, 0x47, 0xd2, + 0x9e, 0x09, 0x96, 0xd3, 0xdf, 0xfa, 0xc1, 0x85, 0xe9, 0x14, 0x1e, 0xe6, 0x36, 0xd5, 0xe6, 0x26, 0x50, 0x79, 0x4d, + 0xc9, 0xfb, 0xe9, 0xf5, 0x75, 0x73, 0x18, 0xa3, 0x1f, 0xc4, 0x02, 0xd0, 0x07, 0x97, 0xcb, 0xca, 0x7d, 0xa7, 0x98, + 0x0c, 0xc5, 0x3d, 0xf9, 0x2d, 0xff, 0x6f, 0x01, 0xe6, 0xc2, 0xc6, 0xc5, 0x8b, 0x65, 0x4f, 0x5c, 0x3b, 0x5d, 0xbc, + 0x64, 0x15, 0xf0, 0xed, 0x75, 0x12, 0x10, 0x39, 0x13, 0x02, 0xcd, 0xb8, 0x3f, 0x48, 0xc3, 0x5d, 0xf2, 0xf6, 0x79, + 0x01, 0x1c, 0x85, 0xad, 0xf0, 0x4d, 0x0c, 0xee, 0xde, 0xed, 0x83, 0xaf, 0x2c, 0xa5, 0xca, 0x2e, 0xc5, 0xf2, 0x40, + 0xe1, 0xd8, 0xcd, 0x20, 0x30, 0x1a, 0x68, 0x32, 0x1f, 0x88, 0xb1, 0x20, 0xc3, 0xd3, 0x8f, 0xf1, 0x9d, 0x52, 0xe5, + 0x16, 0x45, 0x4f, 0xc6, 0x9e, 0xc6, 0x1b, 0x38, 0x01, 0x62, 0x35, 0x68, 0xc9, 0x6f, 0x80, 0x82, 0x59, 0xf8, 0xb0, + 0x00, 0xce, 0xc8, 0x87, 0x38, 0x5c, 0xe9, 0x36, 0xd1, 0x81, 0x73, 0x0d, 0x00, 0xb5, 0xcf, 0xdf, 0x74, 0x0a, 0xc9, + 0x8f, 0xf1, 0xbb, 0x33, 0x7b, 0x87, 0x63, 0x3d, 0x3b, 0xe2, 0x43, 0xbe, 0x8a, 0x9e, 0x64, 0xc1, 0x38, 0x19, 0xc7, + 0xde, 0x23, 0x38, 0xd5, 0x90, 0x0a, 0xe8, 0x13, 0xf7, 0x2b, 0xab, 0xf7, 0xfa, 0x18, 0xfa, 0x7f, 0xb7, 0x0f, 0xfa, + 0xa3, 0xff, 0x2f, 0xdb, 0x8b, 0x1e, 0x19, 0x05, 0x74, 0xd7, 0xe7, 0xfa, 0xd7, 0x41, 0xea, 0x26, 0x48, 0xe8, 0x94, + 0xdb, 0xdf, 0xfe, 0xdf, 0x1a, 0x4c, 0x92, 0x8a, 0x6a, 0x91, 0x31, 0x89, 0xbd, 0x93, 0x34, 0xf8, 0xcf, 0xa3, 0x6a, + 0x6b, 0x80, 0x04, 0x35, 0x53, 0x3e, 0x2f, 0x31, 0xff, 0x1d, 0xaf, 0xed, 0xce, 0xc8, 0x4e, 0xd7, 0x73, 0xff, 0xeb, + 0xe4, 0x89, 0x4e, 0xa7, 0xe5, 0xc6, 0xb3, 0x6e, 0x2d, 0x33, 0xc0, 0x5f, 0xc4, 0xc0, 0xdf, 0x6c, 0x5d, 0xd2, 0x00, + 0x0e, 0xc8, 0x1c, 0xc2, 0x89, 0x51, 0xbc, 0xda, 0x70, 0xba, 0xf5, 0x15, 0x54, 0xbd, 0x2a, 0x29, 0xd1, 0xd5, 0xce, + 0xab, 0xa6, 0x59, 0xa0, 0x3c, 0x38, 0xf6, 0xa5, 0x4b, 0x0c, 0x43, 0x47, 0x0b, 0x04, 0xf5, 0x28, 0xf1, 0x0c, 0xa0, + 0x0f, 0x4b, 0xc7, 0xfa, 0xeb, 0x76, 0x41, 0x9e, 0x2e, 0x3b, 0x79, 0x21, 0xd7, 0xdc, 0x37, 0xd4, 0x71, 0xde, 0x70, + 0x33, 0x6e, 0x5e, 0x33, 0x40, 0xc5, 0x2f, 0x39, 0xd8, 0xe8, 0xb9, 0x97, 0xce, 0xc7, 0xf7, 0x87, 0x22, 0xec, 0xd8, + 0x31, 0x84, 0x86, 0xcb, 0xfc, 0xde, 0x2d, 0xfd, 0xb6, 0x51, 0x95, 0x0f, 0xd3, 0xe5, 0x1e, 0x4d, 0xb4, 0xfc, 0xd2, + 0xa4, 0x92, 0xaf, 0x9e, 0x1d, 0xf7, 0xda, 0xf2, 0x31, 0x5b, 0x5d, 0x54, 0xcd, 0x8e, 0x23, 0x8e, 0xba, 0x33, 0x9f, + 0xe5, 0xb5, 0xf0, 0x5b, 0x30, 0x51, 0x7e, 0x66, 0x10, 0xdb, 0x61, 0x41, 0xb5, 0xb8, 0x4a, 0xb7, 0x23, 0xb8, 0x84, + 0xc3, 0xff, 0x82, 0xd7, 0xe1, 0x71, 0xd5, 0x1b, 0x2e, 0x8c, 0x6b, 0xb4, 0x5e, 0x41, 0xf5, 0x53, 0x19, 0x89, 0x78, + 0x75, 0x17, 0x6c, 0x5a, 0xab, 0x8e, 0xcb, 0xec, 0x72, 0xaa, 0x1f, 0x91, 0x2e, 0xc6, 0x79, 0x55, 0xbc, 0xe4, 0x4a, + 0x3e, 0xa3, 0x08, 0x85, 0xb4, 0x7f, 0xb9, 0xcf, 0x63, 0x05, 0x64, 0x51, 0x81, 0xf5, 0xb5, 0x5c, 0x31, 0x2c, 0xb5, + 0x74, 0xba, 0x78, 0xd8, 0xfd, 0xe0, 0x8f, 0x68, 0xd9, 0x8f, 0x3f, 0x30, 0x9b, 0x9e, 0xff, 0xb5, 0x21, 0x12, 0x68, + 0xe4, 0x33, 0x38, 0x3a, 0x70, 0xfd, 0xa2, 0x32, 0xf6, 0xd9, 0xbc, 0xad, 0x15, 0xc6, 0x33, 0xb5, 0x3f, 0x46, 0x02, + 0x22, 0xf9, 0x35, 0x3b, 0xe6, 0x8c, 0x4b, 0x8c, 0xb4, 0x29, 0x79, 0x2d, 0x80, 0xe2, 0x8b, 0x69, 0x9e, 0xa7, 0xdd, + 0xda, 0x26, 0x83, 0x0c, 0x1c, 0x79, 0x3e, 0xc7, 0xcd, 0x78, 0xb2, 0xe1, 0x24, 0x48, 0xb9, 0x39, 0xb9, 0x64, 0xbd, + 0x8a, 0xe3, 0xd1, 0x84, 0x97, 0xb7, 0xe1, 0xd1, 0x07, 0xab, 0x12, 0x4d, 0x96, 0x20, 0x44, 0x7a, 0xf2, 0x59, 0x7c, + 0x99, 0x4f, 0x86, 0x79, 0xf3, 0x9d, 0xc9, 0x7f, 0xab, 0x47, 0x9f, 0xce, 0x58, 0x99, 0x4f, 0x11, 0xae, 0xd7, 0x7f, + 0x98, 0x5b, 0x16, 0x06, 0x3e, 0xd7, 0x67, 0x55, 0x44, 0x3a, 0xe9, 0xc3, 0x64, 0xf7, 0xfb, 0xb2, 0x23, 0x5c, 0x9d, + 0xdc, 0x39, 0x41, 0x92, 0x7c, 0xc8, 0xf6, 0x0c, 0x09, 0xc9, 0x18, 0xbc, 0x73, 0x30, 0x04, 0xad, 0x35, 0xd9, 0xe2, + 0xc4, 0x7b, 0x79, 0x77, 0xbe, 0x5f, 0xf6, 0x71, 0xef, 0x4b, 0xb5, 0xa5, 0x40, 0x52, 0xe4, 0x46, 0x9d, 0xd6, 0xf6, + 0x47, 0x68, 0x6d, 0xd5, 0x0c, 0x39, 0x1d, 0x7d, 0x71, 0x6d, 0xd3, 0x68, 0xed, 0xb9, 0x88, 0x10, 0x3f, 0x4a, 0xd1, + 0x74, 0xca, 0x19, 0x6c, 0xf3, 0x88, 0x22, 0x38, 0x06, 0x1c, 0xf6, 0x9c, 0x4e, 0xc4, 0x08, 0xc8, 0xe2, 0x83, 0x71, + 0x25, 0x9e, 0x86, 0xa2, 0x8a, 0x36, 0x1d, 0xc2, 0x68, 0x4e, 0xb3, 0x42, 0xa3, 0x47, 0x42, 0x8c, 0xa5, 0x76, 0x9c, + 0x31, 0x04, 0x76, 0x72, 0xf4, 0x36, 0x27, 0x24, 0x52, 0x3e, 0x50, 0x40, 0x8e, 0x11, 0x19, 0x0c, 0x8c, 0x81, 0x46, + 0xee, 0xe6, 0x76, 0x21, 0xc2, 0x86, 0x34, 0xa4, 0x9b, 0x9b, 0x1f, 0x3e, 0xe6, 0x56, 0x19, 0x99, 0x25, 0x4a, 0x40, + 0xdc, 0x7e, 0xca, 0x0d, 0x47, 0x3e, 0xbc, 0x62, 0xd8, 0x7e, 0xbb, 0xba, 0xcf, 0x83, 0x6c, 0xde, 0xa7, 0x26, 0x8c, + 0xe8, 0xb0, 0x12, 0x45, 0xa1, 0x4f, 0x38, 0xc0, 0xf5, 0x5b, 0xbd, 0x59, 0x59, 0x11, 0x2c, 0x52, 0x99, 0xc9, 0xe8, + 0x29, 0xdd, 0x46, 0x9b, 0x88, 0x96, 0x5e, 0x44, 0x3a, 0xff, 0x86, 0xa3, 0x1b, 0xe6, 0xfc, 0xf5, 0x1e, 0x39, 0x7a, + 0xe5, 0x3b, 0x92, 0x1e, 0x35, 0x06, 0xa5, 0x80, 0x80, 0x8e, 0xea, 0xca, 0xc9, 0xd8, 0x78, 0xa5, 0x8e, 0xac, 0x3f, + 0xfd, 0xcb, 0x3d, 0xf0, 0x58, 0x09, 0xdf, 0x50, 0xa5, 0xeb, 0xe9, 0x35, 0x2a, 0xd4, 0x2c, 0x1d, 0x37, 0xb6, 0x9c, + 0x88, 0xbf, 0x54, 0xac, 0xfe, 0x63, 0x04, 0x70, 0x46, 0x76, 0x61, 0x6b, 0xcb, 0x3c, 0x58, 0x37, 0x3e, 0x67, 0x07, + 0x59, 0x2b, 0xb0, 0x84, 0xe3, 0x73, 0x72, 0x17, 0x34, 0xa4, 0x10, 0xab, 0x25, 0xa6, 0x6a, 0x7a, 0x89, 0x44, 0x59, + 0xb1, 0x65, 0x9f, 0x3f, 0x70, 0x2a, 0x23, 0x49, 0xaa, 0xdb, 0x69, 0x49, 0x6c, 0x26, 0x22, 0xdf, 0x92, 0x35, 0x9f, + 0xb1, 0x13, 0x44, 0xc7, 0xb8, 0x19, 0x82, 0x81, 0xfa, 0xbb, 0x27, 0xcb, 0x97, 0xe4, 0x90, 0xca, 0x6b, 0xc4, 0x0e, + 0x1c, 0xa1, 0xe6, 0x7f, 0x4d, 0x81, 0x4a, 0xa3, 0x59, 0x5c, 0xb8, 0x03, 0x65, 0xc4, 0xc0, 0xc9, 0x42, 0xae, 0x19, + 0x24, 0x22, 0x95, 0x68, 0x13, 0x5d, 0x42, 0xdb, 0x25, 0x52, 0x99, 0x72, 0x93, 0x1c, 0x97, 0xfb, 0x89, 0xba, 0xf4, + 0x75, 0xc3, 0xde, 0xff, 0xf0, 0xc7, 0x98, 0xb8, 0x8c, 0xec, 0x1c, 0x6f, 0xde, 0xe1, 0xe4, 0x15, 0x25, 0x39, 0x0f, + 0x9c, 0xe2, 0x7a, 0x58, 0x88, 0x02, 0xc0, 0x0c, 0x48, 0x79, 0xff, 0xaa, 0x70, 0xec, 0x8e, 0xd4, 0xcd, 0xe6, 0x8d, + 0xd0, 0xea, 0xfc, 0xf5, 0x5d, 0x34, 0xad, 0x9b, 0x63, 0x72, 0xbe, 0x0c, 0xd7, 0x16, 0x96, 0xc3, 0x81, 0xf4, 0x8c, + 0xa2, 0x27, 0x4d, 0x9b, 0x78, 0x68, 0xea, 0xc4, 0xaa, 0x99, 0x26, 0xe6, 0xcd, 0x3c, 0xb1, 0x68, 0x96, 0xf5, 0x3d, + 0xf9, 0xa3, 0x22, 0x86, 0xf6, 0x8a, 0x1f, 0xca, 0x4c, 0x8d, 0xc1, 0x5c, 0x50, 0x86, 0xda, 0x4f, 0xe9, 0x80, 0xed, + 0x09, 0xd5, 0x18, 0xf0, 0x1e, 0x2c, 0x50, 0x49, 0xe6, 0x16, 0xf7, 0x33, 0x91, 0xe9, 0x64, 0x66, 0xc4, 0x93, 0xe2, + 0x45, 0xac, 0x28, 0x94, 0x9e, 0xec, 0xd0, 0x58, 0xe8, 0x3f, 0xbe, 0x18, 0x9d, 0x5e, 0x67, 0xbc, 0x43, 0xfa, 0xfc, + 0x88, 0xe6, 0xc9, 0x51, 0x32, 0x9d, 0x96, 0x6d, 0x38, 0xe6, 0x71, 0xa6, 0x12, 0x4f, 0xbc, 0x00, 0x48, 0xc6, 0xd4, + 0xb6, 0x8d, 0x05, 0xae, 0xa9, 0x89, 0x10, 0x52, 0x66, 0xf8, 0x68, 0xd0, 0x3d, 0x1d, 0xb7, 0xd9, 0x46, 0x66, 0xc4, + 0x52, 0x40, 0x8a, 0x68, 0xdf, 0x23, 0xbe, 0xff, 0x3a, 0x68, 0x1e, 0xbe, 0x69, 0x23, 0x73, 0x9f, 0xa6, 0xb5, 0x60, + 0x00, 0x1e, 0xf4, 0x4a, 0x7f, 0xd9, 0x63, 0x38, 0x13, 0x91, 0x4f, 0x6c, 0x14, 0xb1, 0xfc, 0x46, 0x00, 0x30, 0x1f, + 0xd4, 0xe2, 0x30, 0x98, 0x8f, 0x36, 0xf6, 0xb3, 0xbf, 0x54, 0x28, 0x97, 0x93, 0xa8, 0xcc, 0x7f, 0xc9, 0x36, 0x6f, + 0xcc, 0xc2, 0x90, 0xd4, 0xf2, 0xd1, 0xc4, 0x04, 0x4c, 0x1b, 0x45, 0x4c, 0x01, 0x02, 0xdf, 0x10, 0x29, 0x1d, 0x3f, + 0xc4, 0x01, 0x83, 0xd0, 0xd3, 0xa6, 0x54, 0x31, 0xba, 0x1c, 0xb7, 0x43, 0x9a, 0x6d, 0xde, 0x16, 0xe7, 0xab, 0x56, + 0x7f, 0x63, 0x4c, 0x82, 0x69, 0x78, 0x25, 0x23, 0x05, 0xb0, 0xbf, 0xa8, 0x04, 0x16, 0xc7, 0x01, 0x8b, 0x03, 0xf4, + 0x2f, 0x42, 0x7c, 0x42, 0xce, 0x99, 0x39, 0xe8, 0x50, 0xad, 0xa4, 0xff, 0x33, 0x0f, 0x73, 0xff, 0xd4, 0xe3, 0x52, + 0x4f, 0xf5, 0x63, 0x64, 0x28, 0x7b, 0x4a, 0x83, 0xbc, 0x57, 0x52, 0x0e, 0x87, 0x69, 0xd2, 0xc5, 0xdf, 0xde, 0x9c, + 0x8b, 0xb6, 0x85, 0xb7, 0xda, 0xe9, 0x2d, 0xde, 0x18, 0xe3, 0x89, 0xe5, 0xa3, 0x85, 0x5d, 0xbd, 0x6b, 0xb5, 0xe3, + 0x92, 0x39, 0xd7, 0xf5, 0xfb, 0xd0, 0xbd, 0xf2, 0xec, 0x35, 0xa9, 0x9c, 0x2f, 0x7e, 0x28, 0x1e, 0x14, 0xe7, 0xf3, + 0x1f, 0x2a, 0xe3, 0xf2, 0x7c, 0xf5, 0xf0, 0x4c, 0xfb, 0xc5, 0x6c, 0xda, 0xf5, 0x07, 0x23, 0x17, 0xcb, 0xf8, 0x9c, + 0x3e, 0xda, 0xea, 0x02, 0x6b, 0xad, 0xf1, 0x34, 0xec, 0x73, 0x9a, 0x76, 0xe3, 0x4d, 0xb4, 0xab, 0x25, 0x33, 0xca, + 0xcc, 0x13, 0x86, 0x56, 0xb4, 0x47, 0x17, 0x8c, 0x18, 0x64, 0x7d, 0x88, 0x67, 0x03, 0xef, 0xf0, 0xb0, 0x20, 0x33, + 0xe7, 0xa0, 0x6a, 0xd9, 0xc6, 0x20, 0x77, 0x19, 0xcf, 0xe5, 0x77, 0x28, 0x5a, 0x50, 0x93, 0x81, 0x0d, 0xc2, 0xcc, + 0x9a, 0xfb, 0x2d, 0x62, 0x61, 0xaa, 0x45, 0x9e, 0xfa, 0x3d, 0x6f, 0x89, 0x3f, 0x70, 0xa1, 0x95, 0x43, 0x26, 0xeb, + 0x0e, 0x6c, 0x30, 0xbe, 0xdd, 0x95, 0x41, 0x77, 0xc5, 0xa4, 0x7a, 0xa5, 0x2c, 0xd1, 0x05, 0xa4, 0x4e, 0x27, 0xc0, + 0x68, 0xb2, 0x52, 0xaa, 0xd2, 0xf3, 0xcf, 0xd9, 0x79, 0x65, 0x6d, 0x84, 0x18, 0x55, 0x71, 0x48, 0x50, 0xac, 0xab, + 0x58, 0x68, 0x1e, 0x8f, 0x49, 0x42, 0x02, 0xd8, 0x06, 0xd7, 0xcd, 0x70, 0x22, 0x8f, 0x21, 0xfe, 0x69, 0x7f, 0x32, + 0x5f, 0x1c, 0x57, 0x26, 0xfb, 0x9b, 0xe0, 0x8c, 0x58, 0x0c, 0x41, 0xe0, 0x27, 0xfa, 0x3b, 0xe7, 0xdc, 0x92, 0x03, + 0xd5, 0x12, 0xb0, 0x8a, 0xb4, 0xca, 0x67, 0x5a, 0xc4, 0xf4, 0x15, 0x0f, 0x38, 0x82, 0xc8, 0x1d, 0xb9, 0xda, 0x2f, + 0x70, 0x6a, 0x6b, 0xd2, 0xf2, 0x6a, 0xb5, 0x7e, 0x1b, 0xad, 0xde, 0x2b, 0x42, 0x8b, 0x7c, 0x69, 0x69, 0x7b, 0x24, + 0x53, 0xb9, 0x1d, 0xec, 0x0e, 0x88, 0x49, 0x76, 0x9a, 0xc4, 0xfe, 0x46, 0x78, 0x23, 0xfd, 0xdf, 0x7e, 0xbd, 0x7d, + 0x6f, 0xdc, 0x07, 0x09, 0xdc, 0x0d, 0xb4, 0x19, 0x33, 0x80, 0x3e, 0xad, 0x22, 0x5d, 0xb4, 0x45, 0x31, 0xf6, 0x4d, + 0x72, 0xd1, 0xc5, 0xa8, 0x82, 0x8a, 0xcd, 0x96, 0xa4, 0x80, 0xca, 0x0a, 0x9b, 0x43, 0x85, 0xc9, 0x53, 0x41, 0x8e, + 0x19, 0x73, 0xf2, 0x51, 0x3c, 0x77, 0xed, 0x4b, 0xbd, 0x41, 0x21, 0x2a, 0x8e, 0xbb, 0x7a, 0xd3, 0x7a, 0xee, 0xbb, + 0x03, 0x9f, 0xfb, 0xc1, 0x7a, 0xe3, 0x71, 0xbb, 0x2e, 0xa6, 0xec, 0x4e, 0xf0, 0x54, 0xe5, 0x1a, 0xcc, 0xe4, 0xb0, + 0xaa, 0x53, 0x76, 0xad, 0xa1, 0xe8, 0xe6, 0x31, 0x17, 0xf2, 0xdc, 0x31, 0xed, 0xc9, 0x42, 0xe5, 0x54, 0x11, 0x36, + 0xbb, 0x72, 0xe1, 0x3f, 0xd7, 0x43, 0x14, 0xd7, 0x75, 0x71, 0x8c, 0xa7, 0x39, 0x3c, 0xb6, 0x13, 0xc9, 0xf8, 0x4d, + 0xc7, 0x7d, 0x80, 0x73, 0xb0, 0x4b, 0xad, 0x9c, 0x3e, 0xe8, 0x0c, 0xaa, 0xa0, 0xfc, 0x61, 0x3e, 0x0f, 0xec, 0x73, + 0x28, 0xff, 0xcf, 0x5b, 0x0f, 0x6c, 0x1c, 0xb9, 0xd8, 0x06, 0x8e, 0xf7, 0x2e, 0x70, 0xf6, 0xdd, 0x27, 0x6f, 0xaf, + 0x78, 0xf0, 0x42, 0xff, 0x22, 0xe4, 0xec, 0xde, 0xf0, 0xe1, 0x70, 0xba, 0x58, 0xc1, 0x99, 0x68, 0x2e, 0xde, 0xb9, + 0xc4, 0xee, 0xd7, 0x35, 0x85, 0xac, 0x93, 0x24, 0x54, 0xdd, 0x03, 0xb3, 0xcc, 0x37, 0x18, 0xd9, 0x44, 0x2b, 0x4e, + 0xea, 0x1a, 0x5d, 0x73, 0xc2, 0x9c, 0xe1, 0xeb, 0x47, 0x0e, 0x32, 0xdb, 0xa7, 0xfc, 0x79, 0x73, 0x84, 0x76, 0xa8, + 0xf1, 0x71, 0x6f, 0x45, 0x95, 0x1d, 0x0b, 0x36, 0x88, 0xfd, 0xc7, 0x72, 0xf2, 0xe7, 0x07, 0xa7, 0x42, 0xfb, 0x26, + 0x4c, 0x90, 0x3a, 0x00, 0x4d, 0x0d, 0x07, 0x4e, 0xf3, 0x8a, 0x9e, 0xc4, 0x11, 0x58, 0xc9, 0xc2, 0x9e, 0xb3, 0x20, + 0x06, 0x95, 0x41, 0x20, 0x37, 0x24, 0x23, 0x5d, 0xb5, 0xcd, 0x9d, 0x14, 0xbc, 0x9d, 0x31, 0x0b, 0xd4, 0xc4, 0x21, + 0xf9, 0xd7, 0x90, 0x7d, 0x7f, 0x96, 0x7e, 0x32, 0x40, 0x16, 0x9a, 0x6c, 0xd2, 0xc9, 0xcf, 0x52, 0x1a, 0xba, 0x8d, + 0x32, 0x76, 0xde, 0x1c, 0x83, 0x86, 0xc2, 0xf4, 0xdb, 0xbb, 0x01, 0x2f, 0xaa, 0xda, 0x82, 0x91, 0xb8, 0x7d, 0x52, + 0xc3, 0x1f, 0x8b, 0x1a, 0x49, 0x0c, 0x96, 0x3e, 0xaa, 0xbf, 0xf6, 0x30, 0xca, 0xcd, 0xb7, 0x49, 0xd3, 0x58, 0x90, + 0x15, 0x5c, 0xc6, 0x7e, 0x40, 0xc7, 0x33, 0x0a, 0x55, 0x52, 0xee, 0x94, 0x23, 0xef, 0x8f, 0x6c, 0xec, 0xdd, 0x06, + 0x92, 0xf7, 0xf3, 0xff, 0xe6, 0x1f, 0x71, 0x99, 0x44, 0x82, 0x07, 0x72, 0x45, 0x7c, 0x1f, 0x63, 0x8a, 0xd4, 0x0d, + 0xbb, 0x13, 0xd4, 0x5d, 0x0b, 0xa2, 0x4a, 0x85, 0x7d, 0x8a, 0xb0, 0xc6, 0x4b, 0xdf, 0xe2, 0x55, 0xdd, 0xc9, 0xd5, + 0x33, 0xb3, 0xc7, 0xde, 0x5b, 0xea, 0xd1, 0xa3, 0x8f, 0xdc, 0xe4, 0x7c, 0xb7, 0x77, 0x6e, 0x7e, 0x47, 0xaa, 0xba, + 0xee, 0xc3, 0xe7, 0xf1, 0xe7, 0x31, 0x5d, 0x5d, 0x35, 0xf2, 0xe8, 0x44, 0x09, 0x9e, 0x2f, 0xf9, 0x83, 0x0f, 0x71, + 0xf6, 0xf7, 0xe0, 0xd6, 0xde, 0xb0, 0xb2, 0xbc, 0x70, 0x53, 0x64, 0x67, 0x5f, 0x76, 0xdc, 0xab, 0x1d, 0x7b, 0xc3, + 0x78, 0xcb, 0xff, 0x62, 0x36, 0xb3, 0xee, 0x9b, 0x4a, 0x13, 0xe3, 0x3b, 0xfe, 0xa3, 0xd9, 0x2b, 0x88, 0xea, 0xf0, + 0x7d, 0xf6, 0x8f, 0x5b, 0x76, 0x1c, 0x9b, 0xee, 0xf9, 0xe3, 0xc9, 0xdb, 0x93, 0x81, 0xd6, 0x82, 0x6b, 0x4e, 0x2a, + 0xad, 0xc7, 0xd6, 0x5f, 0x45, 0x1a, 0x3d, 0x5d, 0x5d, 0x7d, 0x78, 0x79, 0x76, 0xb9, 0x36, 0x9a, 0x46, 0x5a, 0x9d, + 0xad, 0xbe, 0x4c, 0xf4, 0x50, 0xee, 0x6e, 0x92, 0xb9, 0xe3, 0x2d, 0xc8, 0x6c, 0x30, 0xaf, 0xea, 0x71, 0x5d, 0x43, + 0xf8, 0xb6, 0x9d, 0x34, 0x61, 0x7d, 0xcf, 0xbe, 0x3a, 0x1f, 0x88, 0x01, 0xbd, 0x7e, 0x38, 0x12, 0x3e, 0x75, 0xe7, + 0xac, 0xbb, 0xc6, 0x5c, 0x58, 0x02, 0xb3, 0x31, 0xd7, 0xbb, 0x5a, 0x21, 0x7b, 0xca, 0xb6, 0xb6, 0x9b, 0x4c, 0xb2, + 0x05, 0x5f, 0xcb, 0x7e, 0x7f, 0x88, 0xa3, 0x34, 0x43, 0x81, 0x7a, 0x9e, 0x37, 0x7f, 0x9d, 0x10, 0x8c, 0x1e, 0xf9, + 0x85, 0xa6, 0x72, 0xd0, 0xb3, 0x7a, 0x5f, 0xa6, 0x13, 0x4b, 0xce, 0x51, 0x9b, 0x06, 0x19, 0x5f, 0xe9, 0x28, 0x86, + 0x6d, 0xca, 0xfd, 0x6e, 0xb6, 0x33, 0xd1, 0x24, 0xd6, 0x90, 0xdc, 0xf6, 0xd3, 0xe3, 0x0a, 0xa9, 0xe8, 0x61, 0x4a, + 0xf0, 0x32, 0x9c, 0x80, 0xc3, 0x62, 0x20, 0x77, 0x3a, 0x6a, 0xf4, 0x12, 0x24, 0x0e, 0xca, 0x9b, 0x2e, 0xc4, 0x21, + 0x07, 0x3b, 0xc2, 0xe5, 0x13, 0x31, 0xda, 0x12, 0x42, 0xc7, 0xa8, 0x2a, 0xdc, 0x26, 0x84, 0xfd, 0xe1, 0x8e, 0xc2, + 0x4e, 0x8f, 0x34, 0xcc, 0x16, 0x1f, 0x70, 0x63, 0x84, 0x63, 0xd4, 0x0b, 0xdf, 0x26, 0xf9, 0xcd, 0xc0, 0xb8, 0x40, + 0x2d, 0xa5, 0x30, 0x32, 0x7b, 0xc9, 0x57, 0x60, 0xca, 0xd8, 0x4a, 0x24, 0xd9, 0x21, 0xad, 0x47, 0x2c, 0x72, 0x72, + 0x70, 0x03, 0x47, 0x22, 0x03, 0x80, 0x81, 0x1c, 0x1e, 0x0f, 0x2f, 0xb3, 0xfc, 0x6b, 0x3b, 0xfe, 0x0a, 0x40, 0x84, + 0xfc, 0xeb, 0x81, 0x40, 0xf4, 0x61, 0xe2, 0x2f, 0x47, 0x52, 0x2c, 0xca, 0x8d, 0x77, 0xfa, 0xd5, 0xf6, 0x01, 0x7f, + 0x31, 0xbe, 0x6b, 0x74, 0x73, 0x01, 0x1a, 0x58, 0x4a, 0x08, 0x90, 0xb3, 0x40, 0x3d, 0xf2, 0x8c, 0x24, 0x3d, 0x82, + 0x56, 0x2d, 0xfd, 0x74, 0xbf, 0x39, 0xb1, 0x40, 0xf1, 0x29, 0x67, 0xd6, 0x77, 0xc7, 0x0a, 0xf4, 0x17, 0x3f, 0x49, + 0xdd, 0x0b, 0xcc, 0x95, 0xee, 0x9f, 0xc1, 0x96, 0x74, 0x19, 0x20, 0x4c, 0x42, 0x7a, 0x3f, 0x13, 0x11, 0x01, 0xa4, + 0x84, 0x00, 0x9a, 0xf8, 0x7a, 0x28, 0x10, 0xd9, 0x1f, 0xec, 0xbc, 0x39, 0x62, 0x2b, 0x76, 0xe3, 0xd0, 0xea, 0xd0, + 0x88, 0xad, 0x87, 0x8b, 0x5b, 0x81, 0xbb, 0x29, 0x74, 0xd9, 0xed, 0xf8, 0x8e, 0x0d, 0x7f, 0xb8, 0xc1, 0x75, 0x1b, + 0xfa, 0x75, 0x27, 0xee, 0xb8, 0xff, 0x82, 0x57, 0x58, 0x8e, 0xce, 0xfb, 0x83, 0x87, 0xa7, 0xd3, 0xf2, 0x51, 0xf9, + 0x3c, 0xd5, 0x1a, 0xed, 0x1e, 0x58, 0x09, 0xe9, 0xf7, 0xf2, 0x5d, 0xab, 0xb7, 0xec, 0x6d, 0xdb, 0xfc, 0xa3, 0xa5, + 0x81, 0x81, 0xf6, 0x56, 0xbe, 0xf5, 0x21, 0xa3, 0xf2, 0xed, 0xd7, 0xa1, 0xfe, 0xf6, 0xcb, 0x29, 0xc2, 0x19, 0x5d, + 0x60, 0x57, 0x81, 0x5f, 0x99, 0xa2, 0xea, 0x55, 0xe1, 0x6b, 0x40, 0x80, 0xc1, 0x38, 0x6c, 0x78, 0x85, 0x99, 0xe4, + 0xea, 0x5c, 0x09, 0x5e, 0xc1, 0xea, 0x5f, 0x98, 0xce, 0x47, 0xb4, 0x12, 0x21, 0x63, 0x6b, 0x5f, 0x28, 0x08, 0x1b, + 0x4b, 0xe5, 0x52, 0x9f, 0xdb, 0xe7, 0x20, 0x34, 0x5c, 0x8d, 0x06, 0xff, 0x50, 0xe3, 0x04, 0x72, 0xb9, 0x59, 0xb8, + 0x89, 0x91, 0xe8, 0xc7, 0xd0, 0xc5, 0x66, 0xc6, 0x56, 0xdf, 0x6f, 0x85, 0xf5, 0xb7, 0xd9, 0xfa, 0x06, 0x02, 0x6f, + 0x4b, 0x54, 0x68, 0xe7, 0x03, 0x04, 0x78, 0xf9, 0x71, 0xb3, 0x48, 0x8a, 0xbd, 0x24, 0x34, 0xda, 0x24, 0x74, 0x6a, + 0x8d, 0x1e, 0x94, 0xf7, 0xd0, 0xd1, 0x4f, 0x5a, 0x8b, 0xf5, 0xe7, 0x84, 0xe3, 0x2c, 0x7f, 0x19, 0x4d, 0xb0, 0x51, + 0x02, 0x6a, 0x13, 0x8e, 0x62, 0x4b, 0x9f, 0xc1, 0x57, 0x68, 0xd8, 0x10, 0x81, 0xd8, 0x8e, 0x3f, 0xff, 0x0b, 0xdf, + 0xca, 0x25, 0x36, 0x4d, 0x32, 0xf2, 0x91, 0x0a, 0xd9, 0xc4, 0x32, 0x54, 0x5a, 0x46, 0x26, 0xac, 0x6c, 0xbb, 0x1b, + 0x14, 0xf1, 0x04, 0x46, 0x50, 0xb3, 0x49, 0xfc, 0xa1, 0x27, 0xf6, 0xff, 0xcd, 0x38, 0x35, 0x64, 0xbf, 0xfd, 0xc6, + 0x25, 0xda, 0x43, 0x7f, 0x1a, 0xd4, 0x64, 0xdc, 0x01, 0x9f, 0x43, 0xbe, 0x34, 0x39, 0x66, 0xc7, 0xd4, 0xbf, 0xec, + 0x61, 0xab, 0xb1, 0xe7, 0xf4, 0xe7, 0xdf, 0xae, 0x5b, 0x92, 0xec, 0xe9, 0x94, 0x87, 0xf1, 0x57, 0x62, 0x78, 0xf1, + 0x7c, 0xe6, 0x07, 0xc4, 0xa7, 0x6e, 0x27, 0x3a, 0x99, 0xa7, 0xe3, 0x1d, 0xdd, 0x84, 0x66, 0x8a, 0x2d, 0x98, 0xc6, + 0x49, 0xdf, 0xed, 0x37, 0xae, 0x47, 0x91, 0xce, 0x8a, 0x68, 0xdf, 0x61, 0xb8, 0x9e, 0xba, 0x48, 0xfe, 0x06, 0x4e, + 0x1d, 0xbe, 0x6b, 0xe6, 0x1d, 0x9f, 0xba, 0xc8, 0x74, 0x73, 0xa9, 0xfb, 0x34, 0x28, 0x80, 0xbd, 0x35, 0xf8, 0x1c, + 0x5c, 0xab, 0x6d, 0x83, 0xf7, 0xe0, 0x97, 0x34, 0xd1, 0xd7, 0xa8, 0x23, 0xb9, 0xb5, 0x6f, 0x2f, 0x47, 0x2d, 0x88, + 0xe8, 0x4b, 0x8c, 0x48, 0xfc, 0x7a, 0x55, 0x7b, 0x2a, 0x05, 0x55, 0xb9, 0x5e, 0x74, 0xd3, 0x0c, 0xa3, 0xc1, 0x64, + 0x80, 0x56, 0xb1, 0x09, 0x67, 0x46, 0x44, 0xab, 0xb7, 0x68, 0x36, 0xe4, 0xb6, 0xee, 0xab, 0x6c, 0xad, 0x25, 0x11, + 0x17, 0x69, 0xc3, 0x4f, 0x43, 0x6f, 0x07, 0x08, 0xc9, 0xa0, 0x24, 0xad, 0x11, 0x06, 0x06, 0xc5, 0xda, 0xc0, 0x87, + 0x8f, 0xaf, 0x43, 0x70, 0x7f, 0x15, 0x47, 0x3b, 0x41, 0x81, 0x46, 0x07, 0xf6, 0x66, 0x18, 0x41, 0x89, 0x42, 0x73, + 0xf4, 0x3b, 0x1c, 0xf5, 0x65, 0x46, 0x74, 0x2e, 0x3d, 0x47, 0x46, 0x55, 0xb7, 0xad, 0x2e, 0xa3, 0xd5, 0x1e, 0xd2, + 0xe5, 0x94, 0x04, 0x4a, 0x7e, 0x21, 0xc8, 0xf6, 0xe9, 0x7f, 0x02, 0xcf, 0xe4, 0x44, 0x56, 0xc5, 0x31, 0x62, 0x46, + 0x92, 0x80, 0x55, 0x94, 0x73, 0x98, 0x93, 0xa8, 0x87, 0x84, 0x0f, 0x43, 0xdf, 0x27, 0x05, 0xab, 0x35, 0xa4, 0xda, + 0x86, 0xea, 0x15, 0x20, 0x73, 0x40, 0x1c, 0x0e, 0x50, 0x52, 0x89, 0x03, 0xcc, 0xc6, 0x7a, 0x1a, 0x6e, 0xf8, 0x66, + 0xea, 0x62, 0xf4, 0xfa, 0x19, 0x86, 0xb4, 0xca, 0x18, 0xab, 0xa0, 0x56, 0x65, 0xd1, 0xdc, 0x01, 0x81, 0xc2, 0x28, + 0x4e, 0x11, 0xbf, 0x9b, 0x5a, 0x74, 0x93, 0x91, 0x64, 0x58, 0x99, 0x88, 0x14, 0xf1, 0xe1, 0xee, 0x78, 0xa4, 0x51, + 0x27, 0x97, 0x8e, 0x38, 0x57, 0x40, 0x98, 0x0f, 0x4d, 0x9d, 0xde, 0x38, 0x68, 0x62, 0xb0, 0x6d, 0x38, 0x32, 0xce, + 0x24, 0x95, 0xb8, 0x12, 0xec, 0x46, 0x24, 0x65, 0xc1, 0x92, 0x50, 0xc1, 0x7b, 0x09, 0xc0, 0xb2, 0x89, 0x90, 0x2c, + 0x26, 0x01, 0x4a, 0x36, 0x10, 0xb4, 0x0a, 0x48, 0x3b, 0xea, 0x1a, 0x37, 0xc3, 0x6b, 0x4d, 0x86, 0x9f, 0x9c, 0x82, + 0x34, 0x21, 0x8d, 0x65, 0xf7, 0x47, 0x3e, 0xb9, 0xea, 0x93, 0xf1, 0xe5, 0xd4, 0x46, 0x52, 0x85, 0x94, 0xdc, 0x05, + 0x0a, 0xf3, 0xb5, 0xf1, 0x9f, 0x6d, 0xcd, 0x8f, 0xfa, 0x03, 0x1e, 0xd4, 0x95, 0x20, 0x8d, 0xa5, 0x24, 0x4e, 0x39, + 0xec, 0x07, 0x8b, 0x43, 0x02, 0x1d, 0xc8, 0x5e, 0x71, 0xfe, 0xad, 0x72, 0xdc, 0x89, 0xe2, 0xb5, 0x82, 0x4e, 0x42, + 0x69, 0xfc, 0xbb, 0xaf, 0x4d, 0x2f, 0xf8, 0x86, 0x3f, 0xd3, 0x1f, 0x81, 0xbe, 0x09, 0x83, 0x36, 0x83, 0xdf, 0x51, + 0x58, 0xdb, 0x75, 0xe2, 0x15, 0xaa, 0x1c, 0x66, 0xa7, 0xe3, 0x2a, 0x10, 0x79, 0x63, 0x7b, 0x34, 0x6b, 0x2d, 0x25, + 0x48, 0x50, 0x59, 0xe5, 0x93, 0x3b, 0x3b, 0xe1, 0xe1, 0x21, 0xe4, 0x41, 0xa6, 0x7c, 0x7d, 0x57, 0x75, 0x91, 0xe7, + 0x0d, 0x94, 0x70, 0x6b, 0xfc, 0x90, 0x1a, 0x9c, 0x38, 0x88, 0xc8, 0xc3, 0x6a, 0x8a, 0xa0, 0x86, 0x99, 0xa9, 0xc9, + 0xcc, 0x0c, 0x4b, 0x73, 0xa0, 0x13, 0x19, 0xd3, 0xca, 0xe5, 0x25, 0x5f, 0x8f, 0x04, 0xca, 0x5c, 0x09, 0x61, 0x38, + 0xf6, 0x6d, 0xe1, 0xc1, 0x63, 0xd9, 0x70, 0xac, 0x7b, 0xa1, 0x9d, 0xe8, 0xf1, 0x76, 0x68, 0x13, 0x82, 0x73, 0x91, + 0x43, 0x26, 0x75, 0xa5, 0x2b, 0x12, 0x59, 0x86, 0x9b, 0x96, 0xaa, 0xca, 0x3d, 0x4a, 0xd4, 0x7d, 0x7a, 0x2c, 0xf9, + 0x26, 0xd7, 0x1b, 0x8a, 0x29, 0xd7, 0xac, 0x1f, 0x43, 0x8a, 0x3e, 0x4d, 0xa4, 0x77, 0x0a, 0x95, 0xa6, 0x62, 0xc5, + 0x8c, 0x8e, 0x04, 0x10, 0x70, 0x83, 0x25, 0x98, 0x55, 0x7f, 0x55, 0x28, 0x85, 0x62, 0xe6, 0x2d, 0x45, 0x7e, 0xa4, + 0x58, 0x03, 0xc9, 0x6e, 0xf8, 0x3f, 0x0e, 0xa9, 0x59, 0xcd, 0x3d, 0xcc, 0x93, 0xe1, 0x8c, 0xf9, 0xeb, 0x99, 0x21, + 0x00, 0x4b, 0xfd, 0xe0, 0x17, 0x0c, 0x24, 0x60, 0x10, 0xe5, 0x66, 0xe9, 0xf5, 0xf9, 0x59, 0x50, 0x94, 0x51, 0x1c, + 0x1a, 0x87, 0x68, 0x2e, 0x30, 0x28, 0xef, 0x96, 0xd8, 0x71, 0xeb, 0xc8, 0x1d, 0x82, 0xf7, 0x2a, 0x2e, 0xb0, 0x8d, + 0x4c, 0x3d, 0xeb, 0x72, 0x1f, 0x46, 0x17, 0xb3, 0xd6, 0x4e, 0xc6, 0xe4, 0x21, 0xa1, 0xd5, 0xac, 0x4f, 0x53, 0x94, + 0x1d, 0xd5, 0x0f, 0x0f, 0xe2, 0xc9, 0xa8, 0x79, 0x9e, 0xec, 0xdc, 0x6b, 0xbb, 0x2e, 0x6c, 0xb8, 0xa4, 0x85, 0x89, + 0xbe, 0xfe, 0x65, 0xe9, 0x68, 0xd4, 0x71, 0x90, 0x79, 0xf0, 0xd9, 0xc9, 0x2c, 0xc1, 0xe6, 0x83, 0x89, 0x56, 0x5f, + 0xc1, 0x6c, 0xb8, 0xc0, 0xad, 0x1f, 0x78, 0xf9, 0x6d, 0xfa, 0x55, 0x5e, 0xba, 0x79, 0xec, 0x87, 0x66, 0xe3, 0x9e, + 0x54, 0xaf, 0xe0, 0x16, 0xcb, 0x47, 0x23, 0x6d, 0xbd, 0xeb, 0x4d, 0x3d, 0xbc, 0xee, 0x1d, 0x71, 0x59, 0xc6, 0xa3, + 0xd6, 0x63, 0x81, 0x94, 0xd5, 0xfd, 0x8c, 0xad, 0x99, 0x1e, 0xd1, 0xbb, 0x4a, 0x8d, 0xf1, 0xc9, 0x42, 0x36, 0x26, + 0x70, 0x00, 0x85, 0xdf, 0xf9, 0x3a, 0xb4, 0x4f, 0x7e, 0xeb, 0x5b, 0x31, 0x7e, 0x55, 0x23, 0x09, 0x70, 0x64, 0x37, + 0xbc, 0xad, 0x6b, 0xd0, 0x9e, 0x4a, 0xda, 0x9d, 0xda, 0x7c, 0x64, 0x37, 0x1e, 0x4c, 0xd0, 0xa6, 0x1a, 0xab, 0xc9, + 0x62, 0x85, 0x8a, 0x67, 0xc9, 0x8b, 0x8b, 0x09, 0x19, 0x4d, 0x04, 0xb8, 0x21, 0xf3, 0xea, 0x98, 0xfe, 0x92, 0x7e, + 0xb8, 0xf8, 0x1f, 0x5f, 0x84, 0xcb, 0xf6, 0xb7, 0xc4, 0x3d, 0x57, 0xca, 0xb4, 0xbc, 0x47, 0x53, 0xc5, 0x18, 0x94, + 0xee, 0xea, 0xa3, 0x10, 0xcd, 0x47, 0x8b, 0x7b, 0xa0, 0x58, 0x2c, 0x46, 0x6d, 0xea, 0x0b, 0xbc, 0xd9, 0xca, 0x90, + 0x87, 0x77, 0x9e, 0xba, 0x80, 0xf2, 0x8e, 0x57, 0x6c, 0x4d, 0x28, 0x0b, 0x98, 0xe5, 0x0e, 0x46, 0x7c, 0x44, 0xef, + 0x30, 0xd4, 0xf9, 0x3b, 0x82, 0x20, 0x37, 0x00, 0xa6, 0xd5, 0xf8, 0xe0, 0xb5, 0xd6, 0x7f, 0x29, 0x47, 0x89, 0xbe, + 0x1e, 0x6c, 0xfd, 0x74, 0x9a, 0xd6, 0xa1, 0x7b, 0xd3, 0xad, 0x8a, 0x86, 0x5f, 0xd1, 0x50, 0x58, 0x83, 0x01, 0x53, + 0xc8, 0x5e, 0x62, 0x5b, 0x75, 0xb6, 0xca, 0x89, 0x11, 0xe8, 0x6b, 0x4f, 0xa9, 0x78, 0x32, 0x84, 0x58, 0xb4, 0x13, + 0x67, 0x2a, 0xa5, 0x25, 0x99, 0x17, 0x0d, 0x40, 0x9c, 0x0f, 0x4e, 0xfa, 0x24, 0xe9, 0x53, 0x44, 0xda, 0xa2, 0xa0, + 0x5a, 0xf2, 0x7a, 0x3a, 0x18, 0xc5, 0xd2, 0xee, 0xab, 0x23, 0xa7, 0x57, 0x4e, 0xc0, 0xc8, 0x49, 0xb8, 0x14, 0x8b, + 0x4e, 0x7e, 0x1c, 0xf0, 0xd6, 0xa2, 0x21, 0x79, 0xb4, 0xbe, 0x4f, 0x1d, 0x45, 0x97, 0x28, 0x8f, 0x5e, 0x7b, 0x54, + 0x4f, 0xfc, 0x54, 0xec, 0xa7, 0xc0, 0xa8, 0x76, 0xe7, 0xf8, 0x44, 0x0c, 0xa6, 0x03, 0xcc, 0x79, 0x51, 0xcb, 0x7d, + 0xb3, 0xf3, 0xb1, 0x72, 0x51, 0x9a, 0xca, 0x32, 0x9c, 0xe1, 0xbb, 0x27, 0x8b, 0xde, 0xef, 0xba, 0x6e, 0xf4, 0x56, + 0xf5, 0x7d, 0x84, 0xdc, 0xb1, 0xd8, 0x1c, 0x56, 0xd8, 0xca, 0xce, 0x5e, 0x53, 0xaf, 0xf2, 0x2d, 0xa1, 0x31, 0x62, + 0x0e, 0xee, 0xdb, 0x23, 0xf3, 0xcd, 0x47, 0x2f, 0xf1, 0x2d, 0xe1, 0x93, 0xa9, 0x93, 0x64, 0xc8, 0x1c, 0xd0, 0x7f, + 0x99, 0x93, 0x45, 0xe7, 0xba, 0x4c, 0x45, 0x1c, 0x4f, 0xa7, 0xc9, 0xfa, 0xb0, 0x99, 0x7f, 0x0c, 0x94, 0x8e, 0x4c, + 0x2d, 0x04, 0x79, 0xb7, 0x51, 0xfa, 0x2a, 0x4e, 0xfc, 0x22, 0x0b, 0x2d, 0xa0, 0x95, 0x59, 0x21, 0x2e, 0x3b, 0x29, + 0x8b, 0x4c, 0xf0, 0x1c, 0x44, 0x0a, 0x53, 0x1f, 0x39, 0x61, 0x39, 0xe7, 0xa0, 0x9d, 0x72, 0xc9, 0x88, 0xb2, 0xb9, + 0xfd, 0xe1, 0x36, 0x48, 0x87, 0x22, 0xeb, 0x63, 0x71, 0x08, 0x20, 0xa0, 0x6b, 0xc9, 0x38, 0x6a, 0xc8, 0x73, 0x79, + 0x74, 0x7a, 0xd2, 0x1b, 0xbf, 0xee, 0xbe, 0x2d, 0xa9, 0x92, 0x4c, 0xa1, 0x91, 0x26, 0x23, 0x36, 0xe8, 0x57, 0x64, + 0xcf, 0x16, 0xe5, 0x09}; // Backwards compatibility alias #define INDEX_GZ INDEX_BR diff --git a/esphome/components/web_server/server_index_v3.h b/esphome/components/web_server/server_index_v3.h index 37c80ddf96..2f85586737 100644 --- a/esphome/components/web_server/server_index_v3.h +++ b/esphome/components/web_server/server_index_v3.h @@ -10,7684 +10,2607 @@ namespace esphome::web_server { #ifdef USE_WEBSERVER_GZIP constexpr uint8_t INDEX_GZ[] PROGMEM = { - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xcc, 0xbd, 0x7b, 0x7f, 0x1a, 0xb9, 0xb2, 0x28, 0xfa, - 0xf7, 0x3d, 0x9f, 0xc2, 0xee, 0x9d, 0xf1, 0xb4, 0x8c, 0x68, 0x03, 0x36, 0x8e, 0xd3, 0x58, 0xe6, 0xe4, 0x39, 0xc9, - 0x3c, 0x92, 0x4c, 0x9c, 0x64, 0x26, 0xc3, 0xb0, 0x33, 0xa2, 0x11, 0xa0, 0xa4, 0x91, 0x98, 0x96, 0x88, 0xed, 0x01, - 0xbe, 0xfb, 0xfd, 0x95, 0x1e, 0xdd, 0x6a, 0x20, 0x59, 0x6b, 0x9d, 0x7b, 0xce, 0xfd, 0x9d, 0x3d, 0x7b, 0xc5, 0xb4, - 0xde, 0x2a, 0x95, 0x4a, 0x55, 0xa5, 0xaa, 0xd2, 0xe5, 0xe1, 0x58, 0x66, 0xfa, 0x6e, 0xc1, 0x0e, 0x66, 0x7a, 0x9e, - 0x5f, 0x5d, 0xba, 0x7f, 0x19, 0x1d, 0x5f, 0x5d, 0xe6, 0x5c, 0x7c, 0x3e, 0x28, 0x58, 0x4e, 0x78, 0x26, 0xc5, 0xc1, - 0xac, 0x60, 0x13, 0x32, 0xa6, 0x9a, 0xa6, 0x7c, 0x4e, 0xa7, 0xec, 0xe0, 0xe4, 0xea, 0x72, 0xce, 0x34, 0x3d, 0xc8, - 0x66, 0xb4, 0x50, 0x4c, 0x93, 0x77, 0x6f, 0x9f, 0x35, 0x2f, 0xae, 0x2e, 0x55, 0x56, 0xf0, 0x85, 0x3e, 0x80, 0x26, - 0xc9, 0x5c, 0x8e, 0x97, 0x39, 0xbb, 0x3a, 0x39, 0xb9, 0xb9, 0xb9, 0x49, 0x3e, 0xa9, 0xff, 0xf1, 0x85, 0x16, 0x07, - 0xbf, 0x16, 0xe4, 0xd5, 0xe8, 0x13, 0xcb, 0x74, 0x32, 0x66, 0x13, 0x2e, 0xd8, 0xeb, 0x42, 0x2e, 0x58, 0xa1, 0xef, - 0x7a, 0x90, 0xf9, 0x47, 0x41, 0x62, 0x8e, 0x35, 0x66, 0x88, 0x5c, 0xe9, 0x03, 0x2e, 0x0e, 0x78, 0xff, 0xd7, 0xc2, - 0xa4, 0xac, 0x98, 0x58, 0xce, 0x59, 0x41, 0x47, 0x39, 0x4b, 0x0f, 0x5b, 0x38, 0x93, 0x62, 0xc2, 0xa7, 0xcb, 0xf2, - 0xfb, 0xa6, 0xe0, 0xda, 0xff, 0xfe, 0x42, 0xf3, 0x25, 0x4b, 0xd9, 0x06, 0xa5, 0x7c, 0xa0, 0x87, 0x84, 0x99, 0x96, - 0x3f, 0x57, 0x0d, 0xc7, 0x7f, 0x98, 0x26, 0xef, 0x16, 0x4c, 0x4e, 0x0e, 0xf4, 0x21, 0x89, 0xd4, 0xdd, 0x7c, 0x24, - 0xf3, 0xa8, 0xaf, 0x1b, 0x51, 0x94, 0x42, 0x19, 0xcc, 0x50, 0x2f, 0x93, 0x42, 0xe9, 0x03, 0xc1, 0xc9, 0x0d, 0x17, - 0x63, 0x79, 0x83, 0x3f, 0x0b, 0x22, 0x78, 0x72, 0x3d, 0xa3, 0x63, 0x79, 0xf3, 0x46, 0x4a, 0x7d, 0x74, 0x14, 0xbb, - 0xef, 0xbb, 0xc7, 0xd7, 0xd7, 0x84, 0x90, 0x2f, 0x92, 0x8f, 0x0f, 0x5a, 0xeb, 0x75, 0x90, 0x9a, 0x08, 0xaa, 0xf9, - 0x17, 0x66, 0x2b, 0xa1, 0xa3, 0xa3, 0x88, 0x8e, 0xe5, 0x42, 0xb3, 0xf1, 0xb5, 0xbe, 0xcb, 0xd9, 0xf5, 0x8c, 0x31, - 0xad, 0x22, 0x2e, 0x0e, 0x9e, 0xc8, 0x6c, 0x39, 0x67, 0x42, 0x27, 0x8b, 0x42, 0x6a, 0x09, 0x03, 0x3b, 0x3a, 0x8a, - 0x0a, 0xb6, 0xc8, 0x69, 0xc6, 0x20, 0xff, 0xf1, 0xf5, 0x75, 0x55, 0xa3, 0x2a, 0x84, 0xaf, 0x05, 0xb9, 0x36, 0x43, - 0x8f, 0x11, 0xfe, 0x4d, 0x10, 0xc1, 0x6e, 0x0e, 0x7e, 0x63, 0xf4, 0xf3, 0x2f, 0x74, 0xd1, 0xcb, 0x72, 0xaa, 0xd4, - 0xc1, 0x4b, 0xb9, 0x32, 0xd3, 0x28, 0x96, 0x99, 0x96, 0x45, 0xac, 0x31, 0xc3, 0x02, 0xad, 0xf8, 0x24, 0xd6, 0x33, - 0xae, 0x92, 0x8f, 0xf7, 0x32, 0xa5, 0xde, 0x30, 0xb5, 0xcc, 0xf5, 0x3d, 0x72, 0xd8, 0xc2, 0xe2, 0x90, 0x90, 0x6b, - 0x81, 0xf4, 0xac, 0x90, 0x37, 0x07, 0x4f, 0x8b, 0x42, 0x16, 0x71, 0xf4, 0xf8, 0xfa, 0xda, 0x96, 0x38, 0xe0, 0xea, - 0x40, 0x48, 0x7d, 0x50, 0xb6, 0x07, 0xd0, 0x4e, 0x0e, 0xde, 0x29, 0x76, 0xf0, 0xd7, 0x52, 0x28, 0x3a, 0x61, 0x8f, - 0xaf, 0xaf, 0xff, 0x3a, 0x90, 0xc5, 0xc1, 0x5f, 0x99, 0x52, 0x7f, 0x1d, 0x70, 0xa1, 0x34, 0xa3, 0xe3, 0x24, 0x42, - 0x3d, 0xd3, 0x59, 0xa6, 0xd4, 0x5b, 0x76, 0xab, 0x89, 0xc6, 0xe6, 0x53, 0x13, 0xb6, 0x99, 0x32, 0x7d, 0xa0, 0xca, - 0x79, 0xc5, 0x68, 0x95, 0x33, 0x7d, 0xa0, 0x89, 0xc9, 0x97, 0x0e, 0xfe, 0xcc, 0x7e, 0xea, 0x1e, 0x9f, 0xc4, 0x9f, - 0xc5, 0xd1, 0x91, 0x2e, 0x01, 0x8d, 0x56, 0x6e, 0x85, 0x08, 0x3b, 0xf4, 0x69, 0x47, 0x47, 0x2c, 0xc9, 0x99, 0x98, - 0xea, 0x19, 0x21, 0xa4, 0xdd, 0x13, 0x47, 0x47, 0xb1, 0x26, 0xbf, 0x89, 0x64, 0xca, 0x74, 0xcc, 0x10, 0xc2, 0x55, - 0xed, 0xa3, 0xa3, 0xd8, 0x02, 0x41, 0x12, 0x6d, 0x00, 0x57, 0x83, 0x31, 0x4a, 0x1c, 0xf4, 0xaf, 0xef, 0x44, 0x16, - 0x87, 0xe3, 0x47, 0x58, 0x1c, 0x1d, 0xfd, 0x26, 0x12, 0x05, 0x2d, 0x62, 0x8d, 0xd0, 0xa6, 0x60, 0x7a, 0x59, 0x88, - 0x03, 0xbd, 0xd1, 0xf2, 0x5a, 0x17, 0x5c, 0x4c, 0x63, 0xb4, 0xf2, 0x69, 0x41, 0xc5, 0xcd, 0xc6, 0x0e, 0xf7, 0xc7, - 0x82, 0x70, 0x72, 0x05, 0x3d, 0xbe, 0x94, 0xb1, 0xc3, 0x41, 0x4e, 0x48, 0xa4, 0x4c, 0xdd, 0xa8, 0xcf, 0x53, 0xde, - 0x88, 0x22, 0x6c, 0x47, 0x89, 0xaf, 0x05, 0xc2, 0x42, 0x03, 0xea, 0x26, 0x49, 0xa2, 0x11, 0xb9, 0x5a, 0x79, 0xb0, - 0xf0, 0x60, 0xa2, 0x7d, 0x3e, 0x68, 0x0d, 0x53, 0x9d, 0x14, 0x6c, 0xbc, 0xcc, 0x58, 0x1c, 0x0b, 0xac, 0xb0, 0x44, - 0xe4, 0x4a, 0x34, 0xe2, 0x82, 0x5c, 0xc1, 0x7a, 0x17, 0xf5, 0xc5, 0x26, 0xe4, 0xb0, 0x85, 0xdc, 0x20, 0x0b, 0x3f, - 0x42, 0x00, 0xb1, 0x1b, 0x50, 0x41, 0x48, 0x24, 0x96, 0xf3, 0x11, 0x2b, 0xa2, 0xb2, 0x58, 0xaf, 0x86, 0x17, 0x4b, - 0xc5, 0x0e, 0x32, 0xa5, 0x0e, 0x26, 0x4b, 0x91, 0x69, 0x2e, 0xc5, 0x41, 0xd4, 0x28, 0x1a, 0x91, 0xc5, 0x87, 0x12, - 0x1d, 0x22, 0xb4, 0x41, 0xb1, 0x42, 0x0d, 0x3e, 0x90, 0x8d, 0xf6, 0x10, 0xc3, 0x28, 0x51, 0xcf, 0xb5, 0xe7, 0x20, - 0xc0, 0x30, 0x87, 0x49, 0x6e, 0xb0, 0xa6, 0x66, 0x83, 0xc2, 0x14, 0x3f, 0x8b, 0x3e, 0x4f, 0x76, 0x77, 0x0a, 0xd1, - 0xc9, 0x9c, 0x2e, 0x62, 0x46, 0xae, 0x98, 0xc1, 0x2e, 0x2a, 0x32, 0x18, 0x6b, 0x6d, 0xe1, 0xfa, 0x2c, 0x65, 0x49, - 0x85, 0x53, 0x28, 0xd5, 0xc9, 0x44, 0x16, 0x4f, 0x69, 0x36, 0x83, 0x7a, 0x25, 0xc6, 0x8c, 0xfd, 0x86, 0xcb, 0x0a, - 0x46, 0x35, 0x7b, 0x9a, 0x33, 0xf8, 0x8a, 0x23, 0x53, 0x33, 0x42, 0x58, 0xc1, 0x56, 0xcf, 0xb9, 0x7e, 0x29, 0x45, - 0xc6, 0x7a, 0x2a, 0xc0, 0x2f, 0xb3, 0xf2, 0x0f, 0xb5, 0x2e, 0xf8, 0x68, 0xa9, 0x59, 0x1c, 0x09, 0x28, 0x11, 0x61, - 0x85, 0xb0, 0x48, 0x34, 0xbb, 0xd5, 0x8f, 0xa5, 0xd0, 0x4c, 0x68, 0xc2, 0x3c, 0x54, 0x31, 0x4f, 0xe8, 0x62, 0xc1, - 0xc4, 0xf8, 0xf1, 0x8c, 0xe7, 0xe3, 0x58, 0xa0, 0x0d, 0xda, 0xe0, 0x0f, 0x82, 0xc0, 0x24, 0xc9, 0x15, 0x4f, 0xe1, - 0x9f, 0xaf, 0x4f, 0x27, 0xd6, 0xe4, 0xca, 0x6c, 0x0b, 0x46, 0xa2, 0xa8, 0x37, 0x91, 0x45, 0xec, 0xa6, 0x70, 0x00, - 0xa4, 0x0b, 0xfa, 0x78, 0xb3, 0xcc, 0x99, 0x42, 0xac, 0x41, 0x44, 0xb9, 0x8e, 0x0e, 0xc2, 0x3f, 0x16, 0x31, 0x83, - 0x05, 0xe0, 0x28, 0xe5, 0x86, 0x04, 0xbe, 0xe1, 0x6e, 0x53, 0x8d, 0x4b, 0xa2, 0xf6, 0xb7, 0x20, 0x63, 0x9e, 0xe8, - 0x62, 0xa9, 0x34, 0x1b, 0xbf, 0xbd, 0x5b, 0x30, 0x85, 0x19, 0x25, 0x7f, 0x8b, 0xfe, 0xdf, 0x22, 0x61, 0xf3, 0x85, - 0xbe, 0xbb, 0x36, 0xd4, 0x3c, 0x8d, 0x22, 0xfc, 0xbb, 0x29, 0x5a, 0x30, 0x9a, 0x01, 0x49, 0x73, 0x20, 0x7b, 0x2d, - 0xf3, 0xbb, 0x09, 0xcf, 0xf3, 0xeb, 0xe5, 0x62, 0x21, 0x0b, 0x8d, 0x99, 0x20, 0x2b, 0x2d, 0x2b, 0xf8, 0xc0, 0x8a, - 0xae, 0xd4, 0x0d, 0xd7, 0xd9, 0x2c, 0xd6, 0x68, 0x95, 0x51, 0xc5, 0x0e, 0x1e, 0x49, 0x99, 0x33, 0x2a, 0x52, 0x4e, - 0x78, 0x9f, 0xd1, 0x54, 0x2c, 0xf3, 0xbc, 0x37, 0x2a, 0x18, 0xfd, 0xdc, 0x33, 0xd9, 0xf6, 0x70, 0x48, 0xcd, 0xef, - 0x87, 0x45, 0x41, 0xef, 0xa0, 0x20, 0x21, 0x50, 0xac, 0xcf, 0xd3, 0x1f, 0xaf, 0x5f, 0xbd, 0x4c, 0xec, 0x5e, 0xe1, - 0x93, 0xbb, 0x98, 0x97, 0xfb, 0x8f, 0x6f, 0xf0, 0xa4, 0x90, 0xf3, 0xad, 0xae, 0x2d, 0xe8, 0x78, 0xef, 0x2b, 0x43, - 0x60, 0x84, 0x1f, 0xda, 0xa6, 0xc3, 0x11, 0xbc, 0x34, 0x98, 0x0f, 0x99, 0xc4, 0xf5, 0x0b, 0xff, 0xa4, 0x36, 0x39, - 0xe6, 0xe8, 0xdb, 0xa3, 0xd5, 0xc5, 0xdd, 0x8a, 0x11, 0x33, 0xce, 0x05, 0x1c, 0x8c, 0x30, 0xc6, 0x8c, 0xea, 0x6c, - 0xb6, 0x62, 0xa6, 0xb1, 0x8d, 0x1f, 0x31, 0xdb, 0x6c, 0xf0, 0x3f, 0xd2, 0x63, 0xbd, 0x3e, 0x24, 0x84, 0x1b, 0x7a, - 0x45, 0xf4, 0x7a, 0xcd, 0x09, 0xe1, 0x08, 0x3f, 0xe3, 0x64, 0x45, 0xfd, 0x84, 0xe0, 0x64, 0x83, 0xed, 0x99, 0x5a, - 0x2a, 0x03, 0x27, 0xe0, 0x17, 0x56, 0x68, 0x18, 0xa8, 0xc0, 0x05, 0x9b, 0xe4, 0x30, 0x8e, 0xc3, 0x36, 0x9e, 0x51, - 0xf5, 0x78, 0x46, 0xc5, 0x94, 0x8d, 0xd3, 0x7f, 0xe4, 0x06, 0x0b, 0x41, 0xa2, 0x09, 0x17, 0x34, 0xe7, 0xff, 0xb0, - 0x71, 0xe4, 0xce, 0x85, 0xf7, 0xfa, 0x80, 0xdd, 0x6a, 0x26, 0xc6, 0xea, 0xe0, 0xf9, 0xdb, 0x5f, 0x7e, 0x76, 0x8b, - 0x59, 0x3b, 0x2b, 0xd0, 0x4a, 0x2d, 0x17, 0xac, 0x88, 0x11, 0x76, 0x67, 0xc5, 0x53, 0x6e, 0xe8, 0xe4, 0x2f, 0x74, - 0x61, 0x53, 0xb8, 0x7a, 0xb7, 0x18, 0x53, 0xcd, 0x5e, 0x33, 0x31, 0xe6, 0x62, 0x4a, 0x0e, 0xdb, 0x36, 0x7d, 0x46, - 0x5d, 0xc6, 0xb8, 0x4c, 0xfa, 0x78, 0xef, 0x69, 0x6e, 0xe6, 0x5e, 0x7e, 0x2e, 0x63, 0xb4, 0x51, 0x9a, 0x6a, 0x9e, - 0x1d, 0xd0, 0xf1, 0xf8, 0x85, 0xe0, 0x9a, 0x9b, 0x11, 0x16, 0xb0, 0x44, 0x80, 0xab, 0xcc, 0x9e, 0x1a, 0x7e, 0xe4, - 0x31, 0xc2, 0x71, 0xec, 0xce, 0x82, 0x19, 0x72, 0x6b, 0x76, 0x74, 0x54, 0x51, 0xfe, 0x3e, 0x4b, 0x6d, 0x26, 0x19, - 0x0c, 0x51, 0xb2, 0x58, 0x2a, 0x58, 0x6c, 0xdf, 0x05, 0x1c, 0x34, 0x72, 0xa4, 0x58, 0xf1, 0x85, 0x8d, 0x4b, 0x04, - 0x51, 0x31, 0x5a, 0x6d, 0xf5, 0xe1, 0xb6, 0x87, 0x26, 0x83, 0x61, 0x2f, 0x24, 0xe1, 0xcc, 0x21, 0xbb, 0xe5, 0x54, - 0x38, 0x53, 0x25, 0x51, 0x89, 0xe1, 0x40, 0x2d, 0x09, 0x8b, 0x22, 0x7e, 0x7e, 0x8b, 0x58, 0x00, 0x0f, 0x11, 0x52, - 0x0e, 0x7f, 0xe6, 0x3e, 0xfd, 0x62, 0x0e, 0x0f, 0x85, 0x05, 0xc2, 0xda, 0x8e, 0x54, 0x21, 0xb4, 0x41, 0x58, 0xfb, - 0xe1, 0x5a, 0xa2, 0xe4, 0xf9, 0x22, 0x38, 0xb5, 0xc9, 0x33, 0x6e, 0x8e, 0x6d, 0xa0, 0x6d, 0x54, 0xb3, 0xa3, 0xa3, - 0x98, 0x25, 0x25, 0x62, 0x90, 0xc3, 0xb6, 0x5b, 0xa4, 0x00, 0x5a, 0x5f, 0x19, 0x37, 0xf4, 0x6c, 0x18, 0x9c, 0x43, - 0x96, 0x08, 0xf9, 0x30, 0xcb, 0x98, 0x52, 0xb2, 0x38, 0x3a, 0x3a, 0x34, 0xe5, 0x4b, 0xce, 0x02, 0x16, 0xf1, 0xd5, - 0x8d, 0xa8, 0x86, 0x80, 0xaa, 0xd3, 0xd6, 0xf3, 0x4d, 0xa4, 0xe2, 0x9b, 0x3c, 0x13, 0x92, 0x46, 0x1f, 0x3f, 0x46, - 0x0d, 0x8d, 0x1d, 0x1c, 0xa6, 0xcc, 0x77, 0x7d, 0xf7, 0x84, 0x59, 0xb6, 0xd0, 0x30, 0x21, 0x3b, 0xa0, 0xd9, 0xcb, - 0x0f, 0xc6, 0xf5, 0x21, 0x61, 0x8d, 0x15, 0xda, 0x04, 0x2b, 0xba, 0xb7, 0x69, 0xc3, 0xdf, 0xd8, 0xa5, 0x5b, 0x4d, - 0x0d, 0x4f, 0x11, 0xac, 0xe3, 0x80, 0x0d, 0x37, 0xd8, 0xc0, 0xde, 0xcf, 0x46, 0x9a, 0x81, 0x0e, 0xf4, 0xb0, 0xe7, - 0xf2, 0x89, 0xb2, 0x90, 0x2b, 0xd8, 0xdf, 0x4b, 0xa6, 0xb4, 0x45, 0xe4, 0x58, 0x63, 0x89, 0xe1, 0x8c, 0xda, 0x66, - 0x3a, 0x6b, 0x2c, 0xe9, 0xbe, 0xb1, 0xbd, 0x5a, 0xc0, 0xd9, 0xa8, 0x00, 0xa9, 0xbf, 0x8d, 0x4f, 0x30, 0x56, 0x8d, - 0xd6, 0xeb, 0x67, 0xdc, 0xb7, 0x52, 0xad, 0x65, 0xc9, 0xaf, 0x6d, 0x2d, 0x8a, 0x10, 0xc8, 0x1d, 0xce, 0x87, 0x6d, - 0x3b, 0x7e, 0x21, 0x86, 0xe4, 0xb0, 0x55, 0x62, 0xb1, 0x03, 0xab, 0x1d, 0x8f, 0x85, 0xe2, 0x2b, 0xdb, 0x14, 0x32, - 0x67, 0x7d, 0x0d, 0x5f, 0x92, 0xd9, 0x0e, 0xae, 0xce, 0xc8, 0x00, 0xb8, 0x8e, 0x64, 0x36, 0xfc, 0x1a, 0x3e, 0x79, - 0x8a, 0x10, 0xeb, 0xdd, 0xbc, 0x8a, 0x70, 0x7c, 0xa9, 0x13, 0x8e, 0xad, 0x69, 0x44, 0x8b, 0xb2, 0x4a, 0x54, 0xa2, - 0x99, 0xdb, 0xea, 0x55, 0x16, 0x16, 0x66, 0x30, 0xd5, 0x94, 0x82, 0x26, 0x5e, 0xd2, 0x39, 0x53, 0x31, 0x43, 0xf8, - 0x6b, 0x05, 0x2c, 0x7e, 0x42, 0x91, 0x61, 0x70, 0x86, 0x2a, 0x38, 0x43, 0x81, 0xdd, 0x05, 0x26, 0xad, 0xbe, 0xe5, - 0x14, 0x66, 0x03, 0x35, 0xac, 0x78, 0xbb, 0x60, 0xf2, 0xe6, 0x70, 0x76, 0x08, 0xee, 0xe1, 0x67, 0xd3, 0x2c, 0xd0, - 0x0c, 0x0b, 0xa1, 0x10, 0x3e, 0x6c, 0x6d, 0xaf, 0xa4, 0x2f, 0x55, 0xcd, 0x71, 0x30, 0x84, 0x75, 0x30, 0xc7, 0x46, - 0xc2, 0x95, 0xf9, 0x5b, 0xdb, 0x6a, 0x00, 0xb6, 0x6b, 0xc0, 0x8c, 0x64, 0x92, 0x53, 0x1d, 0xb7, 0x4f, 0x5a, 0xc0, - 0x98, 0x7e, 0x61, 0x70, 0xaa, 0x20, 0xb4, 0x3b, 0x15, 0x96, 0x2c, 0x85, 0x9a, 0xf1, 0x89, 0x8e, 0x3f, 0x08, 0x43, - 0x54, 0x58, 0xae, 0x18, 0x48, 0x38, 0x01, 0x7b, 0x6c, 0x08, 0xce, 0x07, 0x01, 0xfd, 0xf4, 0xca, 0x83, 0xc8, 0x8d, - 0xd4, 0x10, 0x2e, 0x20, 0x0f, 0x15, 0x6b, 0x5d, 0x91, 0x99, 0x92, 0x71, 0x03, 0xee, 0xb1, 0xdd, 0xb7, 0x2d, 0xa6, - 0x8e, 0x1a, 0x88, 0x80, 0x83, 0x15, 0x69, 0x48, 0x22, 0x5c, 0xa2, 0x4e, 0xb4, 0xfc, 0x59, 0xde, 0xb0, 0xe2, 0x31, - 0x85, 0xc1, 0xa7, 0xb6, 0xfa, 0xc6, 0x1e, 0x05, 0x86, 0xe2, 0xeb, 0x9e, 0xc7, 0x97, 0x8f, 0x66, 0xe2, 0xaf, 0x0b, - 0x39, 0xe7, 0x8a, 0x01, 0xdf, 0x66, 0xe1, 0x2f, 0x60, 0xa3, 0x99, 0x1d, 0x09, 0xc7, 0x0d, 0x2b, 0xf1, 0xeb, 0xe1, - 0xcf, 0x75, 0xfc, 0xfa, 0x78, 0xef, 0xe9, 0xd4, 0x53, 0xc0, 0xfa, 0x3e, 0x46, 0x38, 0x76, 0xe2, 0x45, 0x70, 0xd2, - 0x25, 0x33, 0xe4, 0x8e, 0xf9, 0xf5, 0x5a, 0x07, 0x62, 0x5c, 0x8d, 0x73, 0x64, 0x76, 0xdb, 0xa0, 0x0d, 0x1d, 0x8f, - 0x81, 0xc5, 0x2b, 0x64, 0x9e, 0x07, 0x87, 0x15, 0x16, 0xbd, 0xf2, 0x78, 0xfa, 0x78, 0xef, 0xe9, 0xf5, 0xb7, 0x4e, - 0x28, 0xc8, 0x0f, 0x0f, 0x29, 0x3f, 0x50, 0x31, 0x66, 0x05, 0xc8, 0x95, 0xc1, 0x6a, 0xb9, 0x73, 0xf6, 0xb1, 0x14, - 0x82, 0x65, 0x9a, 0x8d, 0x41, 0x68, 0x11, 0x44, 0x27, 0x33, 0xa9, 0x74, 0x99, 0x58, 0x8d, 0x5e, 0x84, 0x42, 0x68, - 0x92, 0xd1, 0x3c, 0x8f, 0xad, 0x80, 0x32, 0x97, 0x5f, 0xd8, 0x9e, 0x51, 0xf7, 0x6a, 0x43, 0x2e, 0x9b, 0x61, 0x41, - 0x33, 0x2c, 0x51, 0x8b, 0x9c, 0x67, 0xac, 0x3c, 0xbc, 0xae, 0x13, 0x2e, 0xc6, 0xec, 0x16, 0xe8, 0x08, 0xba, 0xba, - 0xba, 0x6a, 0xe1, 0x36, 0xda, 0x58, 0x80, 0xaf, 0x76, 0x00, 0xfb, 0x8d, 0x63, 0xd3, 0x0a, 0xe2, 0xab, 0x7d, 0xf4, - 0x80, 0xa1, 0xe0, 0xac, 0xe4, 0x5e, 0xd0, 0xb2, 0xe4, 0x19, 0xe1, 0x31, 0xcb, 0x99, 0x66, 0x9e, 0x9c, 0x03, 0x33, - 0x6d, 0xb7, 0xee, 0x9b, 0x12, 0x7e, 0x25, 0x3a, 0xf9, 0x5d, 0xe6, 0xd7, 0x5c, 0x95, 0xa2, 0x7b, 0xb5, 0x3c, 0x15, - 0xb4, 0xfb, 0xda, 0x2e, 0x0f, 0xd5, 0x9a, 0x66, 0x33, 0x2b, 0xb1, 0xc7, 0x3b, 0x53, 0xaa, 0xda, 0x70, 0xa4, 0xbd, - 0xdc, 0x44, 0x9a, 0xba, 0x61, 0xee, 0x03, 0xc1, 0xb5, 0x23, 0x0a, 0x0c, 0x84, 0x40, 0xbb, 0x6c, 0x8f, 0x69, 0x9e, - 0x8f, 0x68, 0xf6, 0xb9, 0x8e, 0xfd, 0x15, 0x1a, 0x90, 0x6d, 0x6a, 0x1c, 0x64, 0x05, 0x24, 0x2b, 0x9c, 0xb7, 0xa7, - 0xd2, 0xb5, 0x8d, 0x12, 0x1f, 0xb6, 0x2a, 0xb4, 0xaf, 0x2f, 0xf4, 0x57, 0xb1, 0xdd, 0x8c, 0x48, 0xb8, 0x99, 0xc5, - 0x40, 0x05, 0xfe, 0x25, 0xc6, 0x79, 0x7a, 0xe0, 0xf0, 0x0e, 0x04, 0x8f, 0xcd, 0xd6, 0x40, 0x34, 0x5a, 0x6d, 0xc6, - 0x5c, 0x7d, 0x1d, 0x02, 0xff, 0x5b, 0x46, 0xf9, 0x24, 0xe8, 0xe1, 0xdf, 0x1d, 0x68, 0x49, 0xe3, 0x1c, 0xe3, 0x5c, - 0x8e, 0xcc, 0x31, 0x14, 0x9e, 0xd0, 0xfc, 0x04, 0xcc, 0x8b, 0xc1, 0xf7, 0x57, 0x36, 0xcb, 0xf0, 0x65, 0x30, 0x0c, - 0xd5, 0x0b, 0x19, 0x8a, 0x1a, 0x0a, 0x38, 0xa2, 0x2a, 0xcc, 0x99, 0x2b, 0x6b, 0xa2, 0xa4, 0xe3, 0xda, 0xad, 0x38, - 0xee, 0x68, 0x6e, 0x41, 0xe2, 0x38, 0x56, 0x20, 0xcd, 0x79, 0xfe, 0xbe, 0x9a, 0x85, 0xda, 0x99, 0x85, 0x4a, 0x02, - 0x69, 0x0b, 0x55, 0xc8, 0x1c, 0x54, 0x4f, 0x99, 0x40, 0x61, 0x29, 0x60, 0x59, 0x13, 0xa0, 0xd0, 0xa8, 0x24, 0xb8, - 0x39, 0xd1, 0xb8, 0x70, 0xa2, 0x8e, 0xc3, 0x35, 0x20, 0x19, 0x55, 0x15, 0x89, 0xec, 0xe6, 0xa8, 0xc9, 0xbe, 0x12, - 0x17, 0x68, 0x8b, 0xbf, 0xdf, 0x6c, 0x1c, 0x94, 0x18, 0x72, 0xab, 0x53, 0x63, 0x8c, 0x03, 0xb0, 0x60, 0x49, 0x1c, - 0x33, 0x6c, 0x59, 0x9f, 0x6d, 0xe0, 0x94, 0xed, 0x1e, 0x12, 0x22, 0x2b, 0xd8, 0xd4, 0x98, 0x4a, 0xcf, 0x5d, 0x49, - 0x84, 0xa9, 0x67, 0x4b, 0x8b, 0x6a, 0xe2, 0x84, 0x44, 0x5e, 0x3b, 0x11, 0xf5, 0x57, 0x35, 0xe1, 0x30, 0x0d, 0x8a, - 0x6d, 0x52, 0x20, 0xaa, 0xc5, 0x3e, 0x78, 0xef, 0xc3, 0x9a, 0x5a, 0x3b, 0x01, 0xc4, 0x8b, 0x1a, 0xc4, 0x03, 0xd0, - 0x4a, 0x4b, 0xbc, 0xe4, 0x90, 0xd0, 0x7a, 0xe5, 0x98, 0xe1, 0xc2, 0x2e, 0xc4, 0x0e, 0x14, 0xb7, 0xd9, 0x4f, 0x83, - 0x85, 0x20, 0xcb, 0x2a, 0xe0, 0xef, 0xc2, 0x23, 0x22, 0x86, 0xc1, 0x8b, 0xf5, 0x7a, 0x07, 0xed, 0xf6, 0x72, 0xa1, - 0x28, 0xa9, 0xa4, 0xc3, 0xf5, 0xfa, 0x1f, 0x89, 0x62, 0xc7, 0xff, 0x62, 0x86, 0xfa, 0x9e, 0xe8, 0x3e, 0xfc, 0x19, - 0x4a, 0x19, 0x76, 0xb4, 0x4a, 0x29, 0x05, 0x87, 0x3a, 0xd6, 0xd6, 0x17, 0x4a, 0x07, 0x94, 0xfb, 0xf1, 0x0e, 0x01, - 0x33, 0x89, 0xee, 0xa4, 0xae, 0xa6, 0xfc, 0xd8, 0x35, 0x2d, 0x10, 0x42, 0xa9, 0x32, 0xb2, 0xcc, 0xe1, 0x3e, 0xf9, - 0xf2, 0xe8, 0x48, 0x05, 0x0d, 0x7d, 0x2c, 0x29, 0xc5, 0xa7, 0x18, 0x4e, 0x65, 0x75, 0x27, 0x0c, 0xfb, 0xf2, 0xc9, - 0x9f, 0x43, 0x3b, 0xd2, 0x69, 0xab, 0x07, 0x82, 0x39, 0xbd, 0xa1, 0x5c, 0x1f, 0x94, 0xad, 0x58, 0xc1, 0x3c, 0x66, - 0x68, 0xe5, 0xb8, 0x8d, 0xa4, 0x60, 0xc0, 0x3f, 0x02, 0x59, 0xf0, 0x5c, 0xb4, 0x45, 0xfc, 0x6c, 0xc6, 0x40, 0x95, - 0xed, 0x19, 0x89, 0x92, 0xea, 0x1f, 0xba, 0x83, 0xc4, 0x35, 0xbc, 0x7f, 0xec, 0x9b, 0xed, 0xea, 0x35, 0x69, 0x60, - 0xc1, 0x8a, 0x89, 0x2c, 0xe6, 0x3e, 0x6f, 0xb3, 0xf5, 0xed, 0x88, 0x23, 0x9f, 0xc4, 0x7b, 0xdb, 0x76, 0x22, 0x40, - 0x6f, 0x4b, 0xf6, 0xae, 0xa4, 0xf6, 0xda, 0x69, 0x5a, 0x1e, 0xc0, 0x56, 0x41, 0xe8, 0x31, 0x53, 0x85, 0x52, 0xbe, - 0x53, 0xaf, 0xf6, 0xac, 0xee, 0xe4, 0xb0, 0xdd, 0x2b, 0x25, 0x3f, 0x8f, 0x0d, 0x3d, 0xab, 0xe3, 0x70, 0xa7, 0xaa, - 0x5c, 0xe6, 0x63, 0x37, 0x58, 0x81, 0x30, 0x73, 0x78, 0x74, 0xc3, 0xf3, 0xbc, 0x4a, 0xfd, 0x4f, 0x48, 0xbb, 0x72, - 0xa4, 0x5d, 0x7a, 0xd2, 0x0e, 0xa4, 0x02, 0x48, 0xbb, 0x6d, 0xae, 0xaa, 0x2e, 0x77, 0xb6, 0xa7, 0xb4, 0x44, 0x5d, - 0x19, 0x71, 0x1a, 0xfa, 0x5b, 0xfa, 0x11, 0xa0, 0x92, 0xf9, 0xfa, 0x1c, 0x3b, 0x7d, 0x0c, 0x88, 0x81, 0x56, 0xa7, - 0xc9, 0x42, 0x4d, 0xc5, 0xe7, 0x18, 0x61, 0xb5, 0x61, 0x25, 0x66, 0x3f, 0x7c, 0x0a, 0x4a, 0xbb, 0x60, 0x3a, 0x70, - 0x8e, 0x99, 0xe4, 0xff, 0x88, 0x8f, 0xf2, 0xb3, 0x13, 0x6e, 0x76, 0xca, 0xcf, 0x0e, 0x68, 0x7d, 0x35, 0xbb, 0xf1, - 0xb7, 0xa9, 0xbd, 0x99, 0x9e, 0x28, 0xa7, 0x57, 0xad, 0xf7, 0x7a, 0x1d, 0x6f, 0xa5, 0x80, 0x46, 0xdf, 0x49, 0x29, - 0x45, 0xd9, 0x3a, 0xd0, 0x80, 0x10, 0x32, 0x90, 0xb0, 0xb1, 0x93, 0x2e, 0x4f, 0xb9, 0x9f, 0xff, 0x95, 0x9e, 0xc7, - 0x28, 0xee, 0x6d, 0xfd, 0xc7, 0x72, 0xbe, 0x00, 0x86, 0x6c, 0x0b, 0xa5, 0xa7, 0xcc, 0x75, 0x58, 0xe5, 0x6f, 0xf6, - 0xa4, 0xd5, 0xea, 0x98, 0xfd, 0x58, 0xc3, 0xa6, 0x52, 0x6a, 0x3e, 0x6c, 0x6d, 0x96, 0x65, 0x52, 0x49, 0x38, 0xf6, - 0xe9, 0x56, 0x1e, 0x6f, 0x6b, 0x66, 0x7c, 0xc6, 0xab, 0x58, 0x58, 0x3a, 0x2c, 0x80, 0xd6, 0x05, 0xe4, 0xc7, 0xa3, - 0x7b, 0xb8, 0xfe, 0x9b, 0x0a, 0x38, 0xab, 0xcd, 0x16, 0xf8, 0x56, 0x9b, 0xcd, 0x7b, 0xed, 0x24, 0x6d, 0xfc, 0x7e, - 0x8f, 0xdc, 0x5b, 0x42, 0xaf, 0xca, 0x74, 0x32, 0xe3, 0x60, 0x08, 0x69, 0x3b, 0x2c, 0x24, 0x59, 0xcd, 0xe5, 0x98, - 0xa5, 0x91, 0x5c, 0x30, 0x11, 0x6d, 0x40, 0xcf, 0xea, 0x10, 0xe0, 0x77, 0x11, 0xaf, 0xde, 0xd4, 0xf5, 0xad, 0xe9, - 0x7b, 0xbd, 0x01, 0x55, 0xd8, 0x1b, 0xbe, 0x47, 0x19, 0xfb, 0x9e, 0x15, 0xca, 0xf0, 0xa4, 0x25, 0x7b, 0xfb, 0x86, - 0x57, 0x07, 0xd4, 0x1b, 0x9e, 0x7e, 0xbd, 0x4a, 0x25, 0x90, 0x44, 0xed, 0xe4, 0x3c, 0x39, 0x8d, 0x90, 0xd1, 0x18, - 0xbf, 0xf4, 0x1a, 0xe3, 0x65, 0xa9, 0x31, 0x7e, 0xae, 0xc9, 0x72, 0x4b, 0x63, 0xfc, 0x93, 0x20, 0xcf, 0x75, 0xff, - 0xb9, 0xd7, 0xa6, 0xbf, 0x96, 0x39, 0xcf, 0xee, 0xe2, 0x28, 0xe7, 0xba, 0x09, 0xb7, 0x89, 0x11, 0x5e, 0xd9, 0x0c, - 0x50, 0x35, 0x1a, 0x7d, 0xf7, 0xc6, 0xcb, 0x7f, 0x58, 0x09, 0x12, 0xdd, 0xcb, 0xb9, 0xbe, 0x17, 0xe1, 0x99, 0x26, - 0x7f, 0xc1, 0xaf, 0x7b, 0xab, 0xf8, 0x17, 0xaa, 0x67, 0x49, 0x41, 0xc5, 0x58, 0xce, 0x63, 0xd4, 0x88, 0x22, 0x94, - 0x28, 0x23, 0x84, 0x3c, 0x40, 0x9b, 0x7b, 0x7f, 0xe1, 0x4f, 0x92, 0x44, 0xfd, 0xa8, 0x31, 0xd3, 0x98, 0x53, 0xf2, - 0xd7, 0xe5, 0xbd, 0xd5, 0x27, 0xb9, 0xb9, 0xfa, 0x0b, 0x3f, 0xd5, 0xa5, 0x5a, 0x1f, 0xdf, 0x32, 0x12, 0x23, 0x72, - 0xf5, 0xd4, 0x0f, 0xe9, 0xb1, 0x9c, 0x5b, 0x05, 0x7f, 0x84, 0xf0, 0x17, 0xd0, 0xeb, 0x5e, 0xf1, 0x8a, 0x08, 0xb9, - 0x3b, 0x98, 0x43, 0x12, 0x49, 0xa3, 0x3c, 0x88, 0x8e, 0x8e, 0x82, 0xb4, 0x92, 0x85, 0xc0, 0x8f, 0x24, 0xa9, 0x89, - 0xea, 0x58, 0x50, 0x68, 0xe9, 0x91, 0x8c, 0x39, 0xf2, 0xcd, 0xc4, 0x5e, 0x53, 0xed, 0x76, 0x2c, 0x1f, 0x58, 0xdd, - 0x43, 0xc2, 0x35, 0x2b, 0xa8, 0x96, 0xc5, 0x10, 0x85, 0x6c, 0x09, 0xfe, 0x87, 0x93, 0xbf, 0x06, 0x07, 0xff, 0xcf, - 0xff, 0xf8, 0x73, 0xf2, 0x67, 0x31, 0xfc, 0x0b, 0x0b, 0x46, 0x4e, 0x2e, 0xe3, 0x7e, 0x1a, 0x1f, 0x36, 0x9b, 0xeb, - 0x3f, 0x4f, 0x06, 0xff, 0x4d, 0x9b, 0xff, 0x3c, 0x6c, 0xfe, 0x31, 0x44, 0xeb, 0xf8, 0xcf, 0x93, 0xfe, 0xc0, 0x7d, - 0x0d, 0xfe, 0xfb, 0xea, 0x4f, 0x35, 0x3c, 0xb6, 0x89, 0xf7, 0x10, 0x3a, 0x99, 0xe2, 0x1f, 0x04, 0x39, 0x69, 0x36, - 0xaf, 0x4e, 0xa6, 0xf8, 0x57, 0x41, 0x4e, 0xe0, 0xef, 0x9d, 0x26, 0x6f, 0xd8, 0xf4, 0xe9, 0xed, 0x22, 0xfe, 0xeb, - 0x6a, 0x7d, 0x6f, 0xf5, 0x0f, 0xdf, 0x40, 0xbb, 0x83, 0xff, 0xfe, 0xf3, 0x4f, 0x15, 0x7d, 0x7f, 0x45, 0x4e, 0x86, - 0x0d, 0x14, 0x9b, 0xe4, 0x63, 0x62, 0xff, 0xc4, 0xfd, 0x74, 0xf0, 0xdf, 0x6e, 0x28, 0xd1, 0xf7, 0x7f, 0xfe, 0x75, - 0x79, 0x45, 0x86, 0xeb, 0x38, 0x5a, 0x7f, 0x8f, 0xd6, 0x08, 0xad, 0xef, 0xa1, 0xbf, 0x70, 0x34, 0x8d, 0x10, 0xfe, - 0x43, 0x90, 0x93, 0xef, 0x4f, 0xa6, 0xf8, 0x47, 0x41, 0x4e, 0xa2, 0x93, 0x29, 0x7e, 0x2f, 0xc9, 0xc9, 0x7f, 0xc7, - 0xfd, 0xd4, 0x2a, 0xe1, 0xd6, 0x46, 0xfd, 0xb1, 0x86, 0x9b, 0x10, 0x5a, 0x30, 0xba, 0xd6, 0x5c, 0xe7, 0x0c, 0xdd, - 0x3b, 0xe1, 0xf8, 0xb9, 0x04, 0x60, 0xc5, 0x1a, 0x94, 0x34, 0xe6, 0x12, 0x76, 0xf5, 0x11, 0x16, 0x1e, 0x30, 0xe8, - 0x5e, 0xca, 0xb1, 0xd5, 0x13, 0xa8, 0x54, 0xdb, 0xdb, 0x5b, 0x05, 0xd7, 0xb7, 0xf8, 0x9a, 0x3c, 0x97, 0x71, 0x1b, - 0x61, 0x45, 0xe1, 0x47, 0x07, 0xe1, 0x77, 0xda, 0x5d, 0x78, 0xc2, 0x36, 0xb7, 0x18, 0x26, 0xa4, 0xe5, 0x67, 0x22, - 0x84, 0x9f, 0xee, 0xc9, 0xd4, 0x33, 0x50, 0x3f, 0x20, 0xac, 0x55, 0x78, 0x3d, 0x8a, 0x1f, 0x6b, 0x52, 0x22, 0xc7, - 0xdb, 0x82, 0xb1, 0xdf, 0x68, 0xfe, 0x99, 0x15, 0xf1, 0x53, 0x8d, 0xdb, 0x9d, 0x07, 0xd8, 0xa8, 0xaa, 0x0f, 0xdb, - 0xa8, 0x57, 0xde, 0x6e, 0xbd, 0x93, 0xf6, 0x3e, 0x01, 0x4e, 0xe1, 0xba, 0xbe, 0x06, 0xd6, 0xfe, 0x90, 0xef, 0x28, - 0xb5, 0x0a, 0x7a, 0x13, 0xa1, 0xfa, 0x55, 0x2a, 0x17, 0x5f, 0x68, 0xce, 0xc7, 0x07, 0x9a, 0xcd, 0x17, 0x39, 0xd5, - 0xec, 0xc0, 0xcd, 0xf9, 0x80, 0x42, 0x43, 0x51, 0xc9, 0x53, 0xfc, 0x24, 0xaa, 0x4d, 0xfb, 0x93, 0x48, 0xaa, 0xbd, - 0x13, 0xc3, 0x7d, 0x96, 0xe3, 0x4b, 0x64, 0x75, 0x5d, 0xb6, 0x7d, 0x23, 0xd8, 0x6c, 0x83, 0xb2, 0x6c, 0x68, 0xce, - 0x6f, 0x85, 0xe1, 0x7e, 0x93, 0x90, 0x4e, 0x3f, 0xba, 0x54, 0x5f, 0xa6, 0x57, 0x11, 0xdc, 0xe4, 0x14, 0x44, 0x30, - 0xa3, 0x3c, 0x82, 0x12, 0x94, 0xb4, 0x7a, 0xf4, 0x92, 0xf5, 0x68, 0xa3, 0xe1, 0xd9, 0xec, 0x8c, 0xf0, 0x01, 0xb5, - 0xf5, 0x73, 0x3c, 0xc3, 0x63, 0xd2, 0x6c, 0xe3, 0x25, 0x69, 0x99, 0x2a, 0xbd, 0xe5, 0x65, 0xe6, 0xfa, 0x39, 0x3a, - 0x8a, 0x8b, 0x24, 0xa7, 0x4a, 0xbf, 0x00, 0x8d, 0x00, 0x59, 0xe2, 0x19, 0x29, 0x12, 0x76, 0xcb, 0xb2, 0x38, 0x43, - 0x78, 0xe6, 0x68, 0x10, 0xea, 0xa1, 0x25, 0x09, 0x8a, 0x81, 0x9c, 0x41, 0x04, 0xeb, 0xcf, 0x06, 0xed, 0x21, 0x21, - 0x24, 0x3a, 0x6c, 0x36, 0xa3, 0x7e, 0x41, 0x7e, 0x10, 0x29, 0xa4, 0x04, 0xec, 0x34, 0xf9, 0x15, 0x92, 0x3a, 0x41, - 0x52, 0xfc, 0x5e, 0x26, 0x9a, 0x29, 0x1d, 0x43, 0x32, 0x28, 0x09, 0x94, 0xc7, 0xf0, 0xe8, 0xf2, 0x24, 0x6a, 0x40, - 0xaa, 0x41, 0x51, 0x84, 0x0b, 0x72, 0xa7, 0x51, 0x3a, 0x1b, 0x9c, 0x0e, 0xc3, 0x33, 0xc2, 0xa6, 0x42, 0xff, 0x77, - 0xba, 0x3f, 0x1b, 0xb4, 0x4c, 0xff, 0x57, 0x51, 0x3f, 0x2e, 0x88, 0xb2, 0x6c, 0x5c, 0x5f, 0xa5, 0x82, 0x99, 0xf9, - 0xa2, 0xd4, 0x0d, 0xd0, 0xf5, 0x3d, 0x26, 0xcd, 0x4e, 0x1a, 0x8f, 0xc3, 0x99, 0x34, 0xa1, 0x43, 0x07, 0x0a, 0x9c, - 0x13, 0x28, 0x8f, 0x0b, 0x02, 0x9d, 0x56, 0xd5, 0xee, 0x74, 0xea, 0x12, 0xbe, 0x8f, 0xbe, 0xef, 0xff, 0x28, 0xd2, - 0x3f, 0x84, 0x1d, 0xc1, 0x8f, 0x62, 0xbd, 0x86, 0xbf, 0x7f, 0x88, 0x3e, 0x0c, 0xcb, 0xa4, 0xfd, 0xe0, 0xd2, 0x7e, - 0x85, 0x34, 0xc1, 0x52, 0x33, 0x60, 0xac, 0x4a, 0x7e, 0xcc, 0x2e, 0xce, 0x84, 0xd8, 0x19, 0x1c, 0x1d, 0xf1, 0x01, - 0x6d, 0xb4, 0x87, 0x70, 0x23, 0x50, 0x68, 0xf5, 0x1b, 0xd7, 0xb3, 0x38, 0x3a, 0xb9, 0x8a, 0x50, 0x3f, 0x3a, 0x80, - 0x55, 0xee, 0xc9, 0x06, 0x71, 0xb0, 0xce, 0x1a, 0x9c, 0xa6, 0xe3, 0x2b, 0xd2, 0xea, 0xc7, 0xc2, 0x12, 0xf9, 0x1c, - 0xe1, 0xcc, 0xd1, 0xd4, 0x16, 0x1e, 0xa3, 0x86, 0x12, 0x0d, 0xff, 0x3d, 0x46, 0x8d, 0x99, 0x6e, 0x4c, 0x50, 0x9a, - 0xc1, 0xdf, 0x78, 0x4c, 0x08, 0x69, 0x76, 0xca, 0x8a, 0xfe, 0xb0, 0xa4, 0x28, 0x9d, 0x78, 0xf5, 0xe8, 0xc0, 0x6c, - 0x0e, 0xd9, 0x88, 0xf9, 0x80, 0x0d, 0xd7, 0xeb, 0xe8, 0xb2, 0x7f, 0x15, 0xa1, 0x46, 0xec, 0xd1, 0xee, 0xc4, 0xe3, - 0x1d, 0x42, 0x58, 0x0c, 0x37, 0xee, 0x06, 0xea, 0x86, 0xd5, 0x6e, 0x9b, 0x56, 0xd5, 0xfe, 0x0f, 0xc8, 0x02, 0xdb, - 0x94, 0x72, 0x8f, 0xe5, 0x6f, 0x17, 0x30, 0x55, 0x8f, 0xdb, 0x92, 0xb4, 0x70, 0x41, 0xbc, 0xba, 0x9b, 0x12, 0x5d, - 0xe1, 0x7f, 0x46, 0xaa, 0xe2, 0x78, 0x90, 0xe3, 0xd9, 0x90, 0x48, 0x6a, 0xe4, 0x97, 0x9e, 0x57, 0xa6, 0xb3, 0x9c, - 0xdc, 0xb0, 0xad, 0xfb, 0xdf, 0x1c, 0xee, 0x64, 0x1e, 0xeb, 0x24, 0x5b, 0x16, 0x05, 0x13, 0xfa, 0xa5, 0x1c, 0x3b, - 0xc6, 0x8e, 0xe5, 0x20, 0x5b, 0xc1, 0xc5, 0x2e, 0x06, 0xae, 0xae, 0xe3, 0x77, 0xca, 0x78, 0x27, 0x7b, 0x49, 0xc6, - 0x96, 0xe1, 0x32, 0xd7, 0xbd, 0xbd, 0xa5, 0x13, 0xa5, 0x63, 0x84, 0xc7, 0xee, 0x1e, 0x38, 0x4e, 0x92, 0x64, 0x99, - 0x64, 0x90, 0x0d, 0x1d, 0x28, 0xb4, 0x31, 0xfb, 0x2a, 0x56, 0xe4, 0xb1, 0x4e, 0x04, 0xbb, 0x35, 0xdd, 0xc6, 0xa8, - 0x3a, 0xc4, 0xfd, 0x7e, 0xbb, 0xa4, 0x3d, 0x43, 0x80, 0x54, 0x22, 0xe4, 0x98, 0x01, 0x84, 0xe0, 0xee, 0xdf, 0x25, - 0xcd, 0xa8, 0x0a, 0x6f, 0xb6, 0xaa, 0x01, 0x0e, 0x42, 0x95, 0xf7, 0x12, 0xf4, 0xc4, 0x86, 0x3d, 0x2b, 0x0b, 0x5b, - 0xe5, 0x39, 0x42, 0x7c, 0x12, 0x2f, 0x13, 0xb8, 0x11, 0x34, 0x98, 0xa4, 0x04, 0x5a, 0xaf, 0x97, 0x21, 0x6e, 0xcd, - 0x2a, 0xc5, 0xf4, 0x84, 0xcc, 0x06, 0x45, 0xa3, 0x61, 0x94, 0xd7, 0x63, 0x8b, 0x17, 0x4b, 0x84, 0x27, 0xe5, 0x5e, - 0xf3, 0xe5, 0x16, 0xa4, 0xde, 0x55, 0x3c, 0xa9, 0x2b, 0x81, 0x1b, 0x4a, 0x20, 0xa3, 0x5f, 0xd4, 0xd0, 0x3a, 0x9e, - 0x92, 0x93, 0x78, 0x90, 0xf4, 0xff, 0xe7, 0x10, 0xf5, 0xe3, 0xe4, 0x18, 0x9d, 0x58, 0x5a, 0x32, 0x41, 0xbd, 0xcc, - 0xf6, 0xb1, 0x32, 0xb7, 0x9f, 0x6d, 0x6c, 0x14, 0x90, 0xa9, 0xc4, 0x82, 0xce, 0x59, 0x3a, 0x85, 0x5d, 0xef, 0x91, - 0x67, 0x81, 0x01, 0x99, 0xd2, 0xa9, 0xa3, 0x2d, 0x49, 0xd4, 0xa7, 0xb4, 0xfc, 0xea, 0x47, 0xfd, 0xbc, 0xfa, 0xfa, - 0x9f, 0x51, 0x7f, 0x46, 0xd3, 0xc7, 0x7c, 0xe3, 0x94, 0xe4, 0xb5, 0x3e, 0xce, 0x7d, 0x1f, 0x1b, 0xbb, 0x38, 0x01, - 0xf0, 0xc6, 0x68, 0x57, 0x3b, 0xb2, 0x44, 0x1b, 0x3e, 0x29, 0xa9, 0x93, 0x4a, 0x34, 0x9d, 0x02, 0x54, 0x83, 0x45, - 0x50, 0xa1, 0x6d, 0x40, 0x30, 0x65, 0xc0, 0x16, 0x8f, 0xb4, 0x00, 0xcd, 0xe5, 0x55, 0x0b, 0xad, 0x6a, 0x85, 0x1d, - 0x67, 0x55, 0xbf, 0x8b, 0x2f, 0x89, 0xf7, 0x04, 0xa8, 0xf2, 0xe5, 0xb2, 0x37, 0x69, 0x34, 0x90, 0xf2, 0xf8, 0x35, - 0x1e, 0x4c, 0x86, 0xf8, 0x16, 0x50, 0x08, 0xd7, 0x30, 0x0a, 0xd7, 0xe6, 0xd8, 0x71, 0x73, 0x6c, 0x34, 0xe4, 0x06, - 0xf5, 0x82, 0xca, 0x4b, 0x57, 0x79, 0xb3, 0xb1, 0x90, 0xd9, 0xc6, 0xb8, 0x0b, 0x64, 0x52, 0xc0, 0x10, 0x8c, 0x10, - 0xf2, 0x49, 0xa2, 0xbd, 0xcd, 0x42, 0xa3, 0x50, 0xdd, 0xec, 0x5e, 0xa0, 0xa8, 0xf6, 0xf4, 0x88, 0x01, 0x16, 0x50, - 0xb5, 0x54, 0x23, 0xcf, 0x34, 0x1e, 0x37, 0xda, 0x06, 0xdd, 0x9b, 0xed, 0x5e, 0xbd, 0xb1, 0xfb, 0x55, 0x63, 0x78, - 0xdc, 0x20, 0xb3, 0x6a, 0x87, 0x6f, 0x64, 0xa3, 0xb1, 0xa9, 0xdf, 0x97, 0xfa, 0x4d, 0x5c, 0xbb, 0xbf, 0x78, 0xba, - 0x63, 0xe2, 0xe1, 0x4f, 0xdf, 0xea, 0xbc, 0x15, 0x09, 0x17, 0x82, 0x15, 0x70, 0xc2, 0x12, 0x8d, 0xc5, 0x66, 0x53, - 0x9e, 0xfa, 0xbf, 0x69, 0x6b, 0x33, 0x46, 0x38, 0xd0, 0x21, 0x23, 0xb5, 0x61, 0x89, 0x0b, 0x4c, 0x0d, 0x15, 0x21, - 0x84, 0xbc, 0xd3, 0xde, 0x3c, 0x46, 0x1b, 0x92, 0x94, 0x91, 0xe0, 0xec, 0x8e, 0x15, 0x61, 0xc9, 0xc7, 0x7b, 0x8f, - 0xe5, 0x37, 0x45, 0xba, 0x81, 0x18, 0xa6, 0xa6, 0x58, 0xee, 0x08, 0x59, 0x4e, 0xbe, 0x80, 0x9c, 0x53, 0x5e, 0xb0, - 0x24, 0x86, 0x20, 0x3e, 0xe1, 0x05, 0x33, 0x8c, 0xfb, 0x3d, 0x2f, 0x37, 0x66, 0x75, 0x4e, 0x33, 0x0b, 0xb5, 0x3f, - 0x00, 0xcd, 0x1c, 0x94, 0x43, 0x92, 0xec, 0x14, 0xfb, 0x78, 0xef, 0xe1, 0xab, 0x7d, 0x32, 0xf4, 0x7a, 0xed, 0xa4, - 0xe7, 0x0c, 0x58, 0x1f, 0x9c, 0x57, 0x43, 0xcd, 0xdc, 0x8f, 0x34, 0xce, 0x0c, 0x13, 0x95, 0xc7, 0x1c, 0x90, 0xe9, - 0xe3, 0xbd, 0x87, 0x6f, 0x63, 0x6e, 0x74, 0x53, 0x08, 0x87, 0xf3, 0x8e, 0x0b, 0x12, 0x53, 0xc2, 0x90, 0x9d, 0x7c, - 0x49, 0xc7, 0x8a, 0xe0, 0x74, 0x4f, 0xa9, 0xc9, 0x04, 0xb1, 0x63, 0x20, 0x86, 0x24, 0x73, 0x20, 0x20, 0x19, 0xc2, - 0x59, 0x4d, 0xae, 0x23, 0x66, 0x0d, 0x4c, 0x67, 0xd7, 0xb0, 0x18, 0x89, 0x65, 0x0f, 0x11, 0xce, 0x4c, 0xb7, 0x7a, - 0x63, 0x8f, 0x93, 0x82, 0x6e, 0x1b, 0xba, 0x55, 0xf2, 0xec, 0x7b, 0x10, 0xbc, 0xfc, 0xc7, 0x4b, 0xd7, 0x76, 0x99, - 0xf0, 0xc4, 0x5b, 0xa4, 0x7d, 0xbc, 0xf7, 0xf0, 0x17, 0x67, 0x94, 0xb6, 0xa0, 0x9e, 0xfc, 0xef, 0xc8, 0xa8, 0x0f, - 0x7f, 0x49, 0xaa, 0x5c, 0x53, 0xf8, 0xe3, 0xbd, 0x87, 0xef, 0xf6, 0x15, 0x83, 0xf4, 0xcd, 0xb2, 0x52, 0x12, 0x98, - 0xf1, 0xad, 0x58, 0x9e, 0xae, 0xdc, 0x59, 0x91, 0x8a, 0x0d, 0x36, 0x27, 0x54, 0xaa, 0x36, 0xa5, 0x6e, 0xe5, 0x09, - 0x96, 0xc4, 0x5c, 0x25, 0xd5, 0x97, 0xcd, 0xa1, 0x31, 0x97, 0xe2, 0x3a, 0x93, 0x0b, 0xf6, 0x95, 0xfb, 0xa5, 0xa7, - 0x1a, 0x25, 0x7c, 0x0e, 0x86, 0x38, 0x66, 0xec, 0x02, 0x1f, 0xb6, 0x50, 0x6f, 0xeb, 0x3c, 0x93, 0x06, 0x51, 0x8b, - 0xfa, 0x61, 0x83, 0x29, 0x69, 0xe1, 0x8c, 0xb4, 0x70, 0x4e, 0xd4, 0xa0, 0x65, 0x4f, 0x8c, 0x5e, 0x5e, 0x36, 0x6d, - 0xcf, 0x1d, 0xd8, 0xee, 0xb9, 0xdd, 0xb7, 0xf6, 0x50, 0x9e, 0xf5, 0x72, 0xa3, 0xbf, 0x34, 0x07, 0xfd, 0xcc, 0xa0, - 0xc6, 0x0b, 0x16, 0x17, 0xb8, 0x30, 0x2d, 0x5f, 0xf3, 0x51, 0x0e, 0x76, 0x2a, 0x30, 0x33, 0xac, 0x51, 0x5a, 0x96, - 0x6d, 0xbb, 0xb2, 0x79, 0x62, 0xd6, 0xaa, 0xc0, 0x79, 0x02, 0xa4, 0x1c, 0xe7, 0xce, 0xae, 0x47, 0xed, 0x56, 0x39, - 0x3f, 0x3a, 0x8a, 0x6d, 0xa5, 0x31, 0x8d, 0x0b, 0x9f, 0x5f, 0xdd, 0x00, 0xbe, 0xb7, 0x54, 0x63, 0x86, 0xcc, 0x04, - 0x1a, 0x8d, 0x6c, 0xb8, 0xa1, 0x87, 0x84, 0xc4, 0x79, 0x1d, 0x8a, 0x7e, 0xf4, 0x86, 0x19, 0xdc, 0x02, 0x40, 0xa3, - 0x51, 0x5e, 0xf7, 0x6e, 0x41, 0xec, 0xa9, 0xc6, 0x72, 0xf3, 0x25, 0x2e, 0xad, 0x89, 0x5a, 0x3b, 0x76, 0x58, 0x7e, - 0x14, 0x48, 0x84, 0xb8, 0x2b, 0xfc, 0x7c, 0x82, 0xad, 0x21, 0xa0, 0xdc, 0x0b, 0x67, 0x03, 0x81, 0x8d, 0xd5, 0x96, - 0x2b, 0xe4, 0x49, 0x5b, 0x07, 0xa5, 0xbe, 0x10, 0x5c, 0x70, 0x41, 0xa1, 0xc6, 0xc6, 0x61, 0xf9, 0x0b, 0xb6, 0x6b, - 0xce, 0x89, 0x15, 0x72, 0xda, 0x32, 0x33, 0x0c, 0x03, 0xb0, 0x4e, 0x09, 0x98, 0xe7, 0xe4, 0xe9, 0xd7, 0x51, 0xff, - 0x61, 0x80, 0xfa, 0x8f, 0x08, 0x0b, 0xb6, 0x81, 0xd5, 0x95, 0x24, 0xd2, 0x29, 0x28, 0x94, 0xcf, 0x7a, 0xbc, 0x20, - 0xa0, 0x8d, 0xab, 0x43, 0xb5, 0x76, 0x45, 0xf9, 0x15, 0xca, 0x12, 0xee, 0x14, 0xa3, 0xcf, 0xc4, 0xfe, 0x3e, 0x39, - 0xae, 0x2e, 0xe8, 0xa0, 0xeb, 0x7d, 0xca, 0xc1, 0x90, 0x14, 0x3e, 0x7c, 0xf7, 0xed, 0xbb, 0xd5, 0xc7, 0x8b, 0xdd, - 0x1d, 0x1c, 0x98, 0x95, 0xc2, 0xac, 0x83, 0x0d, 0x5c, 0x37, 0x32, 0x85, 0xfe, 0xcb, 0x3b, 0xf1, 0x3a, 0x15, 0xda, - 0xda, 0x8c, 0xfe, 0x38, 0x84, 0xd1, 0xb6, 0xdb, 0xa6, 0x04, 0x0b, 0x9a, 0x05, 0xba, 0x64, 0x8d, 0x5b, 0x69, 0xf1, - 0x15, 0x32, 0xf2, 0xd0, 0x14, 0x60, 0x62, 0xbc, 0x3f, 0xfb, 0xd1, 0xc6, 0xe1, 0x89, 0x1d, 0x1a, 0x5a, 0x19, 0x42, - 0x68, 0xf1, 0x1e, 0x30, 0xc7, 0x1e, 0x11, 0x00, 0xa2, 0xa7, 0x06, 0x52, 0x15, 0xc8, 0xa2, 0xa8, 0x52, 0xe4, 0x3f, - 0x3f, 0x24, 0xe4, 0x69, 0xa5, 0xc8, 0x7c, 0x53, 0x19, 0x73, 0x01, 0x62, 0xa0, 0x14, 0x2e, 0x12, 0xca, 0x04, 0x7b, - 0x19, 0xfa, 0x4e, 0xfb, 0xf2, 0x46, 0xda, 0x4c, 0x2a, 0x6e, 0x3c, 0xb8, 0x29, 0x35, 0x2a, 0x3e, 0x9b, 0xef, 0x21, - 0xb1, 0x95, 0x7b, 0x0f, 0x72, 0x05, 0x35, 0x83, 0x84, 0xef, 0xb7, 0xa6, 0xb4, 0x6f, 0x77, 0xf3, 0x79, 0xdb, 0x22, - 0x66, 0x6b, 0x5d, 0x12, 0x2e, 0x14, 0x2b, 0xf4, 0x23, 0x36, 0x91, 0x05, 0xdc, 0x7f, 0x94, 0x60, 0x41, 0x9b, 0x7b, - 0x81, 0x0e, 0xd0, 0x4c, 0x30, 0xb8, 0x74, 0xd8, 0x9a, 0xa1, 0xf9, 0xf5, 0xd9, 0xdc, 0x81, 0x7f, 0xdc, 0xae, 0xf5, - 0xf4, 0xe8, 0xe8, 0x0b, 0xab, 0x00, 0xe5, 0x86, 0x69, 0x86, 0x11, 0x10, 0x2f, 0xcb, 0xe5, 0xb8, 0x9b, 0xe1, 0x7b, - 0x71, 0xa5, 0x32, 0xf0, 0x84, 0x23, 0x24, 0x42, 0xcf, 0x89, 0xde, 0x4c, 0xb7, 0xe9, 0xbd, 0xd3, 0x66, 0x88, 0x50, - 0xac, 0x01, 0x72, 0x0f, 0x72, 0xb9, 0x55, 0x32, 0xa9, 0xca, 0xd6, 0xb6, 0x1c, 0xc4, 0x63, 0x00, 0x57, 0x6c, 0x84, - 0x94, 0x00, 0x0d, 0xf7, 0x0b, 0x2d, 0xef, 0x24, 0xb0, 0xff, 0x58, 0x25, 0x20, 0xd2, 0xa2, 0xda, 0xc6, 0x45, 0x08, - 0x5b, 0x53, 0x9f, 0xc0, 0x38, 0xe1, 0xe1, 0xf3, 0x7d, 0x1a, 0x6a, 0x8f, 0xda, 0xcc, 0x9c, 0x41, 0x50, 0x42, 0xa2, - 0xb2, 0x42, 0xf2, 0x25, 0x16, 0x8e, 0x9b, 0xf3, 0xf7, 0x70, 0x40, 0x8a, 0x0b, 0x1a, 0xdb, 0xbb, 0x2d, 0x38, 0x3e, - 0x8a, 0x64, 0x19, 0xd7, 0xba, 0xee, 0x15, 0xa6, 0x1a, 0x76, 0xa0, 0xa3, 0x21, 0x9c, 0x0a, 0x73, 0x4f, 0xf8, 0xb8, - 0x22, 0xa9, 0xda, 0x59, 0x40, 0x79, 0x62, 0x58, 0x99, 0xa6, 0x04, 0xf3, 0xd7, 0xce, 0x7c, 0xad, 0x3c, 0x26, 0x98, - 0x19, 0xc6, 0x8d, 0x5d, 0x05, 0xb6, 0x01, 0x1c, 0x5b, 0x3d, 0x92, 0xc1, 0xa2, 0x7a, 0xa5, 0xb8, 0xe9, 0x34, 0x60, - 0x02, 0xde, 0x80, 0xf5, 0xcc, 0xf6, 0xd6, 0x7f, 0x6e, 0x0e, 0x46, 0x81, 0x55, 0x8d, 0xc0, 0x4b, 0x43, 0xe0, 0x11, - 0x30, 0x6e, 0xde, 0xb4, 0xbc, 0xef, 0x8c, 0x68, 0x84, 0x3f, 0xf1, 0x1c, 0x9e, 0x59, 0x96, 0x7b, 0xe7, 0x63, 0x6b, - 0x45, 0x52, 0x41, 0xc0, 0xb6, 0x08, 0x3b, 0x22, 0x2f, 0x11, 0x56, 0x8d, 0x46, 0x4f, 0x5d, 0xb2, 0x4a, 0xab, 0x52, - 0x0d, 0x53, 0xc0, 0x2d, 0x31, 0xe0, 0x7d, 0xed, 0x44, 0x05, 0x43, 0x02, 0x6f, 0xfd, 0xad, 0x40, 0x7d, 0xff, 0xf0, - 0x4d, 0x1c, 0xd2, 0xb7, 0xb0, 0x6c, 0x79, 0x11, 0x0b, 0x53, 0x8a, 0xab, 0x3b, 0x9c, 0xd7, 0xdf, 0x36, 0x1b, 0x81, - 0x71, 0x1f, 0xb6, 0x31, 0xd8, 0xb8, 0xa1, 0x9e, 0xb6, 0xa4, 0xa1, 0xdc, 0x84, 0x3d, 0x54, 0xd9, 0x3b, 0x86, 0x9d, - 0xf5, 0x74, 0x25, 0xed, 0x6a, 0xa2, 0x36, 0x1b, 0xc5, 0x2a, 0xa3, 0x81, 0x2d, 0xc3, 0x4e, 0x73, 0xcc, 0xec, 0x2a, - 0xf0, 0x1f, 0x2f, 0x88, 0xc6, 0x01, 0xb2, 0xbe, 0xfe, 0xda, 0x75, 0x4a, 0x35, 0x4c, 0xd8, 0xde, 0xee, 0x7c, 0x7c, - 0xcc, 0xf7, 0x9d, 0x8f, 0x58, 0xba, 0xad, 0x6f, 0xce, 0xc6, 0xf6, 0xbf, 0x71, 0x36, 0x3a, 0xb5, 0xbd, 0x3f, 0x1e, - 0x81, 0x3b, 0xa9, 0x1d, 0x8f, 0xf5, 0x35, 0x25, 0x12, 0x0b, 0xb7, 0x1c, 0x57, 0x9d, 0xf5, 0x5a, 0x0c, 0x5a, 0xa0, - 0x76, 0x8a, 0x22, 0xf8, 0xd9, 0xb6, 0x3f, 0x03, 0x92, 0x6c, 0x75, 0xc8, 0xb1, 0x28, 0x45, 0x19, 0x94, 0x80, 0x01, - 0x75, 0x6c, 0x6c, 0xbd, 0x0c, 0x62, 0x3b, 0x1c, 0x72, 0x58, 0x4e, 0x44, 0x79, 0x75, 0x05, 0x23, 0x36, 0xc7, 0x86, - 0x13, 0x30, 0xe3, 0xbd, 0x56, 0x85, 0x5e, 0xfc, 0xfc, 0xd7, 0xcc, 0x69, 0xed, 0x88, 0xb1, 0x9c, 0x44, 0xcd, 0x8a, - 0xc1, 0x8d, 0xc0, 0x31, 0x8c, 0x87, 0x46, 0x42, 0xad, 0x4e, 0x75, 0x54, 0x3b, 0x92, 0x70, 0x0b, 0xd4, 0x6e, 0x87, - 0xe6, 0x5c, 0x5a, 0xaf, 0xf7, 0x1e, 0x2c, 0xb8, 0x08, 0x70, 0xfb, 0x39, 0xd1, 0x35, 0x92, 0x42, 0x89, 0x93, 0xa0, - 0x70, 0x6e, 0x50, 0x55, 0x13, 0x39, 0x68, 0x0d, 0x81, 0x27, 0xed, 0x65, 0x97, 0xb2, 0x12, 0x92, 0xb3, 0x46, 0x03, - 0xe5, 0x65, 0xc7, 0x74, 0x20, 0x1a, 0xd9, 0x10, 0x33, 0x9c, 0x59, 0x81, 0x05, 0x4e, 0xaf, 0x38, 0xaf, 0xba, 0x1e, - 0x64, 0x43, 0x84, 0x8b, 0xf5, 0x3a, 0xb6, 0x43, 0xcb, 0xd1, 0x7a, 0x9d, 0x87, 0x43, 0x33, 0xf9, 0x50, 0xf1, 0x69, - 0x5f, 0x93, 0xa7, 0xe6, 0x3c, 0x7c, 0x0a, 0x83, 0x6c, 0x90, 0x38, 0x77, 0x2a, 0xc1, 0x1c, 0x34, 0x57, 0x0d, 0x39, - 0xc8, 0x1a, 0xed, 0x61, 0x40, 0xc3, 0x06, 0xd9, 0x90, 0xe4, 0x1b, 0xb0, 0x9c, 0x55, 0xee, 0xc0, 0xfc, 0x04, 0x07, - 0xdb, 0x27, 0x73, 0xce, 0xd8, 0x06, 0xc3, 0x35, 0xd9, 0x56, 0x19, 0x94, 0x78, 0xe5, 0x16, 0xd7, 0x97, 0xab, 0x19, - 0x58, 0x94, 0x85, 0xb0, 0xbb, 0x66, 0xee, 0x83, 0xf0, 0x5f, 0x62, 0x3b, 0xa5, 0xa5, 0x11, 0xf7, 0x16, 0xe2, 0x7b, - 0xdb, 0xed, 0x24, 0x49, 0x68, 0x31, 0x35, 0x57, 0x22, 0xfe, 0x86, 0xd7, 0xec, 0x81, 0x53, 0x37, 0xce, 0xa0, 0xe7, - 0x41, 0xd9, 0xd9, 0x90, 0xd8, 0xf1, 0x7b, 0x66, 0xc7, 0x3b, 0xae, 0x64, 0x74, 0xbf, 0x2e, 0xc2, 0x0e, 0x26, 0xff, - 0x5f, 0x1e, 0xcc, 0x99, 0x1b, 0x8c, 0x45, 0x93, 0x2d, 0xb8, 0x7d, 0x05, 0x1e, 0x19, 0xdd, 0x82, 0xdb, 0xd7, 0xe1, - 0xeb, 0xa1, 0x35, 0xfb, 0xea, 0x00, 0x03, 0x32, 0x61, 0x47, 0x5a, 0x25, 0x04, 0xc3, 0xec, 0x6e, 0x73, 0x64, 0x96, - 0xac, 0xc2, 0xe1, 0xaa, 0x49, 0x2c, 0xb6, 0xf6, 0x42, 0xc5, 0xa4, 0x06, 0x82, 0xb1, 0x48, 0x9f, 0xa2, 0x50, 0x69, - 0x50, 0x37, 0x8e, 0x01, 0xac, 0x72, 0xda, 0xfa, 0xa7, 0x47, 0x47, 0x20, 0x34, 0x00, 0x6b, 0x97, 0x64, 0x74, 0xa1, - 0x97, 0x05, 0xf0, 0x57, 0xca, 0xff, 0x86, 0x64, 0x70, 0x3b, 0x31, 0x69, 0xf0, 0x03, 0x12, 0x16, 0x54, 0x29, 0xfe, - 0xc5, 0xa6, 0xb9, 0xdf, 0xb8, 0x20, 0x1e, 0xa3, 0x95, 0xe5, 0x14, 0x25, 0xea, 0x49, 0x87, 0xae, 0x75, 0xc8, 0x3d, - 0xfd, 0xc2, 0x84, 0xfe, 0x99, 0x2b, 0xcd, 0x04, 0x00, 0xa0, 0x42, 0x3c, 0x98, 0x92, 0x42, 0xb0, 0x75, 0x6b, 0xb5, - 0xe8, 0x78, 0xfc, 0xcd, 0x2a, 0xba, 0xce, 0x16, 0xcd, 0xa8, 0x18, 0xe7, 0xb6, 0x93, 0xd0, 0x66, 0xd2, 0xdb, 0x89, - 0x96, 0x25, 0x43, 0x8b, 0x9d, 0x8a, 0xfd, 0x30, 0xb4, 0x3e, 0x16, 0xc4, 0x9f, 0x0b, 0xfe, 0x2c, 0xfd, 0x26, 0x1f, - 0x03, 0x57, 0xea, 0x5f, 0x59, 0x85, 0x70, 0x26, 0x58, 0x07, 0xe4, 0x35, 0xa9, 0x8f, 0xd3, 0xa3, 0xce, 0x78, 0x47, - 0xb9, 0x50, 0x1a, 0x85, 0x6d, 0x9d, 0x14, 0x06, 0x53, 0xce, 0xbf, 0x2e, 0x71, 0xfd, 0xe2, 0x8f, 0x11, 0x7f, 0x74, - 0x88, 0x7f, 0x97, 0x4a, 0xa3, 0x55, 0x89, 0x60, 0xc8, 0xef, 0x48, 0xa6, 0xe0, 0x2a, 0x36, 0xe7, 0xfa, 0xb9, 0x9e, - 0xe7, 0x5b, 0x9e, 0x38, 0x3d, 0xa6, 0x4a, 0xe8, 0xa8, 0xf8, 0x86, 0xe1, 0x17, 0x0c, 0xee, 0x8d, 0x5f, 0xf2, 0xa0, - 0xca, 0xee, 0x7d, 0xf1, 0xcb, 0xe0, 0xbe, 0xf8, 0x25, 0x4f, 0x77, 0x8b, 0x06, 0xf7, 0xc4, 0x9d, 0xe4, 0x22, 0x69, - 0x45, 0x9e, 0x8f, 0x5a, 0xd2, 0xca, 0xbf, 0xd2, 0x6e, 0x0d, 0x5c, 0xd9, 0xc4, 0x81, 0x71, 0x5e, 0x5d, 0x84, 0x62, - 0xce, 0x9c, 0xd1, 0x72, 0xf8, 0x5f, 0x5b, 0x27, 0x77, 0xf2, 0x48, 0x2b, 0x85, 0xbc, 0xa6, 0x85, 0xbe, 0x07, 0x1b, - 0xae, 0xd8, 0xf1, 0x01, 0xa4, 0x04, 0x94, 0x6d, 0xff, 0x5e, 0x17, 0x81, 0x38, 0xae, 0xac, 0xf3, 0x51, 0xd8, 0x3e, - 0x29, 0x4a, 0xae, 0xae, 0x2e, 0x84, 0xdc, 0x1a, 0x2d, 0x01, 0xc2, 0xd4, 0xbb, 0xe6, 0x31, 0x47, 0x93, 0x59, 0xba, - 0xda, 0x94, 0xaa, 0x83, 0xc2, 0x72, 0x75, 0x1c, 0xe1, 0x62, 0x63, 0x6e, 0xd0, 0x3f, 0x71, 0xfc, 0x88, 0x3b, 0x1a, - 0xf9, 0x63, 0x49, 0x81, 0xde, 0xef, 0xf7, 0xb5, 0xd9, 0x43, 0x22, 0xed, 0x1c, 0x4a, 0x4b, 0x01, 0xc0, 0x6a, 0x83, - 0xaf, 0x1b, 0x8f, 0x53, 0x4f, 0xa4, 0x9b, 0xcd, 0x57, 0x0d, 0x61, 0x31, 0x2b, 0x2d, 0x78, 0x4c, 0x37, 0x7b, 0x2c, - 0x47, 0xbd, 0x2c, 0xae, 0xcb, 0x3d, 0x56, 0xeb, 0x17, 0x7d, 0x05, 0x94, 0x95, 0x21, 0xda, 0x7a, 0x1d, 0xd7, 0xe1, - 0x4d, 0x44, 0x70, 0x0d, 0x82, 0xb0, 0x08, 0x0c, 0x38, 0x6a, 0x8c, 0xb7, 0xad, 0x13, 0xa3, 0x6d, 0xfb, 0x25, 0xcf, - 0xba, 0xd7, 0xc6, 0x11, 0x2a, 0x1a, 0x6c, 0xf5, 0x50, 0xf3, 0x80, 0xed, 0xec, 0xca, 0x8e, 0x02, 0x08, 0x2d, 0x4b, - 0xe3, 0xdc, 0xca, 0x8a, 0x76, 0x0f, 0x7c, 0xd1, 0x37, 0xcc, 0x73, 0x1d, 0xe8, 0x76, 0xf3, 0x03, 0xdb, 0xa6, 0x27, - 0xf2, 0x6b, 0xb6, 0x4d, 0x35, 0x4e, 0xf8, 0xb0, 0x85, 0xbe, 0x6d, 0x08, 0x6b, 0xfb, 0xda, 0x5f, 0xe4, 0x7f, 0xa1, - 0xbb, 0x36, 0xa0, 0xa7, 0x05, 0xb3, 0xa7, 0x31, 0xef, 0xf4, 0x66, 0xf3, 0x63, 0xe9, 0xbf, 0x60, 0x6c, 0x85, 0x7e, - 0xb4, 0xbb, 0xc0, 0x89, 0x95, 0xc6, 0x21, 0x38, 0xfe, 0xc4, 0xc9, 0x34, 0x97, 0x23, 0x9a, 0xbf, 0x85, 0x1e, 0xab, - 0xdc, 0xe7, 0x77, 0xe3, 0x82, 0x6a, 0xe6, 0x68, 0x4d, 0x35, 0x8a, 0x4f, 0x3c, 0x18, 0xc6, 0x27, 0x6e, 0x29, 0x77, - 0xd5, 0x02, 0x5e, 0xfd, 0x5c, 0x36, 0x91, 0xfe, 0xb8, 0xf1, 0xb4, 0x83, 0xab, 0xfd, 0xbd, 0x6c, 0x93, 0x34, 0x5e, - 0x92, 0x34, 0xae, 0xe2, 0xed, 0xa6, 0xe2, 0xf8, 0xd1, 0x57, 0x06, 0xbb, 0x4b, 0xe6, 0x1e, 0x05, 0x64, 0xee, 0x11, - 0x4f, 0xbf, 0x59, 0x2b, 0xa0, 0x78, 0xa7, 0xc9, 0xa9, 0xb1, 0x8c, 0xb1, 0xa3, 0x7e, 0xa3, 0xc1, 0xa0, 0x41, 0x93, - 0xab, 0xc0, 0xdb, 0xa1, 0x3a, 0xbd, 0xbc, 0xfd, 0x51, 0x9c, 0x2d, 0x95, 0x96, 0x73, 0xd7, 0xa8, 0x72, 0x3e, 0x4e, - 0x26, 0x13, 0x14, 0xd8, 0xe6, 0x0e, 0x3f, 0xad, 0xbb, 0x91, 0xad, 0x3e, 0x73, 0x31, 0x4e, 0x15, 0x76, 0x67, 0x8b, - 0x4a, 0xe5, 0x86, 0x78, 0x33, 0xe7, 0xdd, 0x3c, 0x3c, 0xe1, 0x82, 0xab, 0x19, 0x2b, 0xe2, 0x02, 0xad, 0xbe, 0xd6, - 0x59, 0x01, 0xb7, 0x39, 0xb6, 0x33, 0x3c, 0x29, 0x2d, 0x07, 0x74, 0x02, 0xad, 0x81, 0xce, 0x68, 0xce, 0xf4, 0x4c, - 0x8e, 0xc1, 0xf0, 0x25, 0x19, 0x97, 0xee, 0x54, 0x47, 0x47, 0x87, 0x71, 0x64, 0xf4, 0x17, 0xe0, 0x83, 0x1e, 0xe6, - 0xa0, 0xfe, 0x0a, 0x1c, 0x83, 0xaa, 0xae, 0x19, 0x5a, 0xb1, 0x6d, 0x1f, 0x1a, 0x9d, 0x7c, 0x66, 0x77, 0x98, 0xa3, - 0xcd, 0x26, 0xb5, 0xa3, 0x8e, 0x26, 0x9c, 0xe5, 0xe3, 0x08, 0x7f, 0x66, 0x77, 0x69, 0xe9, 0xb6, 0x6e, 0xbc, 0xac, - 0xcd, 0x22, 0x46, 0xf2, 0x46, 0x44, 0xb8, 0xea, 0x24, 0x5d, 0x6d, 0xb0, 0x2c, 0xf8, 0x14, 0x70, 0xf4, 0x27, 0x76, - 0x97, 0xba, 0xf6, 0x02, 0x57, 0x41, 0xb4, 0xf2, 0xa0, 0x4f, 0x82, 0xe4, 0x70, 0x19, 0x9c, 0xc0, 0x31, 0x30, 0x75, - 0x87, 0xa4, 0x56, 0xae, 0x12, 0x21, 0x11, 0xda, 0xfc, 0xbb, 0x53, 0xc1, 0x8b, 0xf0, 0x9c, 0xd3, 0x35, 0x8b, 0xdb, - 0xad, 0x4a, 0x0c, 0x2a, 0x54, 0x16, 0x24, 0x1f, 0x62, 0xee, 0x77, 0x9f, 0xf3, 0x7e, 0x08, 0x74, 0x66, 0x0b, 0xea, - 0x1a, 0x4d, 0x27, 0xe6, 0x17, 0xaa, 0xee, 0xa0, 0xe6, 0xba, 0xaa, 0x78, 0xf0, 0x21, 0x06, 0xc0, 0x83, 0xb5, 0x0c, - 0x35, 0x0e, 0xa1, 0x1b, 0x6f, 0xa6, 0x3a, 0xa5, 0x24, 0x5e, 0xf9, 0x39, 0xa4, 0x3c, 0x04, 0xa3, 0xde, 0x00, 0x1a, - 0x3a, 0x04, 0xb3, 0x96, 0x87, 0x7c, 0x12, 0x8b, 0x9d, 0x33, 0x54, 0x9a, 0x33, 0x34, 0x09, 0x40, 0xfe, 0x95, 0x33, - 0x93, 0x19, 0x68, 0x18, 0xde, 0xd2, 0x1c, 0x80, 0x6e, 0x75, 0x1d, 0x0e, 0x85, 0x2b, 0x5a, 0x3a, 0xef, 0xd9, 0x45, - 0x97, 0xb5, 0x61, 0xc5, 0xa6, 0x1d, 0xb4, 0x49, 0x61, 0x4a, 0xcc, 0x16, 0xd8, 0x78, 0xbd, 0x0f, 0xf7, 0x76, 0xb5, - 0x71, 0x91, 0xf8, 0x69, 0x11, 0x0f, 0x93, 0x98, 0xa2, 0x15, 0x8f, 0x29, 0x96, 0x60, 0x07, 0x59, 0x6c, 0xca, 0xf1, - 0xb3, 0x70, 0x39, 0x6a, 0x56, 0xd2, 0xfb, 0x1d, 0x0c, 0x81, 0xcb, 0xd7, 0x60, 0x1b, 0x8a, 0x79, 0x49, 0x58, 0x62, - 0xe3, 0xe9, 0x17, 0xac, 0xdb, 0xdc, 0x2e, 0x88, 0x5f, 0x81, 0x29, 0x8d, 0x57, 0xc1, 0x2c, 0x42, 0xa7, 0x72, 0xe7, - 0x70, 0xe8, 0xae, 0x09, 0x2b, 0xe3, 0xd5, 0x58, 0x91, 0xad, 0xa3, 0xe7, 0xdb, 0x36, 0x9e, 0x7f, 0x2f, 0x59, 0x71, - 0x77, 0xcd, 0xc0, 0xc6, 0x5a, 0x82, 0xbb, 0x71, 0xb5, 0x0c, 0x95, 0x81, 0x7c, 0x5f, 0x1a, 0xd6, 0x65, 0x83, 0xbf, - 0x19, 0x15, 0x63, 0x63, 0xee, 0x29, 0x03, 0x6d, 0x8d, 0xdd, 0x2e, 0xec, 0xab, 0xae, 0x9b, 0xac, 0x67, 0x62, 0x25, - 0x54, 0x90, 0x76, 0x77, 0x0b, 0xb8, 0x08, 0xfd, 0x61, 0x07, 0x6a, 0xb8, 0xad, 0xba, 0x81, 0x24, 0xb8, 0xf6, 0x93, - 0x5f, 0x9f, 0xea, 0x3e, 0x6b, 0xdd, 0xaf, 0x4f, 0xb5, 0x76, 0x59, 0x68, 0x0c, 0x89, 0xb0, 0xeb, 0xa7, 0xf4, 0x9f, - 0x16, 0x9b, 0x0d, 0xda, 0xc0, 0xf0, 0xde, 0xf3, 0x5e, 0x1c, 0xbf, 0xf7, 0x16, 0x8a, 0x09, 0x5c, 0xe4, 0x5e, 0xe7, - 0xd2, 0x13, 0xf2, 0x6a, 0x04, 0xef, 0xf9, 0xce, 0x10, 0xde, 0xf3, 0xc0, 0xe9, 0x15, 0xa4, 0xa6, 0xa9, 0x60, 0x63, - 0x4f, 0x3f, 0x91, 0x45, 0x42, 0xc3, 0xc7, 0xdd, 0xe3, 0x44, 0xe8, 0xbf, 0x52, 0xe0, 0xbf, 0xf0, 0x68, 0xa9, 0xb5, - 0x14, 0x98, 0x8b, 0xc5, 0x52, 0x63, 0x65, 0x46, 0xbf, 0x9a, 0x48, 0xa1, 0x9b, 0x13, 0x3a, 0xe7, 0xf9, 0x5d, 0xba, - 0xe4, 0xcd, 0xb9, 0x14, 0x52, 0x2d, 0x68, 0xc6, 0xb0, 0xba, 0x53, 0x9a, 0xcd, 0x9b, 0x4b, 0x8e, 0x9f, 0xb3, 0xfc, - 0x0b, 0xd3, 0x3c, 0xa3, 0xf8, 0x8d, 0x1c, 0x49, 0x2d, 0xf1, 0xab, 0xdb, 0xbb, 0x29, 0x13, 0xf8, 0xdd, 0x68, 0x29, - 0xf4, 0x12, 0x2b, 0x2a, 0x54, 0x53, 0xb1, 0x82, 0x4f, 0x7a, 0xcd, 0xe6, 0xa2, 0xe0, 0x73, 0x5a, 0xdc, 0x35, 0x33, - 0x99, 0xcb, 0x22, 0xfd, 0xaf, 0xd6, 0x29, 0x7d, 0x30, 0x39, 0xeb, 0xe9, 0x82, 0x0a, 0xc5, 0x61, 0x61, 0x52, 0x9a, - 0xe7, 0x07, 0xa7, 0xdd, 0xd6, 0x5c, 0x1d, 0xda, 0x0b, 0x3f, 0x2a, 0xf4, 0xe6, 0x2f, 0xfc, 0x9b, 0x84, 0x51, 0x26, - 0x23, 0x2d, 0xdc, 0x20, 0x57, 0xd9, 0xb2, 0x50, 0xb2, 0x48, 0x17, 0x92, 0x0b, 0xcd, 0x8a, 0xde, 0x48, 0x16, 0x63, - 0x56, 0x34, 0x0b, 0x3a, 0xe6, 0x4b, 0x95, 0x9e, 0x2d, 0x6e, 0x7b, 0xf5, 0x1e, 0x6c, 0x7e, 0x2a, 0xa4, 0x60, 0x3d, - 0xe0, 0x37, 0xa6, 0x85, 0x5c, 0x8a, 0xb1, 0x1b, 0xc6, 0x52, 0x28, 0xa6, 0x7b, 0x0b, 0x3a, 0x06, 0x3b, 0xe0, 0xf4, - 0x62, 0x71, 0xdb, 0x33, 0xb3, 0xbe, 0x61, 0x7c, 0x3a, 0xd3, 0x69, 0xb7, 0xd5, 0xb2, 0xdf, 0x8a, 0xff, 0xc3, 0xd2, - 0x76, 0x27, 0xe9, 0x74, 0x17, 0xb7, 0xc0, 0xc1, 0x6b, 0x56, 0x34, 0x01, 0x16, 0x50, 0xa9, 0x9d, 0xb4, 0x1e, 0x9c, - 0xde, 0x87, 0x0c, 0xb0, 0x71, 0x68, 0x9a, 0x09, 0x81, 0xb1, 0x7b, 0xba, 0x5c, 0x2c, 0x58, 0x01, 0x5e, 0xf4, 0xbd, - 0x39, 0x2d, 0xa6, 0x5c, 0x34, 0x0b, 0xd3, 0x68, 0xf3, 0x62, 0x71, 0xbb, 0x81, 0xf9, 0xa4, 0xd6, 0x6c, 0xd5, 0x4d, - 0xcb, 0x7d, 0xad, 0x82, 0x21, 0x9a, 0x98, 0x34, 0x69, 0x31, 0x1d, 0xd1, 0xb8, 0xdd, 0xb9, 0x8f, 0xfd, 0xff, 0x92, - 0x0e, 0x0a, 0xc0, 0xd6, 0x1c, 0x2f, 0x0b, 0x73, 0x8b, 0x9a, 0xb6, 0x95, 0x6d, 0x76, 0x26, 0xbf, 0xb0, 0xc2, 0xb7, - 0x6a, 0x3e, 0x56, 0x3b, 0xf3, 0xfe, 0x8f, 0x1a, 0xa5, 0xb6, 0xad, 0x17, 0xea, 0x1a, 0x68, 0xf4, 0x6e, 0x63, 0xff, - 0xd5, 0xb9, 0xa0, 0xf7, 0xcf, 0xba, 0x1e, 0xee, 0x93, 0xc9, 0xa4, 0x06, 0x74, 0x0f, 0xdd, 0x76, 0x6b, 0x71, 0x7b, - 0xd0, 0x69, 0x79, 0x18, 0x5b, 0x98, 0x9e, 0x2f, 0x6e, 0xf7, 0xac, 0x60, 0x80, 0x15, 0xdb, 0xbd, 0x1d, 0x24, 0xa7, - 0xea, 0x80, 0x51, 0xc5, 0x36, 0x7f, 0xe1, 0x11, 0x05, 0xdc, 0x30, 0x48, 0x3b, 0x30, 0x72, 0x2a, 0xac, 0xc0, 0x70, - 0x75, 0xc3, 0xc7, 0x7a, 0x96, 0xb6, 0x5b, 0xad, 0xef, 0x2a, 0x4c, 0xea, 0xcd, 0xec, 0x92, 0xb6, 0x0b, 0x36, 0xaf, - 0xe1, 0xd7, 0x47, 0x5a, 0xee, 0x82, 0xd5, 0x42, 0xba, 0x4e, 0x0b, 0x96, 0x9b, 0x28, 0x37, 0x1b, 0xb7, 0x15, 0xaa, - 0x16, 0x77, 0x07, 0xbb, 0x09, 0xfa, 0x2f, 0xc0, 0x6c, 0x73, 0x88, 0xbf, 0x32, 0xa2, 0x8c, 0xe6, 0x59, 0x0c, 0x8d, - 0x1c, 0x34, 0x0f, 0x4e, 0x0b, 0x36, 0x47, 0x7e, 0x50, 0xc9, 0xfd, 0x6e, 0xc1, 0xe6, 0x9b, 0xc4, 0x54, 0x5f, 0x19, - 0x34, 0xa2, 0x39, 0x9f, 0x8a, 0x34, 0x63, 0x80, 0xe2, 0x9b, 0x84, 0x09, 0xcd, 0xf5, 0x5d, 0xb3, 0x90, 0x37, 0xab, - 0x31, 0x57, 0x8b, 0x9c, 0xde, 0xa5, 0x93, 0x9c, 0xdd, 0xf6, 0x4c, 0xa9, 0x26, 0xd7, 0x6c, 0xae, 0x5c, 0xd9, 0x1e, - 0xa4, 0x37, 0xc7, 0xd6, 0xb4, 0x02, 0x66, 0x22, 0x6f, 0xb6, 0xf7, 0x98, 0x07, 0x60, 0x53, 0x2e, 0xf5, 0x41, 0x4b, - 0xf5, 0xe6, 0x5c, 0x34, 0xdd, 0x40, 0xce, 0x60, 0x75, 0x76, 0xa1, 0x10, 0xf4, 0x9f, 0xb0, 0xdb, 0x05, 0x15, 0x63, - 0x36, 0x5e, 0x05, 0xd5, 0x3a, 0x50, 0x2f, 0x2c, 0x95, 0x0a, 0x3d, 0x6b, 0x1a, 0x7b, 0xb0, 0xb8, 0x23, 0xd0, 0x57, - 0xd0, 0xef, 0x41, 0x0b, 0xdb, 0xff, 0x4f, 0xda, 0x28, 0xac, 0x7c, 0x00, 0xa1, 0x99, 0xf8, 0xe4, 0xae, 0x09, 0x7f, - 0x57, 0xe0, 0x7f, 0xc4, 0x33, 0x9a, 0x3b, 0x88, 0xcc, 0xf9, 0x78, 0x9c, 0xd7, 0x46, 0x74, 0x15, 0x74, 0xd6, 0x46, - 0x2b, 0x98, 0x7f, 0xda, 0x3a, 0x68, 0x1d, 0x98, 0xb9, 0x38, 0x94, 0x3c, 0x3b, 0xbb, 0x7f, 0xfa, 0x80, 0xf5, 0x72, - 0x2e, 0x58, 0x6d, 0xaa, 0xdf, 0x04, 0x75, 0xd8, 0x70, 0xc7, 0x35, 0xdc, 0x3e, 0x68, 0x1f, 0x9c, 0xb5, 0xbe, 0xf3, - 0x3b, 0x3a, 0x67, 0x13, 0x6d, 0x71, 0xb8, 0xb6, 0xc5, 0x2f, 0x7c, 0xd3, 0x37, 0x05, 0x5d, 0xa4, 0x42, 0xc2, 0x9f, - 0x1e, 0x6c, 0xc4, 0x49, 0x2e, 0x6f, 0xd2, 0x19, 0x1f, 0x8f, 0xc1, 0x9d, 0x0a, 0x0a, 0x94, 0x89, 0x2c, 0xcf, 0xf9, - 0x42, 0x71, 0xbb, 0x1a, 0x0e, 0xdd, 0xba, 0x5b, 0x50, 0x0d, 0x07, 0x74, 0x1a, 0x0c, 0xa8, 0x5b, 0x0d, 0xa8, 0xea, - 0x3f, 0x1c, 0x61, 0x67, 0x6b, 0xae, 0xa6, 0x54, 0xaf, 0x86, 0x49, 0x9f, 0x96, 0x4a, 0x03, 0xcc, 0xbd, 0x21, 0x87, - 0xa1, 0xf4, 0xcd, 0x11, 0xd3, 0x37, 0x8c, 0x89, 0xaf, 0x0f, 0xe2, 0x2a, 0x95, 0x22, 0xbf, 0xb3, 0x9f, 0xab, 0xb0, - 0x4b, 0xba, 0xd4, 0x72, 0x93, 0x8c, 0xb8, 0xa0, 0xc5, 0xdd, 0x47, 0xc5, 0x84, 0x92, 0xc5, 0x47, 0x39, 0x99, 0xac, - 0xbe, 0x46, 0x7e, 0xee, 0xa3, 0x4d, 0xa2, 0xb8, 0x98, 0xe6, 0xcc, 0x12, 0x1b, 0x83, 0x08, 0x8e, 0xe0, 0xdb, 0x76, - 0x4d, 0x93, 0xb5, 0x41, 0x6f, 0x92, 0x2c, 0xe7, 0x73, 0xaa, 0x99, 0x81, 0x73, 0xb8, 0x49, 0x5d, 0x0d, 0x43, 0x71, - 0x5a, 0x07, 0xf6, 0x4f, 0x55, 0x1a, 0xb6, 0x51, 0x50, 0xd8, 0x37, 0xc9, 0x85, 0xc1, 0x0f, 0x03, 0x0e, 0xb3, 0x8b, - 0xcc, 0xea, 0x99, 0xb5, 0x0b, 0x60, 0x07, 0xb3, 0xab, 0x35, 0x75, 0x55, 0xa3, 0x11, 0xdd, 0xd6, 0x77, 0xf5, 0xdc, - 0x9c, 0x8e, 0x58, 0xbe, 0xb2, 0x1b, 0xd5, 0x03, 0xd7, 0x6d, 0xd5, 0x70, 0x99, 0x03, 0x92, 0x61, 0x40, 0x34, 0x4c, - 0xd3, 0xe6, 0x0d, 0x1b, 0x7d, 0xe6, 0xda, 0x6e, 0x99, 0xa6, 0xba, 0x01, 0x07, 0x1f, 0x33, 0xa6, 0x05, 0x2b, 0x56, - 0x9e, 0xa8, 0xb6, 0x6a, 0xc4, 0xec, 0x17, 0x61, 0x0e, 0x4b, 0x4d, 0x47, 0x4d, 0x08, 0x77, 0xc6, 0x8a, 0xd5, 0xbe, - 0xc9, 0xcd, 0xe9, 0xad, 0x43, 0xb1, 0x07, 0xad, 0xef, 0x6a, 0x07, 0xde, 0x59, 0xab, 0xe5, 0xc9, 0x75, 0xd3, 0xd6, - 0x48, 0xdb, 0x49, 0x97, 0xcd, 0xcb, 0x44, 0x2d, 0x17, 0x69, 0x2d, 0x61, 0x24, 0xb5, 0x96, 0x73, 0x9b, 0xb6, 0x87, - 0x1a, 0xd5, 0xa9, 0x65, 0xbb, 0xb3, 0xb8, 0x3d, 0x30, 0xff, 0xb4, 0x0e, 0x5a, 0xbb, 0x87, 0xf1, 0x2e, 0x56, 0x9c, - 0x22, 0x8f, 0xc7, 0xd0, 0x71, 0x9b, 0xcd, 0x7b, 0x4b, 0x05, 0x47, 0xaf, 0x81, 0xb8, 0x39, 0x5d, 0x36, 0x66, 0xb2, - 0x00, 0x58, 0xca, 0x05, 0x9c, 0x74, 0xf6, 0xe0, 0x81, 0x3e, 0x94, 0x04, 0xd3, 0xf4, 0xbd, 0x8d, 0xd6, 0x87, 0xd5, - 0x3a, 0xa8, 0x06, 0x06, 0xff, 0x6c, 0xfe, 0xaa, 0x78, 0xe5, 0x27, 0x2c, 0x90, 0x55, 0x78, 0x23, 0xe9, 0xae, 0x5b, - 0x4e, 0x3e, 0x19, 0xeb, 0x4a, 0x6c, 0x32, 0xde, 0x1d, 0x73, 0x7a, 0x6b, 0xdd, 0x3c, 0xe6, 0x5c, 0x80, 0x11, 0x19, - 0xc2, 0x3a, 0x30, 0xb7, 0x9f, 0x85, 0x0d, 0x8d, 0x75, 0x0c, 0x0d, 0x1f, 0x77, 0x92, 0x6e, 0x17, 0xe1, 0x16, 0xee, - 0x74, 0xbb, 0x81, 0x7c, 0x34, 0xd1, 0xfb, 0x8a, 0xee, 0x2b, 0x29, 0xf7, 0x94, 0x3c, 0x31, 0x8d, 0x9e, 0xb4, 0x5b, - 0x2d, 0x6c, 0x5c, 0xd9, 0xcb, 0xc2, 0x42, 0xed, 0x69, 0xb6, 0xdd, 0x6a, 0x41, 0xb3, 0xf0, 0xc7, 0xcd, 0xeb, 0x27, - 0xb2, 0x6a, 0xa5, 0x2d, 0xdc, 0x4e, 0xdb, 0xb8, 0x93, 0x76, 0xf0, 0x69, 0x7a, 0x8a, 0xcf, 0xd2, 0x33, 0xdc, 0x4d, - 0xbb, 0xf8, 0x3c, 0x3d, 0xc7, 0xf7, 0xd3, 0xfb, 0xf8, 0x22, 0xbd, 0xc0, 0x0f, 0xd2, 0x07, 0xf8, 0x61, 0xda, 0x6e, - 0xe1, 0x47, 0x69, 0xbb, 0x8d, 0x1f, 0xa7, 0xed, 0x0e, 0x7e, 0x92, 0xb6, 0x4f, 0xf1, 0xd3, 0xb4, 0x7d, 0x86, 0x9f, - 0xa5, 0xed, 0x2e, 0xa6, 0x90, 0x3b, 0x82, 0xdc, 0x0c, 0x72, 0xc7, 0x90, 0xcb, 0x20, 0x77, 0x92, 0xb6, 0xbb, 0x1b, - 0x2c, 0x6d, 0xf8, 0x8b, 0xa8, 0xd5, 0xee, 0x9c, 0x9e, 0x75, 0xcf, 0xef, 0x5f, 0x3c, 0x78, 0xf8, 0xe8, 0xf1, 0x93, - 0xa7, 0xcf, 0xa2, 0x21, 0xbe, 0x33, 0x5e, 0x28, 0x52, 0x0c, 0xf8, 0x51, 0xbb, 0x3b, 0xc4, 0xb7, 0xfe, 0x33, 0xe6, - 0x47, 0x9d, 0xb3, 0x16, 0xba, 0xba, 0x3a, 0x1b, 0x36, 0xca, 0xdc, 0x47, 0xc6, 0xf9, 0xa5, 0xca, 0x22, 0x84, 0xc4, - 0x90, 0x83, 0xf0, 0x17, 0xeb, 0xcc, 0xc2, 0x62, 0x9e, 0x14, 0xe8, 0xe8, 0xc8, 0xfc, 0x98, 0xfa, 0x1f, 0x23, 0xff, - 0x83, 0x06, 0x8b, 0x74, 0x43, 0x63, 0xe7, 0xfd, 0xac, 0x4b, 0xdf, 0x83, 0xd2, 0xac, 0xe7, 0x80, 0x3b, 0x03, 0xfb, - 0xff, 0x8a, 0xac, 0x01, 0x0d, 0x39, 0xb3, 0x4a, 0xaa, 0x6e, 0x9f, 0x91, 0x55, 0x91, 0x76, 0xba, 0xdd, 0xa3, 0x9f, - 0x06, 0x7c, 0xd0, 0x1e, 0x0e, 0x8f, 0xdb, 0xf7, 0xf1, 0xb4, 0x4c, 0xe8, 0xd8, 0x84, 0x51, 0x99, 0x70, 0x6a, 0x13, - 0x68, 0x6a, 0x6b, 0x43, 0xd2, 0x99, 0x49, 0x82, 0x12, 0x9b, 0xd4, 0xb4, 0x7d, 0xdf, 0xb6, 0xfd, 0x00, 0x2c, 0xbb, - 0x4c, 0xf3, 0xae, 0xe9, 0xcb, 0xcb, 0xb3, 0xb5, 0x6b, 0x14, 0x4f, 0x53, 0xd7, 0x9a, 0x4f, 0x3c, 0x1b, 0x0e, 0xf1, - 0xc8, 0x24, 0x76, 0xab, 0xc4, 0xf3, 0xe1, 0xd0, 0x75, 0xf5, 0xc0, 0x74, 0x75, 0xbf, 0xca, 0xba, 0x18, 0x0e, 0x4d, - 0x97, 0xc8, 0xf9, 0xf1, 0x2b, 0x7d, 0xf0, 0xb9, 0xd4, 0xa5, 0xf0, 0xcb, 0x4e, 0xb7, 0xdb, 0x07, 0x0c, 0x33, 0xf6, - 0xb9, 0x1e, 0x46, 0xd7, 0x01, 0x8c, 0xbe, 0xc0, 0xef, 0xfe, 0x1d, 0x4d, 0x6f, 0x69, 0x09, 0xa4, 0x7e, 0xf4, 0x5f, - 0x51, 0x43, 0x1b, 0x98, 0x9b, 0x3f, 0x53, 0xfb, 0x67, 0x84, 0x1a, 0x9f, 0x29, 0x80, 0x1b, 0xb4, 0x43, 0x5e, 0xbd, - 0x6b, 0x7a, 0xfc, 0x85, 0x82, 0xbb, 0xcd, 0x4c, 0xe5, 0xb4, 0xbf, 0x9e, 0xdd, 0x8c, 0xd6, 0x33, 0xf5, 0x05, 0xfd, - 0x19, 0xff, 0xa9, 0x8e, 0xe3, 0x41, 0xb3, 0x91, 0xb0, 0x3f, 0xc7, 0xe0, 0xd7, 0xd3, 0x4f, 0xc7, 0x6c, 0x8a, 0xfa, - 0x83, 0x3f, 0x15, 0x1e, 0x36, 0x82, 0x8c, 0xef, 0x76, 0x53, 0xc0, 0xeb, 0x67, 0x3b, 0x31, 0xfe, 0x0e, 0xf5, 0x51, - 0xff, 0x4f, 0x75, 0xfc, 0x27, 0xba, 0x77, 0x12, 0x68, 0x30, 0xa4, 0xdb, 0xc2, 0x55, 0x28, 0xa0, 0xe3, 0x72, 0x0b, - 0x33, 0xdc, 0x6e, 0x32, 0x08, 0x9c, 0x06, 0x6e, 0xe1, 0x24, 0x96, 0x0d, 0x7e, 0x72, 0xda, 0x42, 0xdf, 0xb5, 0x3b, - 0xa0, 0xe8, 0x68, 0x8a, 0xe3, 0xdd, 0x4d, 0x5f, 0x34, 0x4f, 0xf1, 0x83, 0x66, 0x81, 0xdb, 0x08, 0x37, 0xdb, 0x5e, - 0x03, 0x3d, 0x50, 0x71, 0x0b, 0x61, 0x15, 0x5f, 0xc0, 0x3f, 0x67, 0x68, 0x58, 0x6d, 0xc8, 0xc7, 0x74, 0xbb, 0x77, - 0xf0, 0x61, 0x25, 0xb1, 0x6a, 0xf0, 0x93, 0xf3, 0x16, 0xfa, 0xee, 0xdc, 0x74, 0xc4, 0x8e, 0xf5, 0x9e, 0xae, 0x24, - 0x3e, 0x6b, 0x4a, 0xe8, 0xa8, 0x55, 0xf6, 0x23, 0xe2, 0x2e, 0xc2, 0x22, 0x3e, 0x85, 0x7f, 0xda, 0x61, 0x3f, 0xf7, - 0x76, 0xfa, 0x31, 0xf3, 0x6e, 0xe3, 0xa4, 0x6b, 0x5d, 0x62, 0x95, 0xbd, 0x9f, 0x6e, 0xb0, 0xab, 0xb6, 0xb9, 0x58, - 0x6b, 0x9f, 0xc0, 0x07, 0xc2, 0xfa, 0x98, 0x28, 0xcc, 0x8e, 0xc1, 0x97, 0x16, 0x4c, 0x48, 0xd4, 0xe5, 0x69, 0x4f, - 0x35, 0x1a, 0x48, 0x0c, 0xd4, 0xf0, 0x98, 0xb4, 0x9b, 0xba, 0xc9, 0x30, 0xfc, 0x6e, 0x90, 0x32, 0x40, 0x9b, 0xa8, - 0x7a, 0x7d, 0xe5, 0x7a, 0xb5, 0xb7, 0xf0, 0x1e, 0x3b, 0x08, 0x21, 0xaa, 0x1f, 0xeb, 0x26, 0x43, 0x27, 0xa2, 0x11, - 0xeb, 0x4b, 0xd6, 0x3f, 0x4f, 0x5b, 0xc8, 0x60, 0xa7, 0xea, 0xc7, 0xac, 0xc9, 0x21, 0xbd, 0x93, 0xc6, 0xbc, 0xa9, - 0xe1, 0xd7, 0x59, 0x00, 0x2d, 0x01, 0x78, 0x57, 0x79, 0x06, 0x15, 0x27, 0x9d, 0x6e, 0x17, 0x0b, 0xc2, 0x93, 0xa9, - 0xf9, 0xa5, 0x08, 0x4f, 0x46, 0xe6, 0x97, 0x24, 0x25, 0xbc, 0x6c, 0xef, 0xb8, 0x20, 0xc1, 0xaa, 0x9a, 0x14, 0x0a, - 0x0b, 0x5a, 0xa0, 0x93, 0x8e, 0xbf, 0xa2, 0xc7, 0x33, 0x3f, 0x07, 0x50, 0x49, 0x14, 0xc6, 0x3a, 0x53, 0x36, 0x0b, - 0x9c, 0x13, 0x7a, 0x95, 0x74, 0xfb, 0xb3, 0x93, 0xb8, 0xd3, 0x94, 0xcd, 0x02, 0xa5, 0xb3, 0x13, 0x53, 0x13, 0x67, - 0xe4, 0x15, 0xb5, 0xad, 0xe1, 0x19, 0xdc, 0xab, 0x66, 0x24, 0x3b, 0x3e, 0x6f, 0x35, 0x92, 0x2e, 0xc2, 0x83, 0x6c, - 0xdd, 0xc2, 0xf9, 0x7a, 0xdd, 0xc2, 0x34, 0x5c, 0x06, 0xe1, 0x01, 0x52, 0x6a, 0xcd, 0xb6, 0xe3, 0xe4, 0xf4, 0x79, - 0xac, 0xc1, 0x46, 0x40, 0x83, 0xe7, 0x8d, 0x06, 0x9f, 0xa0, 0x94, 0xbb, 0xcb, 0x39, 0x64, 0x22, 0x05, 0x4e, 0x42, - 0x3d, 0xda, 0x2b, 0xe1, 0xd7, 0xd5, 0x8d, 0xfc, 0x9e, 0x88, 0x3f, 0x48, 0x6c, 0xd3, 0xaa, 0x62, 0xaf, 0xe9, 0x6e, - 0xb1, 0x7b, 0x74, 0xa7, 0xd8, 0xc3, 0x3d, 0xc5, 0x1e, 0xef, 0x16, 0xfb, 0x5b, 0x06, 0x5a, 0x3f, 0xfe, 0xdd, 0xe9, - 0x79, 0xab, 0x71, 0x0a, 0xc8, 0x7a, 0x7a, 0xde, 0xaa, 0x0a, 0x3d, 0xa5, 0xd5, 0x5a, 0x69, 0xf2, 0x0b, 0xb5, 0x7e, - 0x0f, 0xdc, 0x3b, 0x60, 0x9b, 0x85, 0xb3, 0xee, 0xdf, 0xa5, 0xaf, 0xf7, 0xa0, 0x0b, 0x76, 0x25, 0xc2, 0x50, 0x3b, - 0x3d, 0x38, 0x1f, 0xf6, 0x67, 0x2c, 0x6e, 0x40, 0x2a, 0x4a, 0x27, 0xda, 0xfd, 0x42, 0xe5, 0xf5, 0xf2, 0xdf, 0x12, - 0x92, 0x3a, 0x43, 0x84, 0x25, 0x69, 0xe8, 0xc1, 0xe9, 0xd0, 0x9c, 0x77, 0x05, 0xfc, 0x3e, 0x33, 0xbf, 0x4b, 0xe5, - 0x8e, 0x73, 0x8e, 0x98, 0xdd, 0x8c, 0xa2, 0xbe, 0x20, 0xaf, 0x69, 0x6c, 0xec, 0xdd, 0x51, 0x5a, 0x66, 0xa8, 0x2f, - 0x90, 0xf1, 0xb0, 0xcc, 0x10, 0xe4, 0x95, 0x70, 0xbf, 0xf1, 0xaa, 0x48, 0xc1, 0xf6, 0x05, 0x4f, 0x53, 0xb0, 0x7b, - 0xc1, 0xa3, 0x54, 0x80, 0x6f, 0x06, 0x4d, 0x59, 0x60, 0x51, 0xff, 0xc2, 0x69, 0xd3, 0xcc, 0x0d, 0x30, 0x31, 0x58, - 0xda, 0x63, 0x70, 0x52, 0xfc, 0x2d, 0x63, 0xf8, 0xdb, 0xd0, 0x08, 0x33, 0x68, 0x93, 0x21, 0xcc, 0x93, 0x82, 0x40, - 0x1a, 0xe6, 0xc9, 0x94, 0x30, 0x68, 0x92, 0x27, 0x23, 0xc2, 0x06, 0x9d, 0x00, 0x4d, 0x9e, 0x18, 0xd8, 0x01, 0x70, - 0x78, 0xfd, 0x52, 0x5d, 0xdb, 0xc6, 0xe1, 0xb6, 0x1e, 0x9a, 0x10, 0x04, 0xe2, 0x1f, 0x0c, 0xc0, 0x84, 0x43, 0xd9, - 0x9f, 0x9d, 0x2a, 0x14, 0x25, 0x4f, 0xa8, 0xa1, 0xde, 0x7f, 0x01, 0x59, 0x8d, 0xef, 0xad, 0xd8, 0x06, 0x1f, 0xdc, - 0x5b, 0x89, 0xcd, 0x77, 0xf0, 0x47, 0xd9, 0x3f, 0xc0, 0x3c, 0x24, 0x14, 0x6d, 0xd0, 0x5f, 0x29, 0x14, 0xdb, 0x53, - 0x0a, 0xfd, 0xe5, 0x48, 0xb4, 0x52, 0x64, 0x75, 0x9b, 0x46, 0x63, 0x5a, 0x7c, 0x8e, 0xf0, 0x1f, 0x69, 0x94, 0x03, - 0xb7, 0x18, 0xe1, 0x0f, 0x69, 0x54, 0xb0, 0x08, 0xff, 0x9e, 0x46, 0xa3, 0x7c, 0x19, 0xe1, 0xdf, 0xd2, 0x68, 0x5a, - 0x44, 0xf8, 0x3d, 0x28, 0x4e, 0xc7, 0x7c, 0x39, 0x8f, 0xf0, 0xbb, 0x34, 0x52, 0xc6, 0x33, 0x01, 0x3f, 0x4c, 0x23, - 0xc6, 0x22, 0xfc, 0x36, 0x8d, 0x64, 0x1e, 0xe1, 0xeb, 0x34, 0x92, 0x45, 0x84, 0x1f, 0xa5, 0x51, 0x41, 0x23, 0xfc, - 0x38, 0x8d, 0xa0, 0xd0, 0x34, 0xc2, 0x4f, 0xd2, 0x08, 0x5a, 0x56, 0x11, 0x7e, 0x93, 0x46, 0x5c, 0x44, 0xf8, 0xd7, - 0x34, 0xd2, 0xcb, 0xe2, 0xef, 0xa5, 0xe4, 0x2a, 0xc2, 0x4f, 0xd3, 0x68, 0xc6, 0x23, 0xfc, 0x3a, 0x8d, 0x0a, 0x19, - 0xe1, 0x57, 0x69, 0x44, 0xf3, 0x08, 0xbf, 0x4c, 0xa3, 0x9c, 0x45, 0xf8, 0x97, 0x34, 0x1a, 0xb3, 0x08, 0xff, 0x9c, - 0x46, 0x77, 0x2c, 0xcf, 0x65, 0x84, 0x9f, 0xa5, 0x11, 0x13, 0x11, 0xfe, 0x29, 0x8d, 0xb2, 0x59, 0x84, 0x7f, 0x48, - 0x23, 0x5a, 0x7c, 0x56, 0x11, 0x7e, 0x9e, 0x46, 0x8c, 0x46, 0xf8, 0x85, 0xed, 0x68, 0x1a, 0xe1, 0x1f, 0xd3, 0xe8, - 0x66, 0x16, 0x6d, 0xb0, 0x54, 0x64, 0xf5, 0x8a, 0x67, 0xec, 0x77, 0x96, 0x46, 0x93, 0xd6, 0xe4, 0x62, 0x32, 0x89, - 0x30, 0x15, 0x9a, 0xff, 0xbd, 0x64, 0x37, 0x4f, 0x35, 0x24, 0x52, 0x36, 0x1a, 0xdf, 0x8f, 0x30, 0xfd, 0x7b, 0x49, - 0xd3, 0x68, 0x32, 0x31, 0x05, 0xfe, 0x5e, 0xd2, 0x39, 0x2d, 0xde, 0xb0, 0x34, 0xba, 0x3f, 0x99, 0x4c, 0xc6, 0x67, - 0x11, 0xa6, 0xff, 0x2c, 0x3f, 0x98, 0x16, 0x4c, 0x81, 0x11, 0xe3, 0x53, 0xa8, 0xdb, 0x9d, 0x74, 0xc7, 0x59, 0x84, - 0x47, 0x5c, 0xfd, 0xbd, 0x84, 0xef, 0x09, 0x3b, 0xcb, 0xce, 0x22, 0x3c, 0xca, 0x69, 0xf6, 0x39, 0x8d, 0x5a, 0xe6, - 0x97, 0xf8, 0x89, 0x8d, 0x5f, 0xcd, 0xa5, 0xb9, 0x56, 0x98, 0xb0, 0x51, 0x36, 0x8e, 0xb0, 0x19, 0xcc, 0x04, 0xfe, - 0x7e, 0xe1, 0x6f, 0x99, 0x4e, 0xa3, 0x0b, 0xda, 0x19, 0xb1, 0x4e, 0x84, 0x47, 0xaf, 0x6f, 0x44, 0x1a, 0xd1, 0x6e, - 0x87, 0x76, 0x68, 0x84, 0x47, 0xcb, 0x22, 0xbf, 0xbb, 0x91, 0x72, 0x0c, 0x40, 0x18, 0x5d, 0x5c, 0xdc, 0x8f, 0x70, - 0x46, 0x7f, 0xd1, 0x50, 0xbb, 0x3b, 0x79, 0xc0, 0x68, 0x2b, 0xc2, 0x3f, 0xd1, 0x42, 0x7f, 0x58, 0x2a, 0x37, 0xd0, - 0x16, 0xa4, 0xc8, 0xec, 0x2d, 0xa8, 0xdc, 0xa3, 0x71, 0xe7, 0xfc, 0x41, 0x9b, 0x45, 0x38, 0xbb, 0x7e, 0x05, 0xbd, - 0xdd, 0x9f, 0x74, 0x5b, 0xf0, 0x21, 0x40, 0x2e, 0x65, 0x05, 0x34, 0x72, 0x7e, 0xf6, 0xa0, 0xcb, 0xc6, 0x26, 0x51, - 0xf1, 0xfc, 0xb3, 0x99, 0xfd, 0x05, 0xcc, 0x27, 0x2b, 0xf8, 0x5c, 0x49, 0x91, 0x46, 0xe3, 0xac, 0x7d, 0x76, 0x0a, - 0x09, 0x77, 0x54, 0x78, 0xe0, 0xdc, 0x42, 0xd5, 0x8b, 0x51, 0x84, 0x6f, 0x6d, 0xea, 0xc5, 0xc8, 0x7c, 0x4c, 0xdf, - 0xfe, 0x22, 0x5e, 0x8f, 0xd3, 0x68, 0x74, 0x71, 0x71, 0xde, 0x82, 0x84, 0xdf, 0xe8, 0x5d, 0x1a, 0xd1, 0x07, 0xf0, - 0x1f, 0x64, 0x7f, 0x78, 0x06, 0x1d, 0xc2, 0x08, 0x6f, 0xa7, 0x1f, 0xc2, 0x9c, 0xcf, 0x33, 0xfa, 0x99, 0xa7, 0xd1, - 0x68, 0x3c, 0xba, 0x7f, 0x0e, 0xf5, 0xe6, 0x74, 0xfa, 0x4c, 0x53, 0x68, 0xb7, 0xd5, 0x32, 0x2d, 0xbf, 0xe5, 0x5f, - 0x98, 0xa9, 0xde, 0xed, 0x9e, 0x8f, 0x3a, 0x30, 0x82, 0x6b, 0x50, 0xa8, 0xc0, 0x78, 0x2e, 0x32, 0xd3, 0xe0, 0x75, - 0xf6, 0x74, 0x9c, 0x46, 0x0f, 0x1e, 0x9c, 0x76, 0xb2, 0x2c, 0xc2, 0xb7, 0x1f, 0xc6, 0xb6, 0xb6, 0xc9, 0x53, 0x00, - 0xfb, 0x34, 0x62, 0x0f, 0x1e, 0x9c, 0xdf, 0xa7, 0xf0, 0xfd, 0xdc, 0xb4, 0x75, 0x31, 0x19, 0x65, 0x17, 0xd0, 0xd6, - 0x3b, 0x98, 0xce, 0xd9, 0xc5, 0xe9, 0xd8, 0xf4, 0xf5, 0xce, 0x8c, 0xba, 0x33, 0x39, 0x9b, 0x9c, 0x99, 0x4c, 0x33, - 0xd4, 0xf2, 0xf3, 0x57, 0x96, 0x46, 0x19, 0x1b, 0xb7, 0x23, 0x7c, 0xeb, 0x16, 0xee, 0xc1, 0x59, 0xab, 0x35, 0x3e, - 0x8d, 0xf0, 0xf8, 0xe1, 0x62, 0xf1, 0xc6, 0x40, 0xb0, 0x7d, 0xf6, 0xc0, 0x7e, 0xab, 0xcf, 0x77, 0xd0, 0xf4, 0xc8, - 0x00, 0x6d, 0xcc, 0xe7, 0xa6, 0xe5, 0xf3, 0x07, 0xf0, 0x9f, 0xf9, 0x36, 0x4d, 0x97, 0xdf, 0x72, 0x3c, 0xb5, 0x8b, - 0xd2, 0x66, 0x0f, 0x5a, 0x50, 0x63, 0xc2, 0x3f, 0x8c, 0x0a, 0x0e, 0x68, 0x34, 0xea, 0xc0, 0xff, 0x45, 0x78, 0x92, - 0x5f, 0xbf, 0x72, 0x38, 0x3b, 0x99, 0xd0, 0x49, 0x2b, 0xc2, 0x13, 0xf9, 0x41, 0xe9, 0xdf, 0x1e, 0x8a, 0x34, 0xea, - 0x74, 0x2e, 0x46, 0xa6, 0xcc, 0xf2, 0x27, 0xc5, 0x0d, 0x1e, 0xb7, 0x4c, 0x2b, 0x53, 0xfa, 0x46, 0x8d, 0xae, 0x25, - 0xac, 0x24, 0xfc, 0x17, 0xe1, 0x29, 0x68, 0xc4, 0x5c, 0x2b, 0x17, 0x76, 0x3b, 0x4c, 0xdf, 0x1a, 0xd4, 0x1c, 0xdf, - 0x07, 0x78, 0xf9, 0x65, 0x1c, 0x53, 0xda, 0xed, 0xb4, 0x22, 0x6c, 0x46, 0x7d, 0xd1, 0x82, 0xff, 0x22, 0x6c, 0x21, - 0x67, 0xe0, 0x3a, 0xfd, 0xf0, 0xec, 0xe7, 0x9b, 0x34, 0xa2, 0xe3, 0xc9, 0x04, 0x96, 0xc4, 0x4c, 0xc6, 0x17, 0x9b, - 0x49, 0xc1, 0xee, 0x7e, 0xb9, 0x71, 0xdb, 0xc5, 0x24, 0x68, 0x07, 0x9d, 0xf3, 0x07, 0xa3, 0xb3, 0x08, 0xbf, 0x19, - 0x73, 0x2a, 0x60, 0x95, 0xb2, 0x71, 0x37, 0xeb, 0x66, 0x26, 0x61, 0x2a, 0xd3, 0xe8, 0x0c, 0x96, 0xbc, 0x13, 0x61, - 0xfe, 0xe5, 0xfa, 0xce, 0xa2, 0x1b, 0xd4, 0x76, 0x08, 0x32, 0x69, 0xb1, 0xf3, 0x8b, 0x2c, 0xc2, 0x39, 0xfd, 0xf2, - 0xec, 0x97, 0x22, 0x8d, 0xd8, 0x39, 0x3b, 0x9f, 0x50, 0xff, 0xfd, 0xbb, 0x9a, 0x99, 0x1a, 0xad, 0x49, 0x17, 0x92, - 0x6e, 0x84, 0x19, 0xeb, 0xfd, 0x6c, 0x62, 0x30, 0xe4, 0xe5, 0x5c, 0x8a, 0xec, 0xe9, 0x64, 0x22, 0x2d, 0x16, 0x53, - 0xd8, 0x84, 0x7f, 0x00, 0xb4, 0xe9, 0x78, 0x7c, 0xc1, 0xce, 0x23, 0xfc, 0x87, 0xdd, 0x25, 0x6e, 0x02, 0x7f, 0x58, - 0xcc, 0x66, 0x6e, 0xb7, 0xff, 0x61, 0x81, 0x02, 0xf3, 0x9d, 0xd0, 0x09, 0x1d, 0x77, 0x22, 0xfc, 0x87, 0x81, 0xcb, - 0xf8, 0x14, 0xfe, 0x83, 0x02, 0xd0, 0xd9, 0x83, 0x16, 0x63, 0x0f, 0x5a, 0xe6, 0x2b, 0xcc, 0x73, 0x33, 0x1f, 0x9d, - 0x67, 0xed, 0x08, 0xff, 0xe1, 0xd0, 0x71, 0x32, 0xa1, 0x2d, 0x40, 0xc7, 0x3f, 0x1c, 0x3a, 0x76, 0x5a, 0xa3, 0x0e, - 0x35, 0xdf, 0x16, 0x6b, 0x2e, 0xee, 0x67, 0x0c, 0x26, 0xf7, 0x87, 0x45, 0xc8, 0xfb, 0xf7, 0x2f, 0x2e, 0x1e, 0x3c, - 0x80, 0x4f, 0xd3, 0x76, 0xf9, 0xa9, 0xf4, 0xc3, 0xdc, 0x20, 0x59, 0x2b, 0x3b, 0x03, 0x3a, 0xf9, 0x87, 0x19, 0xe3, - 0x64, 0x32, 0x61, 0xad, 0x08, 0xe7, 0x7c, 0xce, 0x2c, 0x26, 0xd8, 0xdf, 0xa6, 0xa3, 0xd3, 0x4e, 0x36, 0x3e, 0xed, - 0x44, 0x38, 0x7f, 0xf3, 0xcc, 0xcc, 0xa6, 0x05, 0xb3, 0xf7, 0x5b, 0xce, 0x63, 0xcd, 0x9c, 0xbe, 0x86, 0x41, 0xc2, - 0x4a, 0x43, 0xe5, 0xf7, 0x01, 0x3d, 0x3c, 0x3f, 0xcf, 0xc6, 0x30, 0xd0, 0xf7, 0xd0, 0x2d, 0x80, 0xf1, 0xbd, 0xdd, - 0x7c, 0x23, 0xda, 0xed, 0xc2, 0x74, 0xdf, 0x2f, 0x96, 0xc5, 0xe2, 0x65, 0x1a, 0x3d, 0x38, 0xbd, 0xdf, 0x1a, 0x8f, - 0x22, 0xfc, 0xde, 0x4d, 0xf0, 0x34, 0x1b, 0x9d, 0xde, 0x6f, 0x47, 0xf8, 0xbd, 0xd9, 0x6f, 0xf7, 0x47, 0xe7, 0x17, - 0x70, 0x6e, 0xbc, 0x57, 0x8b, 0xe2, 0xcd, 0xd4, 0x14, 0x98, 0xd0, 0x07, 0xd0, 0xec, 0xaf, 0x66, 0x37, 0x8e, 0xdb, - 0xb0, 0x91, 0xdf, 0x9b, 0x4d, 0x66, 0xf0, 0xe4, 0x7e, 0xbb, 0x7b, 0xd1, 0x8d, 0xf0, 0x9c, 0x8f, 0x05, 0x10, 0x78, - 0xb3, 0x51, 0x1e, 0xb4, 0x1f, 0xdc, 0x6f, 0x45, 0x78, 0xfe, 0x46, 0x67, 0x1f, 0xe8, 0xdc, 0x50, 0xe3, 0x09, 0xc0, - 0x6c, 0xce, 0x95, 0xbe, 0x7b, 0xad, 0x1c, 0x3d, 0x66, 0xed, 0x08, 0xcf, 0x65, 0x96, 0x51, 0xf5, 0xc6, 0x26, 0x8c, - 0xba, 0x11, 0x16, 0xf4, 0x0b, 0xfd, 0x24, 0xfd, 0x66, 0x1a, 0x33, 0x3a, 0x36, 0x69, 0x06, 0x87, 0x23, 0xfc, 0x76, - 0x0c, 0x17, 0x83, 0x69, 0x34, 0x19, 0x4f, 0xba, 0x00, 0x1e, 0x20, 0x40, 0x16, 0xbb, 0x01, 0x1a, 0xf0, 0x35, 0x7e, - 0x34, 0x4a, 0xa3, 0xf3, 0xd1, 0x05, 0xeb, 0x9c, 0x46, 0xb8, 0xa4, 0x46, 0xb4, 0x0b, 0xf9, 0xe6, 0xf3, 0x83, 0xd9, - 0x52, 0x67, 0x36, 0xc1, 0x00, 0x68, 0x4c, 0xef, 0xb7, 0xc6, 0xe7, 0x11, 0x5e, 0xbc, 0x62, 0x7e, 0x8f, 0x31, 0xc6, - 0x2e, 0x00, 0x96, 0x90, 0x64, 0x10, 0xe8, 0x62, 0x32, 0x7a, 0x70, 0x61, 0xbe, 0x01, 0x0c, 0x74, 0xc2, 0x18, 0x00, - 0x69, 0xf1, 0x8a, 0x95, 0x80, 0x18, 0x8f, 0xee, 0xb7, 0x80, 0xbe, 0x2c, 0xe8, 0x82, 0xde, 0xd1, 0x9b, 0xa7, 0x0b, - 0x33, 0xa7, 0xc9, 0xb8, 0x1b, 0xe1, 0xc5, 0xf3, 0x9f, 0x16, 0xcb, 0xc9, 0xc4, 0x4c, 0x88, 0x8e, 0x1e, 0x44, 0x78, - 0xc1, 0x8a, 0x25, 0xac, 0xd1, 0x45, 0xf7, 0x74, 0x12, 0x61, 0x87, 0x86, 0x59, 0x2b, 0x1b, 0xc1, 0xcd, 0xe7, 0x72, - 0x9e, 0x46, 0xe3, 0x31, 0x6d, 0x8d, 0xe1, 0x1e, 0x54, 0xde, 0xfc, 0x52, 0x58, 0x34, 0x62, 0x06, 0x1f, 0xdc, 0x1a, - 0xc2, 0x7c, 0x01, 0x1e, 0x1f, 0x46, 0x2c, 0xcb, 0xa8, 0x4b, 0x3c, 0x3f, 0x3f, 0x3d, 0x05, 0xdc, 0xb3, 0x33, 0xb4, - 0x08, 0xf2, 0x5a, 0xdd, 0x8d, 0x0a, 0x09, 0x47, 0x17, 0x10, 0x55, 0x20, 0xab, 0xaf, 0xef, 0x5e, 0x19, 0xba, 0xda, - 0x3e, 0x7f, 0x00, 0x0b, 0xa0, 0xe8, 0x78, 0xfc, 0xd2, 0x1e, 0x6e, 0x17, 0xa3, 0xb3, 0x6e, 0xfb, 0x34, 0xc2, 0x7e, - 0x23, 0xd0, 0x8b, 0xd6, 0xfd, 0x0e, 0x94, 0x10, 0xe3, 0x3b, 0x5b, 0x62, 0x72, 0x46, 0xcf, 0xce, 0x5b, 0x11, 0xf6, - 0x5b, 0x83, 0x5d, 0x8c, 0xba, 0xf7, 0xe1, 0x53, 0xcd, 0x58, 0x9e, 0x1b, 0xfc, 0xee, 0x02, 0x5c, 0x14, 0x7f, 0x26, - 0x68, 0x1a, 0xd1, 0x56, 0xb7, 0xd3, 0x19, 0xc3, 0x67, 0xfe, 0x85, 0x15, 0x69, 0x94, 0xb5, 0xe0, 0xbf, 0x08, 0x07, - 0x3b, 0x89, 0x8d, 0x22, 0x6c, 0xf0, 0xee, 0x9c, 0x76, 0xcd, 0xde, 0x77, 0xbb, 0xaa, 0x75, 0xd1, 0x82, 0x0d, 0xeb, - 0x36, 0x95, 0xfb, 0x52, 0x42, 0xde, 0x38, 0x12, 0x4b, 0x23, 0x1c, 0x20, 0xe8, 0xe4, 0xfe, 0x24, 0xc2, 0x7e, 0xc7, - 0x9d, 0x9d, 0x5f, 0x74, 0x80, 0x94, 0x69, 0x20, 0x14, 0xe3, 0xce, 0xe8, 0x0c, 0x48, 0x93, 0x66, 0xaf, 0x2c, 0x9e, - 0x44, 0x58, 0x3f, 0x55, 0xfa, 0x65, 0x1a, 0x8d, 0x2f, 0x46, 0x93, 0xf1, 0x45, 0x84, 0xb5, 0x9c, 0x53, 0x2d, 0x0d, - 0x05, 0x3c, 0x3d, 0xbb, 0x1f, 0x61, 0x83, 0xe6, 0x2d, 0xd6, 0x1a, 0xb7, 0x22, 0xec, 0x8e, 0x12, 0xc6, 0x2e, 0x3a, - 0x30, 0xad, 0x1f, 0x9f, 0x6b, 0xc0, 0xe5, 0x31, 0x1b, 0x9d, 0x46, 0xb8, 0xa4, 0xf7, 0x86, 0x10, 0xc1, 0x97, 0x9a, - 0xcb, 0xcf, 0x8e, 0xf5, 0x00, 0x52, 0xe7, 0x37, 0x3c, 0x2c, 0xc3, 0xcf, 0x37, 0x16, 0x8d, 0xa8, 0xd9, 0xe2, 0xc1, - 0xcd, 0xf0, 0x5b, 0x1a, 0x7b, 0xb6, 0x9d, 0x93, 0xd5, 0x06, 0x97, 0x01, 0x57, 0x3f, 0xb3, 0x3b, 0x15, 0x4b, 0x65, - 0x38, 0xd9, 0x20, 0x45, 0x29, 0xe4, 0x5d, 0x0c, 0x9c, 0x17, 0x29, 0x08, 0x92, 0x82, 0xb4, 0x7a, 0xe2, 0xd2, 0x7b, - 0xb6, 0xf6, 0x04, 0x84, 0x61, 0x80, 0xf4, 0x82, 0x50, 0xa2, 0x21, 0x5a, 0x8d, 0x15, 0x26, 0xbd, 0xc1, 0xbf, 0x91, - 0x29, 0xa5, 0x75, 0x21, 0xa0, 0x84, 0xfa, 0x38, 0xf5, 0xb1, 0xc4, 0x0a, 0x22, 0x39, 0xa1, 0x9e, 0x24, 0x26, 0xea, - 0xf4, 0x0b, 0xa1, 0x63, 0xa9, 0x06, 0xc5, 0x10, 0xb7, 0xcf, 0x11, 0x86, 0x78, 0x0e, 0x64, 0x20, 0xaf, 0xae, 0xda, - 0xe7, 0x47, 0x46, 0xe8, 0xbb, 0xba, 0xba, 0xb0, 0x3f, 0xe0, 0xdf, 0x61, 0x15, 0x43, 0x1b, 0xc6, 0xf7, 0x9e, 0x55, - 0x73, 0xfc, 0xd9, 0xf0, 0xd7, 0xef, 0xd9, 0x7a, 0x1d, 0xbf, 0x67, 0x04, 0x66, 0x8c, 0xdf, 0xb3, 0xc4, 0xdc, 0x91, - 0x58, 0x6f, 0x1d, 0x32, 0x00, 0xcd, 0x59, 0x0b, 0x43, 0x64, 0x77, 0xcf, 0x79, 0xbf, 0x67, 0x03, 0x5e, 0xf7, 0xf4, - 0xae, 0xc2, 0x29, 0x1f, 0x1d, 0xad, 0x8a, 0x54, 0x5b, 0x31, 0x41, 0x5b, 0x31, 0x41, 0x5b, 0x31, 0x41, 0x57, 0x01, - 0xed, 0xcf, 0xfa, 0x20, 0xa5, 0x18, 0x65, 0x8b, 0xe3, 0xa9, 0xdf, 0x80, 0xda, 0x03, 0xb4, 0x93, 0xfd, 0x4a, 0xd9, - 0x51, 0xea, 0x2a, 0xf6, 0x2a, 0x30, 0xf6, 0x26, 0x3a, 0x6d, 0xc7, 0xc9, 0xbf, 0xa3, 0xee, 0x78, 0x56, 0x13, 0xcb, - 0xde, 0xec, 0x15, 0xcb, 0x60, 0x25, 0x8d, 0x68, 0x76, 0x68, 0x63, 0x83, 0xe8, 0xc1, 0x7d, 0x23, 0x98, 0x55, 0x01, - 0xeb, 0x1a, 0x90, 0xd4, 0x03, 0x29, 0xe4, 0xc2, 0x48, 0x69, 0x05, 0x4a, 0xc7, 0x3a, 0x2e, 0x40, 0x43, 0xe9, 0x15, - 0x94, 0x65, 0x5c, 0xd5, 0x86, 0x01, 0x88, 0xb2, 0x32, 0x9a, 0x95, 0xd5, 0xba, 0x20, 0xba, 0x80, 0x26, 0xcc, 0x48, - 0x2c, 0xd0, 0x80, 0x30, 0x0d, 0x08, 0x57, 0x19, 0xc4, 0x19, 0x97, 0x7d, 0x66, 0xb2, 0x95, 0xc9, 0x56, 0x65, 0xb6, - 0xf4, 0xd9, 0x56, 0x48, 0x94, 0x26, 0x5b, 0x96, 0xd9, 0x20, 0xb3, 0xe1, 0x69, 0xaa, 0xf0, 0x28, 0x95, 0x56, 0x54, - 0xab, 0x64, 0xab, 0x97, 0x34, 0xd4, 0xe6, 0x1e, 0x1d, 0xc5, 0xa5, 0x9c, 0x64, 0xd4, 0xc4, 0xf7, 0x56, 0x3c, 0x29, - 0x8c, 0x0c, 0xc4, 0x93, 0xa9, 0xfb, 0x3b, 0xda, 0x6c, 0xcb, 0x4a, 0xc5, 0x74, 0xf4, 0x95, 0x92, 0xe8, 0x2f, 0xaf, - 0x44, 0x7d, 0xce, 0x4d, 0x44, 0x9e, 0x4b, 0x92, 0xb4, 0x5a, 0xa7, 0xed, 0xd3, 0xd6, 0x45, 0x9f, 0x1f, 0xb7, 0x3b, - 0xc9, 0x83, 0x4e, 0x6a, 0x14, 0x11, 0x0b, 0x79, 0x03, 0x0a, 0x98, 0x93, 0x4e, 0x72, 0x86, 0x8e, 0xdb, 0x49, 0xab, - 0xdb, 0x6d, 0xc2, 0x3f, 0xf8, 0x91, 0x2e, 0xab, 0x9d, 0xb5, 0xce, 0xba, 0x7d, 0x7e, 0xb2, 0x55, 0x29, 0xe6, 0x0d, - 0x28, 0x88, 0x4e, 0x4c, 0x25, 0x0c, 0xf5, 0xab, 0xe5, 0xfd, 0x67, 0x47, 0xcf, 0xf3, 0x48, 0xc7, 0xd2, 0xaa, 0xe2, - 0x00, 0xaa, 0xfe, 0x6b, 0x6a, 0x80, 0xe8, 0xbf, 0x46, 0x65, 0xd4, 0xdc, 0x55, 0x01, 0xa2, 0xf6, 0x73, 0x1e, 0x8b, - 0x06, 0x3b, 0x8e, 0x6d, 0xbe, 0x86, 0xba, 0x4d, 0x88, 0x64, 0x87, 0xa7, 0x2e, 0x57, 0x85, 0xb9, 0x53, 0x84, 0x9a, - 0x0a, 0x72, 0x47, 0x2e, 0x57, 0x86, 0xb9, 0x23, 0x84, 0x9a, 0x12, 0x72, 0x69, 0xca, 0x13, 0x0a, 0x39, 0x3a, 0xa1, - 0x4d, 0x03, 0xc9, 0x6a, 0x51, 0x9e, 0x33, 0x3f, 0x6c, 0x3e, 0x81, 0xe5, 0x31, 0x04, 0xc5, 0x09, 0xd2, 0x02, 0x5e, - 0x3b, 0x29, 0xb5, 0x39, 0x2d, 0x5c, 0xaa, 0x71, 0x20, 0xa3, 0x01, 0xff, 0x1c, 0x33, 0xf3, 0x04, 0x46, 0xab, 0x7f, - 0x7a, 0xde, 0x4a, 0xdb, 0xe0, 0xb6, 0x0d, 0xb2, 0xb6, 0xb0, 0xb2, 0xb6, 0xf0, 0xb2, 0xb6, 0xf0, 0xb2, 0x36, 0x08, - 0xf0, 0x41, 0xdf, 0xbf, 0xcb, 0x9a, 0x29, 0x0c, 0x2f, 0xed, 0x6a, 0xac, 0xe1, 0x44, 0xac, 0xd7, 0xeb, 0xd5, 0x06, - 0xac, 0x9e, 0xca, 0x1a, 0x85, 0xaa, 0xd4, 0x9f, 0xab, 0x22, 0x6d, 0xe1, 0x69, 0x0a, 0x5a, 0xee, 0x16, 0xa6, 0x66, - 0x73, 0x7b, 0xaa, 0xb0, 0x1d, 0x51, 0xa7, 0xef, 0xd5, 0xc9, 0x57, 0xe4, 0xd4, 0x68, 0x8f, 0x57, 0x45, 0xca, 0x2d, - 0xcd, 0xe0, 0x96, 0x66, 0x70, 0x4b, 0x33, 0xa0, 0x11, 0x5c, 0x16, 0x36, 0x65, 0x13, 0x4a, 0xe0, 0x4a, 0x60, 0x70, - 0x3a, 0x84, 0x80, 0x82, 0xb1, 0x26, 0x66, 0xd4, 0x5b, 0x9d, 0xb7, 0x21, 0x80, 0x9a, 0x2d, 0xa9, 0x13, 0x6a, 0xfc, - 0xc8, 0xcb, 0x31, 0x7f, 0xaa, 0xa1, 0x7d, 0x02, 0xaf, 0xdb, 0x3c, 0xd4, 0x71, 0x0b, 0xcc, 0x48, 0xa2, 0x22, 0xea, - 0x1b, 0xb2, 0x90, 0x1a, 0x9d, 0x8d, 0x33, 0x0f, 0xff, 0xbc, 0xe5, 0x95, 0x6b, 0x29, 0x41, 0xf8, 0xa6, 0xc3, 0x67, - 0x56, 0x85, 0x09, 0x28, 0xad, 0x5f, 0x9d, 0xe9, 0x9a, 0x3d, 0x12, 0x7a, 0x60, 0xc2, 0xee, 0xe3, 0x4f, 0xf5, 0x05, - 0x29, 0x20, 0xfe, 0x62, 0x6a, 0x12, 0x5d, 0x04, 0x65, 0x70, 0x28, 0x26, 0x37, 0xd4, 0xb8, 0xd7, 0xfc, 0x6c, 0xff, - 0x7c, 0xa2, 0x81, 0xff, 0x61, 0x31, 0x1d, 0x79, 0xb7, 0xdd, 0x8f, 0x26, 0xce, 0x10, 0x39, 0x3c, 0xb4, 0xd6, 0xe5, - 0xe6, 0x6b, 0xdb, 0xbc, 0xdc, 0x24, 0x9a, 0x6c, 0xd8, 0xa1, 0x7e, 0x8d, 0x7e, 0xf7, 0xde, 0x73, 0xc5, 0x74, 0x84, - 0x02, 0x9a, 0x6d, 0xc0, 0x2a, 0x2b, 0x60, 0x29, 0x57, 0xaf, 0x74, 0xaa, 0x84, 0xde, 0xcd, 0x98, 0x37, 0xc5, 0x74, - 0xb4, 0xf7, 0x19, 0x14, 0xdb, 0x63, 0xff, 0x25, 0x0d, 0x7a, 0xf0, 0xaa, 0xed, 0x19, 0xbb, 0xfd, 0x56, 0x9d, 0xeb, - 0xbd, 0x75, 0x54, 0xfe, 0xad, 0x3a, 0x4f, 0xf6, 0xd5, 0x99, 0xf3, 0xdb, 0xd8, 0xef, 0x1d, 0x1d, 0xa8, 0xb1, 0x8d, - 0xc9, 0xd2, 0x74, 0x04, 0x71, 0xeb, 0xe1, 0xaf, 0x8d, 0x2e, 0xd3, 0xf3, 0x24, 0x1c, 0x56, 0x41, 0xf6, 0x93, 0x6e, - 0xca, 0x30, 0x25, 0x9d, 0xe3, 0xc2, 0xc4, 0x97, 0x11, 0x09, 0x6d, 0xaa, 0x84, 0xe2, 0x9c, 0xc4, 0x31, 0x3d, 0xce, - 0x20, 0x4a, 0x4e, 0xbb, 0x4f, 0xd3, 0x98, 0x36, 0x32, 0x74, 0x12, 0xb7, 0x1b, 0xf4, 0x38, 0x43, 0xa8, 0xd1, 0x06, - 0x9d, 0xa9, 0x24, 0xed, 0x66, 0x0e, 0x71, 0x33, 0x0d, 0x29, 0xce, 0x8f, 0x45, 0x52, 0x34, 0xe4, 0xb1, 0x4a, 0x8a, - 0x46, 0xd2, 0xc5, 0x22, 0x99, 0x96, 0xc9, 0x53, 0x93, 0x3c, 0xb5, 0xc9, 0xa3, 0x32, 0x79, 0x64, 0x92, 0x47, 0x36, - 0x99, 0x92, 0xe2, 0x58, 0x24, 0xb4, 0x11, 0xb7, 0x9b, 0x05, 0x3a, 0x86, 0x11, 0xf8, 0xd1, 0x13, 0x11, 0x86, 0x2b, - 0xdf, 0x18, 0x7b, 0x9f, 0x85, 0xcc, 0x5d, 0x00, 0xd1, 0x0a, 0x48, 0xa5, 0x13, 0x16, 0xd4, 0xf9, 0x27, 0x00, 0x13, - 0xd6, 0xf6, 0x8f, 0x0f, 0x8f, 0xb7, 0xc9, 0x72, 0x29, 0x02, 0x27, 0x33, 0xb0, 0x8b, 0xff, 0xec, 0x5c, 0x6b, 0x00, - 0xaa, 0x1b, 0x9a, 0x2f, 0x66, 0x74, 0xc7, 0x93, 0xb7, 0x98, 0x8e, 0xdc, 0xce, 0x2a, 0x9b, 0x61, 0xb4, 0xb0, 0x61, - 0xa7, 0xeb, 0x3e, 0x97, 0x00, 0x6a, 0xef, 0xe7, 0x99, 0x50, 0xa3, 0x24, 0xb7, 0x35, 0xa6, 0x05, 0xbb, 0x53, 0x19, - 0xcd, 0x59, 0x5c, 0x1d, 0xc0, 0xd5, 0x30, 0x19, 0x79, 0x02, 0xd6, 0xf9, 0xc5, 0x71, 0x72, 0xda, 0xd0, 0xc9, 0xf4, - 0x38, 0xe9, 0x3e, 0x68, 0xe8, 0x64, 0x74, 0x9c, 0xb4, 0xdb, 0x15, 0xce, 0x26, 0x05, 0xd1, 0xc9, 0x94, 0x68, 0xd0, - 0x18, 0xda, 0x46, 0xe5, 0x82, 0x82, 0xb9, 0xd9, 0xbf, 0x31, 0x8c, 0x86, 0x1b, 0x86, 0x60, 0x53, 0x1b, 0x81, 0x73, - 0x67, 0x0c, 0x61, 0x37, 0x9d, 0x6e, 0xb7, 0xa9, 0x93, 0x02, 0x6b, 0xbb, 0x92, 0x4d, 0x9d, 0x4c, 0xb1, 0xb6, 0xcb, - 0xd7, 0xd4, 0xc9, 0xc8, 0x36, 0x65, 0x74, 0x80, 0x4c, 0x04, 0xc0, 0x7a, 0xce, 0x02, 0xc8, 0x77, 0xbc, 0xc3, 0xcc, - 0x06, 0xb4, 0x86, 0xdf, 0x2a, 0xd7, 0xf4, 0x05, 0x15, 0xd5, 0x60, 0x76, 0xc4, 0xbe, 0x56, 0xb4, 0x5d, 0x35, 0xc9, - 0xfe, 0x75, 0xd9, 0xb2, 0xd9, 0x42, 0xea, 0x7a, 0xc1, 0x17, 0x35, 0x0c, 0x71, 0xa5, 0xdc, 0xc1, 0xfd, 0x88, 0x92, - 0x18, 0xe2, 0xec, 0x99, 0x53, 0x88, 0x13, 0xaf, 0x47, 0x86, 0x24, 0xde, 0x68, 0x6c, 0x50, 0x1c, 0x9c, 0xb7, 0x2f, - 0x42, 0xaa, 0xba, 0x13, 0x7c, 0x8f, 0x90, 0x68, 0x29, 0xac, 0x79, 0xe6, 0x38, 0xaa, 0x68, 0xf1, 0x1b, 0xa7, 0xdd, - 0xad, 0x1d, 0x10, 0x47, 0x47, 0xdb, 0xe7, 0x85, 0x7f, 0x06, 0x61, 0xe7, 0xe9, 0x83, 0xca, 0xb6, 0xcf, 0x3f, 0xce, - 0x64, 0xad, 0x7e, 0x79, 0x80, 0x28, 0x3e, 0x0c, 0xd6, 0x7d, 0x43, 0xe1, 0x07, 0x55, 0x0c, 0x40, 0x97, 0xd3, 0x3c, - 0x37, 0x19, 0xa6, 0xaf, 0x61, 0x30, 0xb6, 0x57, 0xe1, 0x84, 0x4a, 0xbb, 0xc5, 0x7f, 0xd9, 0x71, 0xd0, 0x89, 0x7b, - 0x3c, 0x26, 0x6c, 0xf4, 0x53, 0x68, 0x25, 0x5c, 0xc1, 0xc6, 0xf9, 0x87, 0xaf, 0xd7, 0xb5, 0xa7, 0x82, 0xec, 0x83, - 0x34, 0xe8, 0xe8, 0x88, 0xab, 0x67, 0x60, 0xd8, 0xcc, 0xe2, 0x46, 0x78, 0xf8, 0xfe, 0x5d, 0x3b, 0xad, 0x3f, 0x99, - 0x73, 0x35, 0x0d, 0x0e, 0xba, 0x87, 0xb5, 0xfc, 0xbd, 0x2b, 0xd1, 0xd7, 0x29, 0x77, 0x6b, 0xfd, 0xbe, 0x32, 0x1b, - 0xdf, 0x79, 0xb4, 0xea, 0xe8, 0x88, 0x57, 0xa1, 0xa3, 0xa2, 0xef, 0x22, 0xd4, 0x37, 0x32, 0xc8, 0xb3, 0x5c, 0x52, - 0xb8, 0x11, 0x85, 0x2b, 0x86, 0xb4, 0xc1, 0x4f, 0x34, 0xfe, 0x49, 0xfe, 0x7f, 0x6a, 0xe4, 0x58, 0xa7, 0x0d, 0x1e, - 0x98, 0x1b, 0x84, 0xac, 0x50, 0x15, 0xb4, 0xd1, 0x40, 0x3a, 0xb4, 0x02, 0x47, 0xe5, 0x61, 0x4e, 0x17, 0x8b, 0xfc, - 0xce, 0xbc, 0xdb, 0x15, 0x70, 0x54, 0xd5, 0x45, 0x93, 0x8b, 0x98, 0x87, 0x0b, 0xe0, 0xe9, 0x01, 0xf7, 0x90, 0xf1, - 0x78, 0x2d, 0x2f, 0xb7, 0x05, 0x02, 0xc9, 0x4c, 0x11, 0xd9, 0x6c, 0xf7, 0xd4, 0x15, 0xc8, 0x65, 0xcd, 0x26, 0xd2, - 0x2e, 0x90, 0x38, 0xe6, 0x20, 0x93, 0x29, 0xeb, 0xd5, 0x7a, 0x60, 0x0b, 0x82, 0xe4, 0x26, 0x8d, 0xc8, 0xb6, 0xbf, - 0x14, 0x9f, 0xc4, 0x80, 0x46, 0xc8, 0x0a, 0x7c, 0xa1, 0xb0, 0xc8, 0x81, 0xeb, 0x2c, 0x7c, 0xc7, 0x5f, 0x69, 0xa9, - 0x18, 0xa8, 0xe1, 0x10, 0x17, 0xe6, 0xa9, 0x8a, 0x72, 0x3e, 0x54, 0x05, 0x4f, 0x1f, 0x05, 0x22, 0x0a, 0x5f, 0xaf, - 0x0f, 0xe1, 0x65, 0x21, 0xd7, 0x26, 0xb8, 0xc1, 0xba, 0x9f, 0xd5, 0x2b, 0x22, 0x30, 0x0e, 0x46, 0x5a, 0xe6, 0xa2, - 0xd0, 0xc9, 0x9b, 0xec, 0x52, 0xf4, 0x1a, 0x0d, 0x66, 0x82, 0x3e, 0x11, 0x88, 0xf0, 0x06, 0x3e, 0x8a, 0xf0, 0xc7, - 0xc6, 0x71, 0x52, 0xcc, 0x46, 0xc3, 0x83, 0x30, 0xdd, 0xb5, 0x84, 0xf5, 0x5a, 0xd9, 0x68, 0x2b, 0x26, 0xc7, 0xc6, - 0x5d, 0x29, 0xfb, 0x29, 0xc3, 0xba, 0x56, 0x66, 0x1c, 0xdc, 0x6d, 0xf5, 0x37, 0xd5, 0x7e, 0x3e, 0xe0, 0xf6, 0x1a, - 0x8f, 0x9b, 0x18, 0x06, 0x06, 0x50, 0xab, 0xad, 0x0d, 0x6e, 0x6d, 0xee, 0x63, 0x6b, 0x20, 0xcc, 0xb6, 0x21, 0x28, - 0x4a, 0x9f, 0x7d, 0x7b, 0x73, 0xeb, 0x63, 0x18, 0x2a, 0x33, 0x27, 0x85, 0xf4, 0x00, 0xe4, 0xe8, 0x21, 0x81, 0xce, - 0xed, 0xcf, 0x8a, 0x2e, 0x54, 0x32, 0x71, 0x39, 0xc6, 0x1f, 0x82, 0xdb, 0xbc, 0x41, 0xf4, 0xf1, 0xa3, 0xd9, 0xe4, - 0x1f, 0x3f, 0x46, 0x38, 0x34, 0x74, 0x8f, 0x02, 0x5e, 0x30, 0x1a, 0x96, 0x61, 0xae, 0xcc, 0xc6, 0x6f, 0xb6, 0x03, - 0xb4, 0xa3, 0x15, 0xde, 0xc1, 0xf2, 0x98, 0xc6, 0x77, 0x1c, 0x43, 0x07, 0x1c, 0xe0, 0xcd, 0x06, 0x7c, 0xd8, 0x7b, - 0x15, 0x2b, 0x74, 0x74, 0xf4, 0x2a, 0x96, 0xa8, 0x7f, 0xcd, 0xcc, 0x9d, 0x1b, 0x78, 0x86, 0x0f, 0xb8, 0x19, 0xbe, - 0x0c, 0x10, 0xe0, 0x9a, 0x6d, 0x4b, 0x36, 0x6f, 0x4c, 0x1c, 0x8e, 0x14, 0xe2, 0x7c, 0x43, 0xb4, 0x61, 0x07, 0x12, - 0xe8, 0xf5, 0x55, 0x08, 0xed, 0x1e, 0x23, 0x0c, 0x58, 0xf8, 0xd2, 0x6f, 0x8f, 0x25, 0x73, 0x56, 0x4c, 0x59, 0xb1, - 0x5e, 0x3f, 0xa7, 0xd6, 0x17, 0x6f, 0x2b, 0x6c, 0xa4, 0xea, 0x35, 0x1a, 0xd4, 0x8c, 0x1f, 0xc4, 0x07, 0x3a, 0xc4, - 0x87, 0xaf, 0xe2, 0x02, 0x21, 0xb0, 0x30, 0xe2, 0x62, 0xe9, 0xfd, 0xce, 0xb2, 0xda, 0xba, 0x14, 0xa8, 0x6c, 0x24, - 0x27, 0x2d, 0x3c, 0x23, 0x59, 0xb9, 0x46, 0x97, 0xb3, 0x5e, 0xa3, 0x91, 0x23, 0x19, 0x67, 0x83, 0x7c, 0x88, 0x39, - 0x2e, 0xe0, 0x32, 0x75, 0x77, 0x1d, 0x16, 0xac, 0x46, 0xb9, 0xdc, 0x7c, 0x57, 0x76, 0xac, 0xe9, 0x3b, 0xba, 0x09, - 0x80, 0xf1, 0x8e, 0x06, 0x44, 0x62, 0x1f, 0x90, 0x85, 0x05, 0xb2, 0xf2, 0x40, 0x16, 0x06, 0xc8, 0x0a, 0xf5, 0x17, - 0x10, 0x40, 0x49, 0xa1, 0x74, 0x87, 0xa2, 0xd7, 0x43, 0x7d, 0x3a, 0x37, 0x12, 0xcc, 0x4d, 0xb4, 0x09, 0xb7, 0x1c, - 0xe0, 0x52, 0xe2, 0xe6, 0xae, 0xc8, 0x2a, 0x8a, 0x4c, 0xd4, 0x5b, 0x7c, 0x6b, 0xfe, 0x24, 0xb7, 0xf8, 0xce, 0xfe, - 0xb8, 0x0b, 0x94, 0x49, 0xbf, 0xd5, 0xb4, 0x0d, 0xdc, 0xc5, 0x88, 0x8b, 0x92, 0x08, 0xd0, 0xda, 0x05, 0x3c, 0x14, - 0xf5, 0x37, 0xe0, 0x94, 0x0d, 0x4d, 0x21, 0x1a, 0x44, 0x61, 0x11, 0x90, 0xce, 0x3f, 0xff, 0x8c, 0x50, 0x5f, 0x40, - 0x64, 0x21, 0x77, 0xb2, 0x35, 0xdb, 0xa8, 0x11, 0x25, 0x51, 0x1a, 0xfb, 0xc0, 0x15, 0xb0, 0x33, 0xa2, 0x28, 0x78, - 0xff, 0xa5, 0xb2, 0xf1, 0xa8, 0x0d, 0xc3, 0x0c, 0xaa, 0x0a, 0xc5, 0x71, 0xb5, 0xda, 0x0e, 0x7c, 0x64, 0xa0, 0x2a, - 0x4c, 0xd4, 0x19, 0x64, 0x1f, 0x45, 0x63, 0x84, 0x1d, 0x1d, 0xb1, 0x81, 0x18, 0x06, 0xaf, 0x9c, 0x55, 0xad, 0xeb, - 0x70, 0xe1, 0xe2, 0x0c, 0x22, 0xcf, 0xaf, 0xd7, 0xf6, 0x2f, 0xf9, 0x60, 0xa4, 0x19, 0x78, 0xae, 0x2e, 0xb8, 0x8d, - 0x17, 0xfb, 0x65, 0xb1, 0x44, 0xcb, 0x77, 0x60, 0xd9, 0xe7, 0xe2, 0x08, 0x72, 0x37, 0xd5, 0xb6, 0x87, 0xfa, 0xc2, - 0x68, 0x14, 0x82, 0x28, 0xbe, 0xd5, 0x91, 0x86, 0x17, 0x3a, 0xcc, 0xab, 0x45, 0xe3, 0xcd, 0x55, 0x19, 0x54, 0x15, - 0x8e, 0x94, 0x04, 0xac, 0xae, 0x0d, 0x9d, 0x84, 0x1f, 0x75, 0x2a, 0xe9, 0x58, 0x48, 0x80, 0x02, 0x47, 0xe6, 0x72, - 0xde, 0x04, 0xcd, 0x67, 0x68, 0x0f, 0x91, 0xab, 0x56, 0xf9, 0xef, 0xba, 0x6c, 0xe9, 0xa2, 0x5b, 0x45, 0x73, 0xb9, - 0x54, 0x6c, 0xb9, 0x80, 0xf3, 0xbd, 0x4c, 0xcb, 0x72, 0x9e, 0x7d, 0xae, 0xa7, 0x80, 0x41, 0xe4, 0xad, 0x9e, 0x33, - 0xb1, 0x8c, 0xdc, 0x3c, 0x5f, 0x5a, 0x71, 0xff, 0xf5, 0x0b, 0xfc, 0x9e, 0x74, 0x8e, 0x5f, 0xe2, 0xdf, 0x29, 0x79, - 0xdf, 0x78, 0x89, 0xa7, 0x9c, 0x58, 0xde, 0x20, 0x79, 0xfd, 0xea, 0xfa, 0xc5, 0xdb, 0x17, 0xef, 0x9f, 0x7e, 0x7c, - 0xf1, 0xf2, 0xd9, 0x8b, 0x97, 0x2f, 0xde, 0x7e, 0xc0, 0x3f, 0x51, 0xf2, 0xf2, 0xa4, 0x7d, 0xd1, 0xc2, 0xef, 0xc8, - 0xcb, 0x93, 0x0e, 0xbe, 0xd5, 0xe4, 0xe5, 0xc9, 0x19, 0x9e, 0x29, 0xf2, 0xf2, 0xb8, 0x73, 0x72, 0x8a, 0x97, 0xda, - 0x36, 0x99, 0xcb, 0x69, 0xbb, 0x85, 0xff, 0x76, 0x5f, 0x20, 0xde, 0x57, 0xb3, 0x98, 0xb2, 0x2d, 0xe3, 0x07, 0x53, - 0x86, 0x8e, 0x94, 0x31, 0x44, 0xb9, 0x0c, 0xd0, 0x69, 0xac, 0xea, 0xa6, 0x0d, 0x10, 0xd6, 0x19, 0x6c, 0x18, 0x01, - 0xad, 0x38, 0x71, 0xed, 0xf0, 0x93, 0x36, 0x3b, 0x05, 0xfa, 0xc4, 0x4b, 0xe1, 0xb8, 0x54, 0xe1, 0xb4, 0x9d, 0x16, - 0x63, 0x92, 0x4b, 0x59, 0xc4, 0x4b, 0x60, 0x04, 0x8c, 0xd6, 0x82, 0x9f, 0x94, 0xf1, 0xa3, 0xc4, 0x25, 0x69, 0xf7, - 0xdb, 0xa9, 0xb8, 0x24, 0x9d, 0x7e, 0x07, 0xfe, 0x74, 0xfb, 0xdd, 0xb4, 0xdd, 0x42, 0xc7, 0xc1, 0x38, 0x7e, 0xa8, - 0xa1, 0xf5, 0x60, 0x88, 0x5d, 0x17, 0xea, 0xef, 0x42, 0x7b, 0x95, 0x9e, 0x70, 0xea, 0xd8, 0x76, 0x4f, 0x5c, 0x32, - 0xa3, 0x87, 0xe5, 0xdf, 0x01, 0x6a, 0x1b, 0x17, 0x97, 0x72, 0xe3, 0xb8, 0x5f, 0xfc, 0x44, 0xa0, 0x5a, 0x90, 0x9a, - 0x98, 0xad, 0x5b, 0x08, 0x98, 0x46, 0x93, 0x0d, 0xe6, 0x40, 0x89, 0x92, 0x85, 0xf6, 0x81, 0xf6, 0x55, 0x53, 0xa2, - 0x64, 0x21, 0x17, 0x71, 0x4d, 0xd5, 0xf0, 0x4b, 0x60, 0xe6, 0x78, 0xc8, 0xd5, 0x4b, 0xfa, 0x32, 0xae, 0xf1, 0x3c, - 0x21, 0x6b, 0x17, 0x6e, 0x8b, 0x5f, 0x9d, 0x15, 0x45, 0x0d, 0x5c, 0x25, 0x60, 0xfd, 0xa8, 0x9a, 0xfa, 0x12, 0x5e, - 0x14, 0x64, 0x0d, 0x7d, 0x45, 0x02, 0xea, 0xf9, 0x6b, 0x69, 0xc6, 0x55, 0x2a, 0xa3, 0xbd, 0x22, 0xda, 0x98, 0x05, - 0x79, 0x45, 0xf4, 0xa5, 0x32, 0x40, 0x90, 0x84, 0x0f, 0xc4, 0x10, 0x0e, 0x7c, 0x3b, 0x40, 0x69, 0xe8, 0x1c, 0xa8, - 0x95, 0x2a, 0x33, 0x21, 0xf3, 0x69, 0xc2, 0x25, 0x80, 0xe6, 0xa9, 0x52, 0x41, 0x99, 0x4f, 0x2c, 0x51, 0x30, 0xf4, - 0x3f, 0xc2, 0x0d, 0x70, 0x1c, 0x1b, 0x54, 0x0c, 0xed, 0x6a, 0x44, 0x3d, 0xbf, 0x7d, 0xd1, 0x3a, 0x79, 0x19, 0xe4, - 0x2f, 0x95, 0xb7, 0xf7, 0xf8, 0x14, 0x50, 0x72, 0x1b, 0xe0, 0xab, 0x8d, 0x7d, 0x6c, 0xb6, 0x5e, 0x08, 0x90, 0x63, - 0x8d, 0x4e, 0xcc, 0xe3, 0x8a, 0x3d, 0xa4, 0x8f, 0x49, 0xbb, 0x05, 0x01, 0xd5, 0xf6, 0x50, 0xbe, 0x3f, 0xb6, 0x60, - 0xaa, 0x93, 0xdb, 0x26, 0xd0, 0x6a, 0x78, 0x6f, 0xe9, 0xae, 0xc9, 0x93, 0x3b, 0xac, 0x02, 0x9c, 0x61, 0xc7, 0xac, - 0x21, 0x8e, 0x05, 0x72, 0x81, 0x68, 0xed, 0x06, 0xd0, 0x54, 0x74, 0xec, 0xbb, 0x7f, 0xde, 0x38, 0xea, 0xb2, 0x99, - 0x74, 0x8f, 0x5f, 0x1e, 0x1d, 0xc5, 0xb2, 0x41, 0xde, 0x23, 0xbc, 0xa2, 0x60, 0xb3, 0x0d, 0x7e, 0x70, 0xdc, 0x32, - 0xf1, 0xa9, 0x0a, 0xa8, 0xe3, 0x44, 0xd5, 0x8e, 0xb5, 0xaa, 0xb3, 0x72, 0x37, 0xf8, 0x31, 0x75, 0x50, 0x23, 0x48, - 0xb3, 0xa3, 0xeb, 0x84, 0x50, 0xfe, 0xb1, 0xe6, 0xb4, 0x06, 0xdb, 0xb2, 0xf1, 0x3b, 0x45, 0xdf, 0xbd, 0x6f, 0xbe, - 0x0c, 0xf0, 0xa0, 0x66, 0x9a, 0xf4, 0xbe, 0xf1, 0x1e, 0x7d, 0xf7, 0x3e, 0x70, 0x3b, 0xe4, 0x15, 0x7b, 0xe2, 0xb9, - 0x91, 0x5f, 0x2d, 0x57, 0xfa, 0x2b, 0x48, 0xf6, 0x05, 0xf9, 0x15, 0xb0, 0x9c, 0x92, 0x5f, 0x63, 0xd9, 0x84, 0x70, - 0x8c, 0xe4, 0xd7, 0xb8, 0x80, 0x1f, 0x39, 0xf9, 0x35, 0x06, 0x6c, 0xc7, 0x33, 0xf3, 0xa3, 0x28, 0x81, 0x01, 0xae, - 0x6e, 0xd2, 0x7a, 0xbc, 0x15, 0xeb, 0xb5, 0x38, 0x3a, 0x92, 0xf6, 0x17, 0xbd, 0xca, 0x8e, 0x8e, 0xf2, 0xcb, 0x59, - 0xd5, 0x37, 0xd7, 0xfb, 0xe8, 0x8b, 0x41, 0x28, 0x1c, 0x98, 0xa6, 0xf1, 0x70, 0xc6, 0x3a, 0x0b, 0x11, 0x07, 0x1a, - 0x68, 0x9e, 0x76, 0xee, 0x9f, 0x5f, 0x60, 0xf8, 0xf7, 0x7e, 0x50, 0x10, 0x74, 0xf8, 0x76, 0x62, 0xa4, 0xcd, 0x9a, - 0xe7, 0x55, 0x9d, 0xab, 0x00, 0x9f, 0x31, 0x43, 0x4d, 0x71, 0x74, 0xc4, 0x2f, 0x03, 0x5c, 0xc6, 0x0c, 0x35, 0x02, - 0x8b, 0xbd, 0xa7, 0xa5, 0x3d, 0x99, 0xe1, 0x9a, 0xe0, 0xa1, 0x5d, 0x3e, 0x28, 0x86, 0x97, 0xda, 0x51, 0x93, 0x30, - 0x1c, 0xb7, 0x22, 0x2d, 0xb7, 0xc9, 0x7a, 0xa2, 0xa9, 0xae, 0xda, 0x3d, 0x24, 0x89, 0x6a, 0x88, 0xab, 0xab, 0x36, - 0x06, 0x95, 0x7c, 0x5f, 0x11, 0x99, 0x0a, 0xe2, 0x5d, 0x06, 0x57, 0xb9, 0x4c, 0x15, 0x9e, 0xf1, 0x54, 0x78, 0x39, - 0xfb, 0x9e, 0xb7, 0x9e, 0x36, 0x4e, 0x9c, 0xa6, 0x67, 0x86, 0x45, 0x5f, 0x95, 0xce, 0x87, 0xb0, 0x49, 0xd5, 0x10, - 0xde, 0x31, 0x2c, 0x31, 0x8f, 0x59, 0x8f, 0x3b, 0x06, 0x71, 0xa2, 0x55, 0xa3, 0x0d, 0x99, 0xf0, 0xb9, 0x49, 0x15, - 0x0c, 0xd4, 0x14, 0xbe, 0x04, 0x23, 0xab, 0xac, 0x32, 0xcc, 0xf6, 0x0d, 0x43, 0x01, 0x01, 0x05, 0xae, 0x08, 0x0b, - 0x24, 0x78, 0x91, 0xd5, 0x08, 0x47, 0x9d, 0x5c, 0xd8, 0xc9, 0x5d, 0x2a, 0xe8, 0x4e, 0x0c, 0x2f, 0x75, 0x0f, 0x89, - 0x46, 0xc3, 0x71, 0xdb, 0x57, 0xc2, 0x0c, 0xa2, 0xd9, 0x1e, 0x5e, 0xb1, 0x1e, 0x52, 0xcd, 0x66, 0x69, 0x00, 0x79, - 0xd5, 0x5a, 0xaf, 0xd5, 0xa5, 0x6f, 0xa4, 0xef, 0xcf, 0x71, 0xc3, 0x77, 0x79, 0xc1, 0xf3, 0x0f, 0x49, 0x06, 0x11, - 0x50, 0x55, 0xe0, 0xb3, 0xe5, 0x22, 0xc2, 0x91, 0x79, 0xe2, 0x0e, 0xfe, 0x9a, 0xa7, 0xc9, 0x22, 0x1c, 0xb9, 0x57, - 0xef, 0xa2, 0x61, 0x35, 0x58, 0x95, 0x95, 0x01, 0xdb, 0x79, 0xf2, 0x11, 0x18, 0x07, 0xfd, 0x49, 0xa1, 0x55, 0xf5, - 0x3b, 0xc9, 0x5d, 0xe8, 0x12, 0xe5, 0x1f, 0x62, 0x73, 0xa3, 0xda, 0xec, 0x77, 0x16, 0xe5, 0x38, 0xf2, 0x55, 0xe1, - 0x41, 0x83, 0x6f, 0xbc, 0x04, 0xd9, 0x76, 0x0f, 0x90, 0xaf, 0xca, 0x1e, 0x80, 0xf3, 0xde, 0x6c, 0x10, 0xfe, 0x43, - 0xee, 0x7d, 0x8d, 0x38, 0xfa, 0x28, 0xc5, 0x13, 0xaa, 0x69, 0xd4, 0x78, 0x6d, 0x0c, 0xdf, 0xac, 0x9c, 0xd5, 0xfb, - 0xda, 0x38, 0xd8, 0xbf, 0xd5, 0x3d, 0x04, 0x93, 0xa8, 0x3d, 0x9c, 0x64, 0x65, 0x5f, 0x13, 0x42, 0x44, 0x06, 0xa6, - 0x6f, 0x7b, 0xe0, 0xe1, 0xc7, 0x48, 0xc1, 0xc5, 0xd9, 0xf2, 0x49, 0x14, 0xa2, 0xb4, 0xd6, 0x1c, 0xab, 0x21, 0xc5, - 0xf6, 0x61, 0x9c, 0x70, 0x37, 0x28, 0xe4, 0xba, 0x17, 0xaa, 0x4e, 0x4c, 0xab, 0x6e, 0x8c, 0xd4, 0xc1, 0xb6, 0x59, - 0x70, 0x56, 0xf5, 0x6e, 0x24, 0x94, 0xea, 0x8d, 0x39, 0xf3, 0x4e, 0x68, 0xb3, 0x6d, 0x1e, 0x5e, 0xb6, 0x2f, 0xd1, - 0x29, 0x30, 0xe4, 0x3d, 0x2c, 0x03, 0x68, 0x5d, 0xc1, 0xb1, 0x1b, 0x07, 0x90, 0x95, 0xe4, 0x6a, 0xe5, 0x5e, 0x89, - 0xe3, 0x03, 0x39, 0xdc, 0x94, 0x6f, 0xc6, 0x05, 0x78, 0x10, 0x38, 0x05, 0x64, 0x21, 0x67, 0xe0, 0x1f, 0x5c, 0xac, - 0xe9, 0x87, 0xf8, 0x3f, 0x70, 0xc0, 0x57, 0x48, 0x9a, 0x5a, 0xf5, 0x13, 0xbc, 0xe5, 0x04, 0x0a, 0x6f, 0x5b, 0xf7, - 0x47, 0x19, 0x3a, 0xcd, 0xd6, 0x75, 0x2a, 0xd6, 0x2f, 0xb5, 0xae, 0x58, 0x29, 0x0b, 0x07, 0x54, 0x2b, 0x46, 0x9b, - 0xd4, 0xf9, 0xb0, 0xba, 0x07, 0xa0, 0x1e, 0x0a, 0xf0, 0x8d, 0xe1, 0x52, 0x3c, 0x2b, 0x20, 0xa2, 0x57, 0xa8, 0x4f, - 0xd3, 0x45, 0xf8, 0xc2, 0xf1, 0x00, 0xee, 0x09, 0x4b, 0x9e, 0xb3, 0x7c, 0x95, 0x1b, 0x16, 0x48, 0x01, 0x85, 0x52, - 0x58, 0xac, 0xd7, 0xb1, 0x30, 0x71, 0x1e, 0x5c, 0x98, 0x5f, 0xf7, 0x9e, 0x87, 0xd1, 0xdf, 0x41, 0x5d, 0xec, 0xd5, - 0x23, 0xc6, 0x84, 0x15, 0x85, 0x97, 0x4e, 0x45, 0x16, 0xf4, 0xb5, 0xaf, 0x0f, 0x51, 0x4d, 0xb9, 0x1f, 0x1b, 0x7d, - 0xef, 0x5b, 0x3e, 0x67, 0x72, 0x09, 0x0f, 0x29, 0x61, 0x46, 0x14, 0xd3, 0xfe, 0x1b, 0x28, 0x08, 0xbc, 0xc6, 0xc3, - 0x43, 0x7c, 0x04, 0xbe, 0xca, 0xd3, 0x3a, 0x9a, 0xf9, 0xe7, 0x39, 0x22, 0x13, 0x3e, 0x33, 0xea, 0x47, 0xe0, 0x45, - 0x04, 0x22, 0x14, 0x21, 0x11, 0x13, 0xe3, 0xa8, 0x1f, 0x19, 0x97, 0xac, 0x08, 0xac, 0xc6, 0x40, 0xc9, 0x1d, 0xe1, - 0xa9, 0xaa, 0x88, 0x58, 0x58, 0x53, 0x07, 0x95, 0x58, 0x6a, 0xcc, 0xb4, 0x4f, 0x3a, 0x15, 0x08, 0xb3, 0x6c, 0x5b, - 0x50, 0xd6, 0x5b, 0xea, 0x02, 0x2c, 0x89, 0x31, 0xbd, 0xe5, 0xc9, 0x47, 0xe0, 0xe6, 0xd8, 0xd8, 0x15, 0x5d, 0xf1, - 0x6b, 0x50, 0x4f, 0xa7, 0x05, 0xfe, 0x68, 0x18, 0xb6, 0x71, 0x4a, 0x37, 0x84, 0xe3, 0x8c, 0x14, 0x09, 0xbd, 0x85, - 0x38, 0x17, 0x73, 0x2e, 0xd2, 0x1c, 0xcf, 0xe9, 0x6d, 0x3a, 0xc3, 0x73, 0x2e, 0x9e, 0xd8, 0x65, 0x4f, 0xc7, 0x90, - 0xe4, 0x3f, 0x96, 0x1b, 0x62, 0x9e, 0xe9, 0x7a, 0xa7, 0x58, 0xf1, 0x08, 0x78, 0x15, 0x15, 0xa3, 0xde, 0xd8, 0xd8, - 0x94, 0x73, 0x5d, 0x19, 0xaf, 0xdf, 0xd3, 0x31, 0xc5, 0x19, 0xce, 0x51, 0x92, 0x4b, 0xcc, 0xfa, 0x22, 0xbd, 0x07, - 0x31, 0xae, 0x33, 0x6c, 0x9f, 0xf8, 0xe2, 0xb7, 0x2c, 0x7f, 0x26, 0x8b, 0xf7, 0x66, 0xcb, 0xe7, 0x08, 0x0a, 0x81, - 0x8b, 0x8a, 0x68, 0xc2, 0xed, 0xde, 0xb2, 0x2f, 0xab, 0xa6, 0xe8, 0xad, 0x6d, 0xca, 0x0d, 0x71, 0x06, 0xc1, 0x81, - 0x93, 0x19, 0x6f, 0xb4, 0x31, 0xeb, 0xb7, 0xbe, 0xd1, 0xe8, 0x0c, 0x95, 0x25, 0x11, 0x86, 0xb5, 0x6a, 0xaa, 0x54, - 0x12, 0xd1, 0x54, 0x4e, 0xc2, 0x5b, 0x19, 0x60, 0xa7, 0x0a, 0x67, 0x72, 0x29, 0x74, 0x2a, 0x03, 0xbc, 0xc9, 0xab, - 0xcd, 0xb5, 0xba, 0xb5, 0x10, 0xd3, 0xf8, 0xce, 0xfe, 0x60, 0xf8, 0xa3, 0x51, 0xf1, 0xbf, 0x01, 0xc3, 0x1e, 0x95, - 0x0a, 0x80, 0x1f, 0x18, 0xce, 0x02, 0xe4, 0x2c, 0x3f, 0x79, 0x0b, 0xe0, 0xb3, 0x2c, 0xe4, 0x1d, 0xa4, 0x32, 0x93, - 0x7a, 0x07, 0xa9, 0x0c, 0x52, 0x8d, 0x77, 0xfb, 0xa1, 0xa8, 0x94, 0x45, 0x61, 0x83, 0x44, 0xe1, 0x52, 0x1d, 0x2c, - 0x89, 0x48, 0xa0, 0x5d, 0x23, 0xca, 0xcd, 0xb9, 0x80, 0x30, 0x87, 0xd0, 0xb8, 0xfd, 0xa6, 0xb7, 0xf0, 0x7d, 0x67, - 0xf3, 0x99, 0xcf, 0xbf, 0xb3, 0xf9, 0xa6, 0x23, 0x8f, 0xf1, 0xf5, 0xdb, 0x4e, 0x63, 0x19, 0x2f, 0x1d, 0xd6, 0xbe, - 0x2b, 0x1f, 0x95, 0x69, 0x99, 0xc7, 0xbb, 0x49, 0x1b, 0xcf, 0x03, 0xa4, 0x6c, 0x56, 0x3c, 0x5c, 0x07, 0xb7, 0x5b, - 0xc7, 0x31, 0x6f, 0x92, 0x36, 0x42, 0xc7, 0x4e, 0xb8, 0x12, 0xb1, 0x91, 0x9c, 0x8e, 0xdf, 0x9f, 0xc0, 0xdd, 0xcb, - 0x48, 0x6d, 0xf9, 0x4a, 0xd9, 0x6a, 0xcd, 0x76, 0xeb, 0x98, 0xef, 0xad, 0xd2, 0x68, 0xe3, 0x39, 0x23, 0x2b, 0xf0, - 0x40, 0xa3, 0x85, 0x55, 0x35, 0x80, 0xcb, 0xea, 0x0b, 0xf1, 0xeb, 0x92, 0x8e, 0xcd, 0xf7, 0xb1, 0x4d, 0x79, 0xb5, - 0xd4, 0x3e, 0xa9, 0xc9, 0x61, 0x10, 0x1d, 0xe4, 0x4a, 0x06, 0x39, 0x31, 0x3f, 0x21, 0x49, 0x17, 0x5d, 0xb6, 0xfb, - 0x49, 0xf7, 0x98, 0x1f, 0xf3, 0x14, 0x78, 0xd8, 0xb8, 0xe9, 0x2b, 0x34, 0xdb, 0xbe, 0xce, 0xe3, 0xe5, 0x88, 0x67, - 0xae, 0xf9, 0xaa, 0x83, 0x32, 0xd5, 0xce, 0x11, 0xb2, 0x00, 0xc5, 0x7c, 0x2f, 0x41, 0x76, 0xbd, 0x9b, 0x63, 0x9e, - 0x42, 0x3f, 0x50, 0xab, 0x63, 0x6b, 0x95, 0x83, 0xfb, 0x75, 0x09, 0x08, 0xe6, 0x3b, 0xaa, 0xcd, 0xc5, 0xa6, 0x37, - 0xe3, 0xaa, 0xb3, 0x63, 0x5e, 0x8d, 0x30, 0x2c, 0xb3, 0xdb, 0x9f, 0x9f, 0x5a, 0xd5, 0xe5, 0x71, 0x00, 0x91, 0x5f, - 0x97, 0x5c, 0x84, 0x9d, 0x86, 0xdd, 0xba, 0x9c, 0xb0, 0xd3, 0xfa, 0x2c, 0x83, 0x22, 0xbb, 0xbd, 0xee, 0xcc, 0xb4, - 0x3e, 0xdb, 0x6b, 0x70, 0x24, 0x84, 0x49, 0x99, 0x95, 0xce, 0xa4, 0x8a, 0xf9, 0xf1, 0x3b, 0xe4, 0x5a, 0x7f, 0xb5, - 0xd4, 0x3e, 0xbf, 0x44, 0x04, 0xc8, 0xae, 0xba, 0x2e, 0xab, 0x43, 0x1f, 0x65, 0x13, 0x2f, 0x8f, 0x79, 0xb0, 0x72, - 0x4f, 0x6f, 0x17, 0x32, 0xf5, 0xf8, 0xda, 0x6f, 0xa5, 0x3b, 0xc8, 0x09, 0xc4, 0xc3, 0x75, 0x17, 0x96, 0x05, 0x39, - 0xbb, 0xb9, 0x83, 0x92, 0xe1, 0xc4, 0x7d, 0xe9, 0x77, 0xcc, 0x5e, 0x37, 0xf0, 0xcb, 0xa4, 0x0b, 0x53, 0xdf, 0xee, - 0xe1, 0xb8, 0x03, 0x7d, 0x18, 0x38, 0x6c, 0x37, 0xe8, 0x33, 0x2b, 0x88, 0x3c, 0xe6, 0x85, 0xc5, 0xb3, 0x2b, 0xd2, - 0xee, 0xf3, 0xd4, 0x6d, 0x26, 0x23, 0x1a, 0xb5, 0x9b, 0x3c, 0x98, 0x19, 0xe0, 0x97, 0x2b, 0x1b, 0x16, 0xf1, 0xeb, - 0x14, 0x40, 0xc9, 0x17, 0xab, 0xd6, 0xa7, 0x82, 0x57, 0xbd, 0xe1, 0x74, 0x3b, 0xdd, 0xaf, 0x1b, 0xdc, 0xee, 0x7a, - 0x78, 0xc2, 0xa3, 0x30, 0x16, 0xad, 0xfd, 0xc4, 0xe7, 0xc0, 0x01, 0x25, 0xad, 0xfb, 0x5d, 0x70, 0xa1, 0x2c, 0x61, - 0xb9, 0x5b, 0x6e, 0xb4, 0x53, 0xce, 0xc2, 0xd1, 0x96, 0x0c, 0xb8, 0x83, 0x6d, 0x88, 0x42, 0x07, 0xc7, 0x1d, 0x9c, - 0xb4, 0xdb, 0x9d, 0x2e, 0x4e, 0xce, 0xba, 0x30, 0xd0, 0x46, 0xd2, 0x3d, 0x1e, 0x29, 0x0b, 0xc0, 0x20, 0x67, 0xe3, - 0xda, 0x7d, 0x04, 0x01, 0xa4, 0x42, 0xf1, 0x9a, 0x1f, 0xc7, 0x71, 0x3b, 0xb9, 0xdf, 0x6a, 0x77, 0x2f, 0x1a, 0x00, - 0xa0, 0xa6, 0xfb, 0x70, 0x35, 0x5e, 0x2d, 0x75, 0xbd, 0x4a, 0x89, 0xf0, 0xf5, 0x6a, 0x0d, 0x5f, 0xad, 0xd1, 0xde, - 0x54, 0x53, 0xf0, 0x55, 0x9d, 0x70, 0x6e, 0x8b, 0x78, 0xa5, 0x4d, 0xb8, 0x2d, 0x62, 0x3b, 0x90, 0x18, 0xa4, 0xf3, - 0xa4, 0xdb, 0xe9, 0x22, 0x3b, 0x16, 0xed, 0xf0, 0xa3, 0xdc, 0x27, 0x3b, 0x45, 0x1a, 0x1a, 0x90, 0xa4, 0x9c, 0x9d, - 0x5c, 0x82, 0x44, 0xcd, 0xc9, 0x55, 0xbb, 0x39, 0x67, 0x89, 0x9f, 0x80, 0x49, 0x85, 0xe5, 0x2c, 0x57, 0xc1, 0x25, - 0x05, 0x80, 0xb8, 0x04, 0xe3, 0xa2, 0xfb, 0xdd, 0xfe, 0xfd, 0xa4, 0x7b, 0xde, 0xb1, 0x44, 0x8f, 0x5f, 0x76, 0x6a, - 0x69, 0x66, 0xea, 0x49, 0xd7, 0xa4, 0x41, 0xd7, 0xc9, 0xfd, 0x2e, 0x94, 0x71, 0x29, 0x61, 0x29, 0x08, 0x7c, 0x51, - 0x15, 0x83, 0x68, 0x17, 0x69, 0x2d, 0xf7, 0xbc, 0x96, 0x7d, 0x71, 0x76, 0x7a, 0xbf, 0x1b, 0x42, 0xad, 0x9c, 0x85, - 0x59, 0x68, 0x37, 0x11, 0x3f, 0x3b, 0x58, 0x5a, 0x74, 0x9c, 0x74, 0xd3, 0x9d, 0x09, 0xda, 0x4d, 0x73, 0x6c, 0x70, - 0x20, 0x50, 0x38, 0xbe, 0x10, 0x4e, 0x5f, 0x12, 0xdc, 0x8f, 0x55, 0x86, 0x26, 0xa1, 0xc2, 0xd9, 0xdf, 0x53, 0x06, - 0x6f, 0x5b, 0x86, 0x57, 0x95, 0x8f, 0xa9, 0xf8, 0x42, 0xd5, 0x6b, 0x0a, 0xd1, 0x3c, 0xc4, 0x30, 0x72, 0xb1, 0xc6, - 0xeb, 0xb9, 0x3f, 0x80, 0x8b, 0x30, 0x13, 0x70, 0xa1, 0xe9, 0x95, 0xa0, 0x15, 0x2f, 0xf0, 0x31, 0x74, 0xa8, 0x35, - 0xc3, 0xea, 0xf3, 0xd4, 0x99, 0x14, 0x84, 0xba, 0xad, 0x77, 0xfc, 0x5b, 0xe5, 0x92, 0xf2, 0x2a, 0x3b, 0xe9, 0xa2, - 0xc4, 0x5d, 0x96, 0x27, 0x6d, 0x94, 0x04, 0x26, 0x24, 0xee, 0x48, 0x9e, 0x65, 0x64, 0x10, 0xdd, 0x46, 0x38, 0xba, - 0x8b, 0x70, 0x64, 0x7d, 0x98, 0x7f, 0x03, 0x3f, 0xee, 0x08, 0x47, 0xd6, 0x95, 0x39, 0xc2, 0x91, 0x66, 0x02, 0x82, - 0x7c, 0x45, 0x43, 0x3c, 0x86, 0xd2, 0xc6, 0xb3, 0xba, 0x2c, 0xfd, 0xd8, 0x7f, 0x95, 0xae, 0xd7, 0x36, 0x25, 0x90, - 0x32, 0x97, 0x66, 0x87, 0xda, 0x47, 0xaa, 0x23, 0xea, 0x99, 0xf5, 0x08, 0x83, 0x00, 0x42, 0xef, 0xfc, 0x23, 0x77, - 0x55, 0x7c, 0x10, 0x76, 0x0a, 0x2b, 0x0d, 0xae, 0xe8, 0x51, 0x78, 0x86, 0x45, 0x78, 0x22, 0x7c, 0x61, 0x10, 0x2b, - 0xfc, 0xef, 0x5c, 0xca, 0x85, 0xff, 0xad, 0x65, 0xf9, 0x0b, 0x9e, 0x46, 0x71, 0x16, 0x2d, 0x60, 0xb9, 0x65, 0xc3, - 0x11, 0x8d, 0x58, 0x7d, 0x04, 0x1f, 0x27, 0x2e, 0x64, 0x1c, 0x48, 0x84, 0x1f, 0x8d, 0x40, 0xe5, 0xe5, 0xc3, 0x8f, - 0x36, 0x7c, 0x91, 0xf9, 0x84, 0xf8, 0x65, 0x10, 0xa2, 0x58, 0xc2, 0x85, 0xc6, 0xb4, 0x60, 0x4a, 0x45, 0x36, 0xae, - 0x5f, 0x24, 0x85, 0x7f, 0xa8, 0xd1, 0xa7, 0x4c, 0x44, 0x64, 0x3a, 0xac, 0xcf, 0xd6, 0x8a, 0xc3, 0xb9, 0x2c, 0x54, - 0x6a, 0x5f, 0x6d, 0xf1, 0x60, 0x5c, 0x94, 0x4f, 0x22, 0xa6, 0xe3, 0x6c, 0x83, 0xed, 0x1d, 0x76, 0x59, 0xc8, 0x5d, - 0x69, 0x87, 0xa5, 0x66, 0xd9, 0xe6, 0x6b, 0x13, 0x52, 0xb5, 0x19, 0x05, 0x13, 0xad, 0x06, 0x54, 0x05, 0xee, 0x80, - 0xc2, 0x36, 0x40, 0x4c, 0xba, 0x2a, 0x4b, 0xa6, 0xab, 0x72, 0x19, 0xce, 0x5a, 0xad, 0xcd, 0x06, 0x17, 0xcc, 0x04, - 0x55, 0xd9, 0x5b, 0x02, 0xf2, 0xd5, 0x4c, 0xde, 0x04, 0xb9, 0x2a, 0x2d, 0x67, 0x69, 0x96, 0x28, 0x0a, 0x8c, 0x60, - 0xa3, 0x0d, 0xfe, 0xc2, 0x15, 0x07, 0x78, 0xba, 0xd9, 0x8d, 0xa4, 0xcc, 0x19, 0x85, 0x78, 0x66, 0x41, 0x93, 0x1b, - 0x3c, 0xe3, 0x63, 0xb6, 0xbf, 0x4d, 0x30, 0x63, 0xfe, 0xf7, 0x5a, 0xf4, 0x08, 0x64, 0xd9, 0x3d, 0x83, 0x3a, 0xb0, - 0x88, 0x6b, 0xe8, 0x20, 0x94, 0xc1, 0x27, 0x21, 0x6e, 0xe6, 0xf4, 0x4e, 0x2e, 0x35, 0xc0, 0x65, 0xa9, 0xe5, 0x6b, - 0x17, 0x0e, 0xe1, 0xb0, 0x85, 0x7d, 0x64, 0x84, 0x15, 0x84, 0x0c, 0x68, 0x61, 0x1b, 0x11, 0xa3, 0x85, 0x5d, 0xa0, - 0x82, 0x16, 0x36, 0xe1, 0x29, 0x5a, 0x9b, 0x32, 0xce, 0xd8, 0x5d, 0xf9, 0xbc, 0x65, 0xb5, 0x09, 0x16, 0x4e, 0x3a, - 0xd4, 0x44, 0x07, 0xb7, 0x87, 0x8c, 0xf0, 0xc6, 0x8f, 0xd7, 0xaf, 0x5e, 0xba, 0x28, 0xd2, 0x7c, 0x02, 0x2e, 0x9b, - 0x4e, 0x35, 0x76, 0x67, 0xc3, 0xbd, 0x57, 0x8a, 0x52, 0x2b, 0x9c, 0x9a, 0xc0, 0x9b, 0x42, 0xe7, 0x89, 0xbd, 0xbc, - 0x78, 0x26, 0x8b, 0x39, 0xb5, 0x37, 0x46, 0xf8, 0x4e, 0xb9, 0x87, 0xe0, 0xcd, 0x5b, 0x33, 0xd5, 0x24, 0xdf, 0x6e, - 0x5f, 0x45, 0x2c, 0x32, 0x23, 0xbf, 0x82, 0x36, 0xc0, 0x54, 0xf6, 0x03, 0x67, 0x05, 0x71, 0xb1, 0xf8, 0x03, 0xf2, - 0xf2, 0xc6, 0x52, 0x97, 0x28, 0x6a, 0x70, 0x83, 0x9f, 0xac, 0xe0, 0x59, 0x70, 0x5d, 0x68, 0xd8, 0x23, 0x27, 0x5e, - 0x44, 0xad, 0xa8, 0xfe, 0x0e, 0xae, 0x51, 0x25, 0xf8, 0x38, 0xae, 0x49, 0x2e, 0x41, 0xf4, 0x28, 0x9f, 0xdc, 0xe3, - 0x20, 0x9a, 0xf8, 0xbb, 0xe7, 0xab, 0xb6, 0xa7, 0xb3, 0x79, 0xa5, 0x4e, 0x2c, 0xaf, 0x4c, 0xc0, 0xc3, 0xd1, 0x3e, - 0x6a, 0x83, 0x70, 0x90, 0xc8, 0x4a, 0xed, 0xa1, 0xcf, 0x45, 0xbd, 0x38, 0xbf, 0x6c, 0xb3, 0xe6, 0xd9, 0x7a, 0x9d, - 0x5f, 0xb5, 0x59, 0xbb, 0x6b, 0x9f, 0xc0, 0x8b, 0x54, 0x06, 0x34, 0x97, 0x4f, 0x78, 0x16, 0x81, 0x76, 0x76, 0x9a, - 0x99, 0x70, 0x0a, 0x1b, 0xaf, 0xf8, 0x59, 0xea, 0xaa, 0x2f, 0x09, 0xc6, 0xa5, 0xc4, 0xea, 0xf1, 0x0b, 0xd4, 0x6f, - 0xa7, 0xbb, 0xae, 0xd2, 0xcd, 0xf6, 0x71, 0x70, 0xe1, 0x52, 0x20, 0xdc, 0x81, 0x90, 0x07, 0xa0, 0xdf, 0x5d, 0x09, - 0x30, 0x0d, 0x02, 0x54, 0x56, 0x20, 0xd2, 0xf2, 0xf9, 0x72, 0xfe, 0xac, 0xa0, 0x66, 0x19, 0x9e, 0xf0, 0x29, 0xd7, - 0x2a, 0xa5, 0x20, 0xdd, 0xee, 0x4b, 0xdf, 0xec, 0x97, 0xa0, 0xb2, 0x5a, 0x2c, 0xdc, 0x44, 0xf3, 0xec, 0xb3, 0x72, - 0x0b, 0x87, 0xb0, 0x59, 0x59, 0x81, 0x33, 0xb4, 0xc1, 0xb9, 0x9c, 0xd2, 0x82, 0xeb, 0xd9, 0xfc, 0xdf, 0x5a, 0x1d, - 0x36, 0xd0, 0x43, 0x73, 0x61, 0x05, 0x20, 0xa1, 0x62, 0xbc, 0x5e, 0xf3, 0x93, 0x6f, 0xdf, 0x27, 0x79, 0x9f, 0xf0, - 0x36, 0xee, 0xe0, 0x53, 0xdc, 0xc5, 0xed, 0x16, 0x6e, 0x77, 0xe1, 0xea, 0x3e, 0xcb, 0x97, 0x63, 0xa6, 0x62, 0x78, - 0x0b, 0x4d, 0x5f, 0x25, 0x17, 0xc7, 0xd5, 0x0b, 0x00, 0x45, 0xe2, 0xd0, 0x25, 0x08, 0x44, 0xef, 0x22, 0xf8, 0x45, - 0x51, 0x18, 0x3e, 0x6e, 0x1a, 0xaa, 0x4e, 0x4a, 0xfd, 0xc2, 0xd5, 0x69, 0x1f, 0xec, 0xb9, 0xed, 0xca, 0x36, 0xc1, - 0xec, 0xdb, 0xfe, 0x4c, 0xab, 0x9f, 0x4d, 0x5d, 0x22, 0x86, 0x87, 0x5e, 0x85, 0x1e, 0xe8, 0x8a, 0xb4, 0x8f, 0x8e, - 0xc0, 0xea, 0x28, 0x98, 0x0d, 0xb7, 0xd1, 0x0f, 0x78, 0xb3, 0x96, 0x06, 0xc1, 0x0a, 0xc0, 0xb8, 0xf3, 0x15, 0x27, - 0x2b, 0x0b, 0x5b, 0x0d, 0x54, 0x98, 0x15, 0x61, 0x8c, 0xbb, 0x90, 0x54, 0x18, 0x21, 0x1a, 0x8e, 0x30, 0x17, 0x0c, - 0xe5, 0xb0, 0x85, 0xe5, 0x64, 0xa2, 0x98, 0x86, 0xa3, 0xa3, 0x60, 0x5f, 0x58, 0xa1, 0xcc, 0x29, 0x32, 0x62, 0x53, - 0x2e, 0x1e, 0xea, 0x3f, 0x58, 0x21, 0xcd, 0xa7, 0xd1, 0x60, 0xa4, 0x91, 0x59, 0xc5, 0x08, 0x67, 0x39, 0x5f, 0x40, - 0xd5, 0x69, 0x01, 0x4e, 0x3f, 0xf0, 0x97, 0x8f, 0xd3, 0xb0, 0x4d, 0x20, 0x5f, 0xbf, 0xd9, 0x98, 0x2e, 0x78, 0x5c, - 0xd0, 0x9b, 0x57, 0xe2, 0x31, 0xec, 0xa8, 0x87, 0x05, 0xa3, 0x90, 0x0d, 0x49, 0x6f, 0xa1, 0x29, 0xf8, 0x80, 0x36, - 0x7f, 0x36, 0x80, 0x4b, 0x2f, 0xcc, 0x87, 0xad, 0xe8, 0xe3, 0x28, 0x26, 0x65, 0x5b, 0x26, 0xd3, 0x9c, 0xd2, 0x55, - 0xa6, 0xa1, 0xb0, 0xd5, 0x14, 0x36, 0xd8, 0x45, 0x3d, 0x09, 0x07, 0x33, 0xa6, 0x6a, 0x96, 0x0e, 0x86, 0xe6, 0xef, - 0x2b, 0x5b, 0xb2, 0x85, 0x5d, 0xc4, 0x99, 0x0d, 0x36, 0x8f, 0x98, 0x06, 0xe5, 0xdb, 0x18, 0xee, 0x61, 0xe1, 0x25, - 0xcd, 0x1a, 0xf9, 0x3c, 0xf3, 0x64, 0xf3, 0x6c, 0xb3, 0x31, 0x03, 0x51, 0x29, 0xe8, 0x81, 0xde, 0xf8, 0x6d, 0xd3, - 0x82, 0xed, 0x51, 0x7e, 0x75, 0x5b, 0x78, 0xce, 0xe1, 0x61, 0x50, 0xdf, 0xde, 0xb5, 0x2e, 0xe4, 0x67, 0x07, 0x92, - 0x56, 0x90, 0x62, 0xa7, 0x13, 0x74, 0x76, 0x8a, 0x83, 0x91, 0x03, 0x3d, 0xbf, 0xfe, 0x6c, 0x61, 0xed, 0x7f, 0xbf, - 0x2e, 0x0b, 0x9a, 0x78, 0x3a, 0xe5, 0x84, 0x32, 0x7f, 0x7e, 0xbe, 0xe2, 0x49, 0x85, 0x0a, 0xee, 0x45, 0x2d, 0xd8, - 0xd3, 0x36, 0xe8, 0xe6, 0x9c, 0x7e, 0xb2, 0x3f, 0x6c, 0x0c, 0x9f, 0x52, 0xcb, 0x96, 0x15, 0x52, 0xa9, 0x87, 0x36, - 0xcd, 0x1e, 0x3d, 0x70, 0x44, 0xfe, 0x0c, 0x5d, 0x00, 0xaf, 0x3f, 0x2e, 0xe4, 0xc2, 0x20, 0x82, 0xfb, 0xed, 0xc6, - 0x6d, 0x7c, 0x05, 0xc0, 0xdb, 0xe1, 0xa0, 0xfa, 0xa7, 0x05, 0xec, 0x6f, 0x54, 0x96, 0xf4, 0xe3, 0xed, 0xd8, 0xe3, - 0xbf, 0x90, 0x10, 0xc1, 0xdd, 0xe2, 0x61, 0xe2, 0xd0, 0xa9, 0x64, 0xcd, 0xca, 0x9f, 0x3b, 0x25, 0x01, 0xc3, 0xea, - 0x05, 0x43, 0x36, 0x6e, 0xa7, 0xb8, 0xcd, 0xfc, 0x0f, 0x2a, 0x18, 0x2c, 0xf8, 0xda, 0x48, 0x2a, 0x96, 0xc5, 0x6f, - 0x9f, 0x3a, 0xff, 0x55, 0xe7, 0xb8, 0x0e, 0x75, 0xed, 0xd5, 0xce, 0x91, 0x89, 0x98, 0x1c, 0xa1, 0xa3, 0xa3, 0xad, - 0x0c, 0x3a, 0x01, 0xc0, 0x23, 0xc7, 0x7e, 0xf9, 0xe5, 0xf3, 0xec, 0x98, 0xd1, 0x3c, 0x16, 0x51, 0xc8, 0xdc, 0x79, - 0x6e, 0xce, 0x4e, 0xe4, 0x09, 0x55, 0x33, 0x5f, 0x18, 0xe0, 0xf8, 0x68, 0x27, 0x15, 0xf0, 0x3d, 0xda, 0xec, 0x99, - 0xc0, 0x16, 0xbf, 0x65, 0x27, 0xb5, 0xaf, 0xa0, 0x5f, 0xa0, 0xd5, 0x3e, 0xa6, 0x72, 0x6b, 0x81, 0xa3, 0xed, 0x89, - 0xec, 0x1d, 0xfa, 0x56, 0x9d, 0x92, 0xf5, 0x78, 0xb1, 0xdf, 0xe8, 0xab, 0x10, 0xfb, 0x92, 0x2b, 0xda, 0x36, 0x62, - 0xd5, 0xcb, 0xbd, 0xba, 0x32, 0x75, 0xaa, 0xae, 0x79, 0x2b, 0x4b, 0x9b, 0xd2, 0x2e, 0xc9, 0xde, 0x6d, 0xb1, 0xf0, - 0x2a, 0xbc, 0xd1, 0x28, 0x2f, 0x42, 0xc1, 0x1e, 0x4b, 0x0c, 0x7b, 0x9c, 0xc0, 0xf5, 0xc2, 0x7a, 0x1d, 0xc3, 0x9f, - 0x7d, 0x63, 0xd8, 0x67, 0xba, 0xf4, 0x1b, 0xdf, 0xe2, 0x57, 0x82, 0xe0, 0xc1, 0xce, 0x0e, 0x12, 0xac, 0xbb, 0xdc, - 0xa0, 0xe1, 0x38, 0xf1, 0x5f, 0xf0, 0x74, 0xb5, 0xf6, 0x2e, 0x07, 0xa3, 0xec, 0x2b, 0xcf, 0xdd, 0x95, 0xac, 0x65, - 0x2d, 0xf2, 0xfc, 0x96, 0x04, 0x43, 0xec, 0xa6, 0x74, 0x8e, 0x5b, 0x49, 0x1b, 0x45, 0xae, 0x58, 0x85, 0xfe, 0x5f, - 0x2b, 0x92, 0xd9, 0xcc, 0xff, 0x3a, 0x3f, 0x3f, 0x77, 0x29, 0xce, 0xe6, 0x4f, 0x19, 0x0f, 0x38, 0x93, 0xc0, 0xbe, - 0xf0, 0x8c, 0x19, 0x1d, 0xf2, 0x1b, 0x18, 0x0a, 0x11, 0xe4, 0x4a, 0x38, 0x76, 0x09, 0x5e, 0x5e, 0x04, 0xca, 0x03, - 0xec, 0xdf, 0x93, 0xad, 0x72, 0xfe, 0xe9, 0x26, 0x1f, 0xda, 0xb8, 0x6c, 0x90, 0x7d, 0x31, 0x9f, 0x03, 0x6b, 0x26, - 0x03, 0xaf, 0x15, 0x44, 0xd8, 0xfe, 0x36, 0x2c, 0xad, 0xb3, 0x94, 0xc1, 0x91, 0x96, 0xcb, 0x6c, 0x66, 0x35, 0xff, - 0xee, 0xc3, 0x94, 0x75, 0xcf, 0xfe, 0x40, 0xe4, 0x2e, 0xb2, 0x72, 0x11, 0x3a, 0xa3, 0xef, 0xcb, 0x60, 0x9c, 0x07, - 0x2f, 0xd9, 0x92, 0x7d, 0x8f, 0x0f, 0xaa, 0x14, 0xf8, 0x78, 0x58, 0x70, 0x9a, 0x7f, 0x8f, 0x0f, 0xaa, 0xa0, 0x9c, - 0xe0, 0x0a, 0x69, 0xe2, 0x5a, 0x62, 0xf3, 0xc4, 0x75, 0x1a, 0x09, 0xa0, 0xa0, 0x79, 0x64, 0x0e, 0xb2, 0xe7, 0x2e, - 0x5e, 0x62, 0xd2, 0xc1, 0x2e, 0x38, 0x98, 0x8d, 0xce, 0x6a, 0x83, 0x9a, 0x43, 0xdc, 0xba, 0x72, 0x36, 0xe6, 0xeb, - 0xd1, 0xd6, 0x82, 0x18, 0x65, 0x32, 0xb9, 0x7a, 0xc7, 0xe3, 0x9d, 0xc5, 0x42, 0x61, 0xb5, 0x60, 0x81, 0x6a, 0x55, - 0xaa, 0xf4, 0xb0, 0xf8, 0x6e, 0xc1, 0x2c, 0x28, 0x62, 0xb6, 0xde, 0xc3, 0x5b, 0xae, 0x08, 0x48, 0xc9, 0x2e, 0x09, - 0x5e, 0x29, 0x37, 0x98, 0xea, 0x1f, 0xa5, 0x07, 0x42, 0xcf, 0x94, 0x8e, 0xb0, 0xc9, 0x53, 0x10, 0x49, 0xec, 0xb0, - 0x85, 0x1d, 0x6b, 0xf4, 0x42, 0x78, 0x21, 0x05, 0xce, 0x55, 0xd3, 0xc4, 0x9c, 0x72, 0x13, 0x5d, 0xec, 0xa1, 0x5a, - 0xb0, 0x4c, 0x5b, 0x04, 0x38, 0x74, 0x68, 0x28, 0xc5, 0x73, 0x03, 0x0a, 0xf3, 0xbc, 0xb6, 0x4b, 0x79, 0x0c, 0x8b, - 0x17, 0xa4, 0x00, 0x51, 0xe3, 0x62, 0x5a, 0xd6, 0x59, 0xe4, 0xcb, 0x29, 0x17, 0x15, 0x32, 0x14, 0x4c, 0x2d, 0xa4, - 0x80, 0xd7, 0x2d, 0xca, 0x22, 0x86, 0x0e, 0xd5, 0xf0, 0xdd, 0x92, 0xb0, 0xb2, 0x8e, 0x39, 0xa6, 0xb8, 0xa8, 0x6a, - 0x00, 0x73, 0xf1, 0xd0, 0x08, 0x88, 0x3e, 0xd4, 0xeb, 0x2b, 0xf1, 0x56, 0x2e, 0xaa, 0x7c, 0x4f, 0xe3, 0x7c, 0x10, - 0x79, 0x67, 0x37, 0x8c, 0x36, 0xe6, 0x01, 0xaa, 0x60, 0xfb, 0xfe, 0xc6, 0xab, 0x47, 0xd9, 0x36, 0xe6, 0x09, 0xab, - 0x32, 0x6b, 0xc4, 0xca, 0xf7, 0x1a, 0xaa, 0xf6, 0xea, 0x55, 0x0b, 0x61, 0x2b, 0x02, 0x54, 0x0a, 0x3e, 0xde, 0xc9, - 0x7f, 0xa1, 0x6d, 0xbe, 0x3d, 0x87, 0xca, 0xf0, 0x40, 0x9e, 0x0c, 0x55, 0x3d, 0xe0, 0xa2, 0xfc, 0x10, 0xc0, 0xe2, - 0x47, 0x26, 0x96, 0xef, 0xbe, 0x0b, 0x64, 0xce, 0x54, 0x2c, 0xf1, 0x6a, 0x40, 0x87, 0xa9, 0x95, 0x87, 0x52, 0x09, - 0xb6, 0x3d, 0x37, 0x05, 0xd7, 0x3e, 0x68, 0x30, 0x1e, 0xb0, 0x61, 0xba, 0xaa, 0x07, 0x16, 0xb6, 0xa1, 0x8d, 0xbd, - 0x39, 0xa7, 0x89, 0xc4, 0x4b, 0x87, 0x38, 0x27, 0x60, 0x7b, 0x5c, 0x32, 0xf7, 0x71, 0x86, 0xfa, 0x75, 0x0e, 0x7f, - 0xb5, 0xc1, 0x39, 0xce, 0x50, 0xfa, 0x30, 0x86, 0x0b, 0xac, 0x0d, 0x06, 0xf0, 0x65, 0x96, 0x54, 0x81, 0x47, 0x6a, - 0x66, 0x24, 0x56, 0x77, 0x11, 0x88, 0x56, 0x3a, 0xbc, 0x1d, 0x67, 0x3e, 0x34, 0xb7, 0xe1, 0x5e, 0x9f, 0x19, 0xe1, - 0x70, 0x94, 0xc5, 0xb5, 0x73, 0x86, 0x93, 0xab, 0x43, 0x5e, 0x3b, 0x31, 0xc1, 0xda, 0x3b, 0x3c, 0x55, 0x40, 0x8f, - 0x06, 0xa7, 0x8a, 0xa5, 0x21, 0x10, 0x33, 0x01, 0xbc, 0x99, 0xc3, 0xa3, 0x2d, 0xc0, 0xf9, 0x68, 0x83, 0x83, 0xaf, - 0xb4, 0xd6, 0xd5, 0xb6, 0x12, 0x65, 0xb3, 0xc1, 0x83, 0x65, 0x86, 0x27, 0x19, 0x9e, 0x67, 0xc3, 0xe0, 0xb8, 0xf9, - 0x98, 0x85, 0x26, 0x5d, 0xeb, 0xf5, 0x0b, 0x67, 0x46, 0x88, 0xec, 0x4f, 0x4b, 0x7f, 0x50, 0x1f, 0x10, 0x3e, 0x85, - 0x2c, 0xa0, 0x25, 0x7d, 0xf7, 0xb7, 0x61, 0x5f, 0xee, 0x46, 0x8d, 0x98, 0x27, 0x96, 0x8c, 0xf4, 0xfd, 0x8f, 0x32, - 0xcb, 0xb6, 0xd6, 0x88, 0x16, 0xb7, 0x07, 0x51, 0xc3, 0xb7, 0x57, 0x9d, 0x2f, 0xa3, 0xd2, 0x6c, 0x07, 0x10, 0xc5, - 0x1a, 0x27, 0xe9, 0x60, 0x8d, 0xe4, 0x7a, 0x1d, 0xdb, 0x14, 0xc2, 0x93, 0x39, 0xa3, 0x6a, 0x59, 0x98, 0xc7, 0xec, - 0x62, 0x85, 0x12, 0xc3, 0xef, 0x62, 0x67, 0x23, 0x0a, 0x6f, 0xc7, 0x49, 0x30, 0xdc, 0x88, 0x05, 0x91, 0x35, 0x91, - 0xfb, 0x2e, 0xab, 0x2c, 0x83, 0x04, 0x11, 0x46, 0xe4, 0xb7, 0xd7, 0xa5, 0xc2, 0x3e, 0x97, 0x67, 0xff, 0x18, 0x5f, - 0x40, 0xb8, 0x79, 0x9b, 0xd2, 0x62, 0x44, 0xa7, 0xc0, 0xc6, 0x42, 0x1c, 0xc2, 0x9d, 0x84, 0xf5, 0x7a, 0x30, 0xec, - 0x09, 0x43, 0x9e, 0xdd, 0x63, 0x7e, 0x65, 0x43, 0xfb, 0x1b, 0x80, 0xab, 0x6e, 0x4b, 0xcd, 0xb5, 0xd1, 0xfd, 0x50, - 0xf3, 0xde, 0x18, 0x77, 0x49, 0xee, 0xc9, 0x90, 0xea, 0x55, 0xf0, 0x9a, 0x05, 0xb8, 0x09, 0x5d, 0x85, 0xc7, 0x78, - 0x69, 0x6d, 0x38, 0xcd, 0xe3, 0x52, 0xd4, 0xbc, 0x29, 0x05, 0x4f, 0x59, 0x13, 0x36, 0xc8, 0x86, 0x78, 0xec, 0x43, - 0x8f, 0x1f, 0xbe, 0x89, 0xc7, 0x08, 0x15, 0xc4, 0xc0, 0xd4, 0xba, 0x6c, 0x8f, 0x2b, 0xbb, 0x7d, 0x93, 0x69, 0x18, - 0x06, 0x63, 0xc4, 0x3c, 0x0e, 0x8d, 0x98, 0xf3, 0x46, 0x03, 0x2d, 0xc9, 0x18, 0x8c, 0x98, 0x97, 0x41, 0x6b, 0x4b, - 0xfb, 0xf0, 0x68, 0xd0, 0xde, 0x12, 0xa1, 0x1e, 0x07, 0x9a, 0xa6, 0xe1, 0x89, 0x91, 0xea, 0x89, 0x77, 0xff, 0xe0, - 0xd5, 0x49, 0x07, 0x14, 0x09, 0x93, 0x2b, 0x3f, 0x09, 0xeb, 0x1a, 0x6e, 0xc7, 0x3d, 0x31, 0xe3, 0x76, 0xb6, 0x0d, - 0x6a, 0x20, 0x07, 0xd9, 0x70, 0xd8, 0x93, 0xde, 0x4a, 0xa2, 0x85, 0x27, 0xd5, 0xa3, 0x24, 0xd5, 0xe2, 0x7d, 0xd1, - 0xdb, 0x57, 0xde, 0xdc, 0xbf, 0x75, 0xba, 0x7d, 0x1e, 0x03, 0x07, 0x74, 0x08, 0xf7, 0x43, 0x55, 0x7c, 0xb0, 0x93, - 0x0e, 0x44, 0x41, 0x4b, 0x5b, 0x35, 0x81, 0xd4, 0x9a, 0xd9, 0xc5, 0xba, 0xa9, 0xd0, 0xb1, 0x80, 0x30, 0x64, 0xaa, - 0xea, 0xee, 0x56, 0x05, 0xaa, 0x21, 0x0e, 0xa7, 0xfe, 0x63, 0x6b, 0xc4, 0x1a, 0x47, 0x9d, 0x71, 0x64, 0x8c, 0x24, - 0xed, 0xf2, 0xc1, 0x3b, 0x44, 0x60, 0x25, 0xe0, 0xe3, 0x41, 0x9b, 0x24, 0x63, 0x48, 0xf0, 0x86, 0x65, 0xda, 0xf0, - 0x21, 0xdc, 0x21, 0x28, 0x4f, 0x6c, 0x50, 0x5a, 0x57, 0xc9, 0x42, 0x2e, 0xe8, 0x32, 0x40, 0xcf, 0x2f, 0xe5, 0x6f, - 0x6c, 0x38, 0xb2, 0x00, 0x0e, 0xd9, 0xce, 0x3e, 0x01, 0x8f, 0x7c, 0x5c, 0x21, 0x88, 0x5f, 0x0a, 0x9d, 0x98, 0xd8, - 0xd9, 0xd7, 0xb0, 0x41, 0xf1, 0x02, 0x1c, 0x04, 0x9d, 0x04, 0x87, 0xc1, 0xbb, 0xcc, 0x6a, 0x92, 0x0d, 0x6e, 0xcd, - 0x49, 0xbc, 0x58, 0xaf, 0x5b, 0xe8, 0xf8, 0x27, 0xf3, 0x3c, 0xf4, 0xa4, 0x54, 0xb8, 0x4f, 0x2a, 0x85, 0x3b, 0x58, - 0x02, 0x92, 0x49, 0xa0, 0x6b, 0xc7, 0x32, 0x54, 0xa3, 0x43, 0xe4, 0xf2, 0x17, 0x10, 0xc7, 0xda, 0x1d, 0x4b, 0xa0, - 0x67, 0xdf, 0x29, 0x60, 0x75, 0xed, 0x65, 0x09, 0x64, 0x04, 0x77, 0xbf, 0x09, 0x8c, 0x0a, 0xd1, 0xf8, 0xfc, 0x99, - 0x17, 0x26, 0x78, 0xe2, 0xfc, 0xb9, 0xe6, 0x86, 0x75, 0x2f, 0xe8, 0x8d, 0x69, 0x3e, 0x9e, 0xe0, 0xe6, 0xc4, 0x82, - 0xf3, 0xa4, 0x03, 0x3f, 0x2d, 0x44, 0x4f, 0x3a, 0xd8, 0xa5, 0xe2, 0x49, 0x09, 0xe4, 0x10, 0x3d, 0x9d, 0x81, 0x14, - 0xb0, 0xd2, 0xb1, 0xd5, 0x22, 0x4d, 0xd1, 0x7a, 0x3d, 0xbd, 0x24, 0x2d, 0x84, 0x56, 0xea, 0x86, 0xeb, 0x6c, 0x06, - 0x3e, 0xd2, 0xa0, 0x18, 0x78, 0x4d, 0xf5, 0x2c, 0x46, 0x78, 0x82, 0x56, 0x63, 0x36, 0xa1, 0xcb, 0x5c, 0xa7, 0xaa, - 0xcf, 0x13, 0x1b, 0xb8, 0x97, 0xd9, 0x48, 0x70, 0x27, 0x1d, 0x3c, 0x35, 0xfc, 0xe5, 0x7b, 0x63, 0x0e, 0x52, 0x64, - 0x26, 0x79, 0x6a, 0x12, 0x30, 0x4f, 0xb2, 0x5c, 0x2a, 0x66, 0x9b, 0xe9, 0x59, 0xdb, 0x72, 0x08, 0x0f, 0x1e, 0xe9, - 0x82, 0x1b, 0x2b, 0xca, 0x28, 0x9d, 0x11, 0xd5, 0x57, 0x27, 0x9d, 0x74, 0x8a, 0x79, 0x02, 0x9c, 0xde, 0x5b, 0x19, - 0xb3, 0x46, 0x79, 0x2b, 0x3a, 0x47, 0xc7, 0x33, 0x2c, 0xaa, 0x4b, 0xd4, 0x39, 0x3a, 0x9e, 0x22, 0x3c, 0x6f, 0x90, - 0x99, 0x02, 0x8f, 0x61, 0x2e, 0xfe, 0x8f, 0x94, 0xff, 0xea, 0xb0, 0x21, 0xc4, 0xf4, 0x1b, 0xd8, 0x29, 0x6c, 0x1c, - 0xa5, 0x39, 0x01, 0xaf, 0xc5, 0xf6, 0x39, 0xce, 0xc8, 0xb4, 0x99, 0xfb, 0x80, 0x7b, 0xa6, 0x95, 0xc6, 0xad, 0x46, - 0xc7, 0x19, 0x1e, 0x6f, 0x27, 0xc5, 0x66, 0xae, 0xcd, 0x3c, 0xcd, 0xe0, 0x7c, 0xaf, 0x46, 0xe1, 0xca, 0x2f, 0xb7, - 0x93, 0xc2, 0xf2, 0x0e, 0xb8, 0xcd, 0x31, 0x16, 0x4d, 0x8a, 0x73, 0x3c, 0x6f, 0xbe, 0xc4, 0xf3, 0xe6, 0xbb, 0x32, - 0xa3, 0xb1, 0xc4, 0x02, 0x82, 0xf7, 0x41, 0x22, 0x9e, 0x57, 0xc9, 0x63, 0x2c, 0x1a, 0xa6, 0x3c, 0x9e, 0x37, 0xaa, - 0xd2, 0xcd, 0x25, 0x16, 0x0d, 0x53, 0xba, 0xf1, 0x0e, 0xcf, 0x1b, 0x2f, 0xff, 0xc5, 0xa4, 0xa3, 0x14, 0xd0, 0x65, - 0x81, 0x56, 0x99, 0x1d, 0xe2, 0xf5, 0xaf, 0x6f, 0xde, 0xb6, 0x3f, 0x76, 0x8e, 0xa7, 0xd8, 0xaf, 0x5f, 0x66, 0x70, - 0x2c, 0xd3, 0x31, 0x6b, 0x02, 0x44, 0x33, 0xdc, 0x39, 0x9e, 0xe1, 0xce, 0x71, 0xe6, 0x9a, 0xda, 0xcc, 0x1b, 0xe4, - 0x56, 0x87, 0x50, 0xd4, 0x51, 0x1a, 0xc2, 0xc7, 0x4f, 0x36, 0x9d, 0xa2, 0x1a, 0x28, 0xd1, 0xf1, 0xb4, 0x06, 0x2a, - 0xf8, 0x5e, 0xd6, 0xbe, 0xab, 0x7a, 0x15, 0x06, 0x59, 0x28, 0xa1, 0x70, 0xcd, 0x0d, 0x78, 0x6a, 0x29, 0x06, 0x32, - 0x61, 0x8a, 0x05, 0xca, 0x37, 0x40, 0x61, 0x94, 0x27, 0x66, 0xe8, 0xc1, 0x74, 0x4c, 0xe2, 0xff, 0xcf, 0x93, 0x29, - 0x87, 0x5e, 0x6e, 0x99, 0x9d, 0xe9, 0xb9, 0xc9, 0x84, 0xc3, 0x07, 0x1e, 0xeb, 0xff, 0xda, 0x81, 0x62, 0x03, 0x52, - 0xfc, 0x7f, 0xe9, 0xe8, 0x42, 0x30, 0x42, 0x56, 0x94, 0x16, 0x0e, 0xf1, 0xbf, 0x3d, 0xac, 0xa0, 0xfb, 0x62, 0xa7, - 0xfb, 0xc2, 0x74, 0x1f, 0x36, 0x6d, 0x54, 0x39, 0x69, 0x55, 0xc9, 0x92, 0xff, 0x3a, 0xdd, 0xda, 0x01, 0x8d, 0xa8, - 0xd1, 0xb3, 0x69, 0xd8, 0xe0, 0x61, 0x3b, 0xdd, 0x83, 0xcc, 0x1b, 0x6e, 0x5f, 0x2b, 0x85, 0xc3, 0x37, 0xb8, 0x53, - 0xbd, 0x6a, 0x81, 0xf7, 0xa6, 0x32, 0xfa, 0xca, 0x38, 0xb4, 0x1c, 0xa4, 0xdb, 0xa6, 0xdc, 0xc6, 0x58, 0x3a, 0xe9, - 0x62, 0xe3, 0x8a, 0x08, 0x95, 0x6e, 0xaf, 0x40, 0x29, 0x3e, 0xd1, 0x4d, 0x66, 0xbe, 0x2e, 0x75, 0x62, 0x2e, 0xa1, - 0x1a, 0xe6, 0xf3, 0xee, 0x4a, 0x27, 0x5a, 0x2e, 0x6c, 0xde, 0xdd, 0x25, 0xf4, 0x09, 0x1a, 0xd6, 0x46, 0x60, 0xb7, - 0xcf, 0x9d, 0x1d, 0x64, 0x70, 0x08, 0x86, 0x07, 0x90, 0x23, 0x2d, 0xb6, 0x0f, 0x6c, 0x5a, 0xc3, 0xae, 0x8b, 0x66, - 0x99, 0x68, 0x5b, 0x6d, 0x9a, 0x5c, 0xbb, 0x87, 0xf9, 0x22, 0xe4, 0x29, 0x44, 0x61, 0xf5, 0xe3, 0x7b, 0xd8, 0x8d, - 0x9b, 0x1a, 0x23, 0x51, 0x57, 0x32, 0x95, 0xd0, 0x4f, 0x6e, 0x31, 0x4b, 0xee, 0x8c, 0x17, 0xa3, 0x32, 0xfe, 0x3e, - 0x26, 0x2e, 0x7f, 0x54, 0x49, 0x72, 0x60, 0xd9, 0xdf, 0x60, 0xc9, 0x2d, 0x98, 0x27, 0x96, 0xd5, 0x24, 0xd6, 0xc9, - 0x5d, 0xb0, 0x88, 0xd2, 0x34, 0xb2, 0x31, 0x0c, 0xa8, 0x69, 0xc6, 0xaa, 0x07, 0x0f, 0x21, 0xd0, 0x43, 0xbf, 0x2c, - 0xa5, 0x5d, 0x67, 0x69, 0xad, 0x7b, 0x6d, 0xba, 0xdf, 0x1e, 0x50, 0x35, 0x8d, 0xcf, 0x01, 0xd7, 0xf4, 0xaf, 0x26, - 0x91, 0x8c, 0xd8, 0x3f, 0x9c, 0x15, 0x8f, 0x97, 0x85, 0xc1, 0x34, 0xd1, 0xd7, 0x49, 0xb6, 0x68, 0x83, 0xa9, 0x5e, - 0xb6, 0xe8, 0xdc, 0x62, 0xf7, 0x7d, 0x67, 0xbf, 0xef, 0xb0, 0xe8, 0x33, 0x93, 0x91, 0x32, 0x53, 0xcc, 0x7f, 0xdf, - 0xd9, 0xef, 0x3b, 0xbc, 0x3b, 0x98, 0x6b, 0x7f, 0xa1, 0x58, 0xb2, 0x33, 0x5c, 0x82, 0x09, 0x79, 0xc0, 0xdd, 0xd4, - 0xb2, 0x4c, 0x10, 0xd8, 0x5a, 0x02, 0xc4, 0xf9, 0x7c, 0x11, 0x57, 0xbc, 0x1a, 0x02, 0xee, 0xd3, 0xbb, 0xb6, 0x57, - 0xa9, 0xc0, 0x63, 0x82, 0x46, 0xc4, 0xc4, 0xb6, 0x31, 0x2f, 0x8d, 0x01, 0x97, 0x47, 0x74, 0xa9, 0x27, 0x49, 0x80, - 0x57, 0x35, 0x2a, 0x6f, 0x53, 0xa4, 0xfc, 0x22, 0x41, 0x8e, 0x2f, 0xf6, 0x88, 0x2a, 0x06, 0xb0, 0x2a, 0x4b, 0xfa, - 0x04, 0x52, 0xcf, 0x0f, 0x26, 0xfa, 0xcb, 0x36, 0xf2, 0xd8, 0x37, 0x77, 0x3f, 0x33, 0x3d, 0x2b, 0xe4, 0x72, 0x3a, - 0x03, 0x1f, 0x5a, 0x60, 0x19, 0x0a, 0x53, 0xaf, 0xb2, 0xf5, 0xaf, 0x49, 0x6e, 0x02, 0x28, 0x9c, 0x6e, 0xca, 0x84, - 0x66, 0x7a, 0x49, 0x73, 0x63, 0x49, 0xca, 0xc5, 0xf4, 0x91, 0xbc, 0xfd, 0x19, 0xb0, 0x9b, 0x12, 0xdd, 0xd8, 0x93, - 0xf7, 0x06, 0x76, 0x00, 0xce, 0x08, 0xdb, 0x57, 0xf1, 0xa1, 0x02, 0x9d, 0x3f, 0xce, 0x09, 0xdb, 0x57, 0xf5, 0x09, - 0xb3, 0xd9, 0x33, 0xb2, 0x35, 0xdc, 0x7e, 0x9c, 0x35, 0x72, 0x74, 0xd2, 0x49, 0xf3, 0x9e, 0x27, 0x06, 0x16, 0xa0, - 0x01, 0x70, 0x77, 0xb6, 0x67, 0x79, 0x77, 0x43, 0x40, 0xef, 0x92, 0x49, 0x7b, 0x5d, 0x6e, 0x52, 0xd6, 0xeb, 0x4e, - 0x45, 0x05, 0x0b, 0x3c, 0x0b, 0xf6, 0x02, 0xb5, 0x5f, 0x7b, 0x28, 0xce, 0xe3, 0x6c, 0xdb, 0xf4, 0xbc, 0xec, 0xbb, - 0xb7, 0x67, 0x91, 0xb1, 0x4d, 0x7b, 0xb3, 0x87, 0x48, 0x58, 0x4e, 0x58, 0x07, 0x9c, 0x70, 0x55, 0x3b, 0x20, 0x40, - 0x1f, 0x03, 0x91, 0x1b, 0x4b, 0xb2, 0xda, 0x54, 0x46, 0xf7, 0x81, 0xdf, 0x2d, 0x25, 0xd2, 0x8d, 0xb6, 0x24, 0x98, - 0x3e, 0xc1, 0xa8, 0xe9, 0xcc, 0x33, 0xd1, 0xb5, 0x17, 0x90, 0xb7, 0x45, 0x5b, 0xff, 0x1e, 0x33, 0x36, 0xdb, 0xc3, - 0xc4, 0x50, 0x06, 0x31, 0xd0, 0xfb, 0x88, 0xf7, 0x1a, 0x8d, 0x0c, 0x81, 0x42, 0x26, 0x1b, 0x62, 0x99, 0x78, 0x2d, - 0xfa, 0xd1, 0x91, 0x81, 0x47, 0x95, 0x80, 0x30, 0x05, 0x21, 0x24, 0xec, 0xda, 0x20, 0x6c, 0xb8, 0x5c, 0xb5, 0x5c, - 0xd8, 0x48, 0xb5, 0xa1, 0x83, 0xff, 0x57, 0xb8, 0x6c, 0xf5, 0xcc, 0x72, 0x51, 0x0c, 0x6e, 0xe6, 0x06, 0x2c, 0x12, - 0xa4, 0x47, 0x9b, 0xed, 0xa1, 0xb8, 0x3f, 0x17, 0x9b, 0x0d, 0x01, 0x89, 0x39, 0x4c, 0x50, 0x34, 0x9c, 0x1b, 0x63, - 0xac, 0x92, 0x4a, 0xcb, 0x5a, 0x93, 0x98, 0x83, 0x80, 0xd1, 0xe1, 0xba, 0xaf, 0x6e, 0x53, 0x86, 0xef, 0x52, 0x81, - 0x6f, 0xc0, 0x93, 0x26, 0x95, 0xd8, 0x3d, 0x5e, 0x50, 0x6c, 0x88, 0xee, 0x79, 0xf6, 0xb6, 0x80, 0x75, 0x36, 0x7b, - 0x44, 0x04, 0xbf, 0xab, 0x5f, 0x6d, 0xf0, 0xdd, 0xc2, 0x2f, 0xc1, 0xfa, 0x39, 0x38, 0x49, 0xb1, 0x68, 0xc8, 0x66, - 0xe1, 0x8e, 0x0c, 0x28, 0x57, 0xf1, 0xcb, 0x61, 0xea, 0x4e, 0x31, 0x5c, 0xfb, 0x78, 0x89, 0xdf, 0x6d, 0xb5, 0xdb, - 0x50, 0x65, 0x71, 0xbb, 0x37, 0x45, 0x43, 0x56, 0x4d, 0xef, 0xc9, 0xdc, 0x4a, 0xa9, 0x7f, 0xbd, 0xc3, 0xad, 0x9d, - 0xf6, 0xfd, 0x34, 0xdf, 0x78, 0x74, 0xae, 0x9a, 0xf6, 0xa9, 0xb5, 0x22, 0x38, 0xf8, 0xd9, 0xc2, 0xcd, 0x9d, 0x01, - 0x07, 0xf0, 0xf3, 0x77, 0x34, 0xaf, 0x32, 0x88, 0x4e, 0x6f, 0x35, 0xe3, 0xeb, 0xf8, 0xcf, 0x71, 0x23, 0xee, 0xa7, - 0x7f, 0x26, 0x7f, 0x8e, 0x1b, 0xa8, 0x8f, 0xe2, 0xc5, 0xed, 0x9a, 0xcd, 0xd7, 0x10, 0x6c, 0xed, 0xde, 0x09, 0x7e, - 0x1d, 0x96, 0xe4, 0x9a, 0xe6, 0x3c, 0x5b, 0xbb, 0xc7, 0xf9, 0xd6, 0x5c, 0xcc, 0x58, 0xc1, 0xf5, 0xda, 0xbc, 0x37, - 0xb5, 0x8e, 0xe5, 0x28, 0x87, 0xc0, 0xc2, 0xf1, 0x41, 0xb3, 0x3f, 0x68, 0x35, 0x1f, 0x0c, 0xed, 0xbf, 0x26, 0xc2, - 0x3d, 0xaa, 0x45, 0x6c, 0x7b, 0xb8, 0xb5, 0xf5, 0x63, 0x30, 0xec, 0x80, 0x50, 0xe0, 0x20, 0x97, 0xbe, 0xca, 0x90, - 0xf5, 0x3d, 0x59, 0xaf, 0x99, 0x8b, 0x66, 0xed, 0x34, 0xf8, 0x65, 0x6c, 0xa6, 0xe3, 0x76, 0xd2, 0xe9, 0x79, 0x31, - 0x96, 0x34, 0x20, 0xd2, 0x34, 0x66, 0x10, 0x48, 0x6a, 0x65, 0x38, 0xac, 0xc5, 0x6d, 0x94, 0x56, 0xf7, 0x47, 0x90, - 0xf2, 0x5d, 0x94, 0xf2, 0x13, 0x02, 0x01, 0xb4, 0x2d, 0x73, 0x54, 0x36, 0xe4, 0x7d, 0x97, 0x9e, 0x1a, 0x67, 0x86, - 0x06, 0x5f, 0xaf, 0x5b, 0x81, 0x6b, 0x52, 0x51, 0x1f, 0xe6, 0x6a, 0x03, 0x61, 0xb8, 0x40, 0xd7, 0xac, 0x88, 0xe8, - 0x87, 0xae, 0xf2, 0xf0, 0x36, 0x31, 0x96, 0x04, 0x9c, 0xf4, 0xfb, 0xa2, 0x5f, 0x90, 0xab, 0x87, 0x31, 0xf8, 0x98, - 0x61, 0x3e, 0xd0, 0x83, 0x62, 0x38, 0x44, 0xa9, 0x73, 0x3a, 0x4b, 0x4d, 0xc4, 0x95, 0xc0, 0x2f, 0xb9, 0x00, 0xbf, - 0x64, 0x85, 0xd8, 0xa0, 0x18, 0x92, 0xa7, 0x59, 0x2c, 0xc1, 0x29, 0x7f, 0x8f, 0xcf, 0xe3, 0x8b, 0xd0, 0xc0, 0xd4, - 0x0c, 0xcb, 0x5c, 0x64, 0x83, 0xc5, 0x9c, 0xb5, 0x04, 0x82, 0x9b, 0x01, 0x77, 0xa9, 0x0d, 0x89, 0xc6, 0x1a, 0x28, - 0xba, 0x8d, 0x42, 0x33, 0xa3, 0x27, 0x3b, 0x6d, 0x0c, 0x22, 0x87, 0x17, 0xe6, 0x1a, 0xc6, 0x22, 0x90, 0xb9, 0x5c, - 0xf5, 0xd8, 0x5f, 0x7e, 0xd8, 0xac, 0x30, 0x78, 0x45, 0xa6, 0x43, 0x77, 0x1c, 0x33, 0xbe, 0xca, 0x13, 0xc7, 0x10, - 0x64, 0x62, 0xa9, 0x74, 0xc3, 0x31, 0x71, 0x25, 0x7d, 0x26, 0x86, 0x6c, 0x37, 0x3c, 0x33, 0x17, 0xba, 0xd9, 0xfe, - 0xee, 0xdc, 0xce, 0x39, 0xe1, 0x46, 0x2b, 0x69, 0xb4, 0x51, 0xcf, 0x0c, 0x55, 0x75, 0xc1, 0xfc, 0x1e, 0x3a, 0x2d, - 0x2d, 0x76, 0xae, 0xde, 0xbd, 0xf0, 0xa5, 0xbc, 0x32, 0xfe, 0x16, 0xab, 0x42, 0x2b, 0x32, 0xdc, 0x6e, 0x21, 0x6f, - 0xce, 0xf4, 0xd0, 0x2b, 0x72, 0xa1, 0x3a, 0xfc, 0x45, 0x3d, 0x61, 0x1e, 0xcf, 0x8c, 0x1a, 0xc2, 0xa3, 0xdf, 0xeb, - 0x0c, 0x94, 0x7f, 0x30, 0x31, 0x99, 0xb3, 0xe4, 0x86, 0x16, 0x22, 0xfe, 0xfe, 0x85, 0x30, 0xb1, 0xaa, 0x0e, 0x60, - 0x20, 0x07, 0xa6, 0xe2, 0x01, 0xdc, 0x9a, 0xf0, 0x09, 0x67, 0xe3, 0xf4, 0x20, 0xfa, 0xbe, 0x21, 0x1a, 0xdf, 0x47, - 0xdf, 0x83, 0xbb, 0xb3, 0x7b, 0xa9, 0xb1, 0x8c, 0x0b, 0xe1, 0xef, 0xb1, 0x1e, 0x96, 0x2a, 0x65, 0xac, 0xbd, 0x6e, - 0x39, 0xbc, 0x90, 0x7a, 0x98, 0xc5, 0x0f, 0x1d, 0xb1, 0xb6, 0x29, 0x58, 0x87, 0x94, 0x14, 0x9e, 0x5d, 0x31, 0xb7, - 0x5a, 0xcc, 0x5d, 0x6a, 0x09, 0x7f, 0x7d, 0xf5, 0xb0, 0x54, 0x41, 0xc3, 0x41, 0xe8, 0x4a, 0x5b, 0x48, 0x80, 0x81, - 0x4b, 0xe9, 0xd3, 0xe9, 0xce, 0x24, 0xf2, 0x31, 0x8b, 0xe1, 0xdd, 0x83, 0xe0, 0xa2, 0x93, 0x6d, 0x85, 0x55, 0x81, - 0xcb, 0x95, 0x2a, 0xea, 0xa5, 0x24, 0x10, 0x80, 0xbe, 0xf4, 0x1e, 0x94, 0x97, 0x45, 0xaf, 0xd1, 0x90, 0xa0, 0x85, - 0xa5, 0xe6, 0x5a, 0x15, 0xd3, 0xc3, 0xf0, 0x85, 0xc1, 0xe0, 0xc3, 0x3b, 0xa4, 0x6d, 0x3d, 0xf3, 0x49, 0x09, 0xb5, - 0x3b, 0xe8, 0x10, 0xac, 0xb2, 0x83, 0xf2, 0x6f, 0x62, 0x8a, 0x6c, 0xfe, 0x80, 0x7d, 0x47, 0x5d, 0x87, 0x43, 0x57, - 0xb0, 0xea, 0xa5, 0x8c, 0x82, 0x01, 0x2b, 0xa7, 0x40, 0xed, 0x9d, 0x64, 0x34, 0x9b, 0x31, 0x50, 0xf7, 0xdb, 0xa2, - 0x81, 0xd1, 0x59, 0xdd, 0x6f, 0xc8, 0x38, 0xfb, 0x08, 0xe3, 0xec, 0xa3, 0xc0, 0x8b, 0x45, 0x92, 0x9f, 0x64, 0xac, - 0x71, 0xac, 0x9a, 0x02, 0x9d, 0x74, 0x80, 0x3b, 0x03, 0x07, 0x1e, 0xb0, 0x45, 0x39, 0x3a, 0xa2, 0xce, 0xe2, 0x9e, - 0x36, 0x32, 0xef, 0xed, 0x09, 0xb5, 0x8b, 0x58, 0xe0, 0x66, 0xcd, 0x4c, 0x0b, 0x5a, 0x2b, 0x8c, 0xf3, 0x78, 0xc0, - 0xdb, 0x3c, 0xab, 0xc5, 0x4f, 0xd8, 0xb2, 0xa6, 0xaa, 0xdf, 0x40, 0x73, 0x54, 0x0b, 0x72, 0xf3, 0xc4, 0x78, 0xab, - 0x92, 0x41, 0x14, 0x0d, 0x2d, 0xa7, 0x42, 0x0c, 0xc9, 0x18, 0xb4, 0x86, 0xc1, 0xad, 0xf6, 0x7a, 0xcd, 0x3d, 0xe2, - 0x8b, 0x9a, 0xb7, 0x9a, 0xb9, 0x05, 0xc8, 0x8a, 0x38, 0x2a, 0xef, 0x4d, 0x22, 0xf0, 0xbe, 0x2d, 0x23, 0xa4, 0xad, - 0x06, 0xf6, 0x19, 0xc9, 0x52, 0xb1, 0xf9, 0x96, 0x4e, 0x87, 0x69, 0x64, 0x47, 0x14, 0xe1, 0x8f, 0x25, 0x24, 0xe1, - 0x2a, 0xe9, 0xa3, 0xca, 0xe4, 0x82, 0xa9, 0x94, 0xe3, 0x8f, 0x85, 0x94, 0xfa, 0xda, 0x7e, 0x49, 0x5c, 0xdd, 0xc9, - 0x08, 0xfc, 0x71, 0xca, 0xf4, 0x5b, 0x5a, 0x4c, 0x19, 0xf8, 0x15, 0xf9, 0xdb, 0xb1, 0x94, 0x92, 0xab, 0x27, 0x22, - 0x1e, 0x50, 0x0c, 0x6f, 0xa0, 0x0e, 0xb1, 0x36, 0x21, 0x50, 0x4a, 0x5c, 0x84, 0x0b, 0xa2, 0xd7, 0x85, 0xbc, 0xbd, - 0x8b, 0x0b, 0xec, 0x1c, 0x00, 0x4b, 0xa7, 0x49, 0x80, 0x7f, 0xf9, 0x98, 0x8f, 0xd5, 0x98, 0x53, 0xa3, 0xeb, 0x77, - 0xbf, 0x93, 0x8f, 0x40, 0x6f, 0x4b, 0x47, 0xc1, 0x41, 0x6b, 0x08, 0xb9, 0x70, 0x17, 0x06, 0x17, 0x5f, 0x61, 0xed, - 0xa2, 0x30, 0xde, 0x58, 0x00, 0xbd, 0xf7, 0x19, 0x58, 0xb0, 0x61, 0x8e, 0x29, 0x3c, 0x20, 0x3b, 0x65, 0x3a, 0x88, - 0x0a, 0xf2, 0xa4, 0x7c, 0x22, 0xb4, 0x56, 0xfb, 0x0d, 0x9b, 0xc0, 0x1d, 0x46, 0xf2, 0xf5, 0xc2, 0x89, 0x03, 0x0f, - 0xc8, 0x34, 0x99, 0x6d, 0xf6, 0xb5, 0x8f, 0x3c, 0xf2, 0x6a, 0x12, 0xef, 0x6b, 0x29, 0xcc, 0x37, 0x2b, 0xba, 0xc1, - 0x10, 0x8a, 0x22, 0xec, 0xf7, 0x46, 0xc5, 0x14, 0x55, 0x06, 0x6d, 0xd0, 0xb0, 0xbc, 0x11, 0x3f, 0xc1, 0x19, 0x43, - 0xeb, 0x85, 0xec, 0x1d, 0x9d, 0x75, 0x38, 0x73, 0x98, 0x31, 0x23, 0x30, 0x2a, 0x2d, 0x0b, 0x3a, 0x05, 0x47, 0xe7, - 0xea, 0x83, 0xa8, 0xb8, 0x3a, 0x56, 0x00, 0x9e, 0x64, 0x06, 0xff, 0xe4, 0xdb, 0x60, 0x3d, 0x6c, 0xd5, 0x0c, 0x53, - 0x7f, 0xd2, 0xbb, 0xae, 0xe5, 0xab, 0x10, 0x47, 0xda, 0x18, 0x42, 0xeb, 0xdc, 0xde, 0x01, 0x8a, 0xb8, 0xa0, 0x17, - 0xa9, 0xc6, 0x1f, 0xd5, 0x72, 0x64, 0xd6, 0xd7, 0xb8, 0x8e, 0x69, 0x83, 0x28, 0xd6, 0x5d, 0x13, 0x7f, 0xac, 0x5e, - 0x64, 0x55, 0x29, 0xb0, 0xce, 0xa0, 0xfc, 0x50, 0xe5, 0x65, 0x43, 0x2a, 0xc9, 0x95, 0xe9, 0x54, 0x9a, 0x4e, 0x2b, - 0x84, 0x72, 0xe9, 0x49, 0x79, 0xff, 0x0a, 0x21, 0x0c, 0x4c, 0x99, 0x3d, 0x58, 0xa5, 0x76, 0xb0, 0x0a, 0x5e, 0xbd, - 0xd8, 0xc2, 0x2a, 0x09, 0xc7, 0x73, 0x89, 0x46, 0x45, 0x85, 0x43, 0x86, 0xf4, 0x85, 0x58, 0x04, 0x09, 0x80, 0x45, - 0x6f, 0x32, 0x97, 0xf7, 0x2d, 0x1c, 0x0a, 0x7b, 0x92, 0x49, 0x38, 0xdd, 0x84, 0xe6, 0xf0, 0x54, 0xaf, 0xea, 0x7b, - 0x84, 0x98, 0x99, 0xf8, 0x4f, 0xf0, 0x44, 0xf3, 0xb7, 0x9f, 0x86, 0x75, 0x16, 0xe4, 0xe9, 0xbf, 0x44, 0x49, 0x68, - 0xec, 0x3f, 0xc7, 0x43, 0x87, 0x84, 0xe1, 0xc0, 0xb7, 0x47, 0x58, 0xe1, 0xe0, 0x4e, 0x11, 0x9f, 0xc1, 0x1d, 0x3e, - 0xd6, 0xa1, 0x07, 0x80, 0x25, 0x14, 0x87, 0x20, 0xdf, 0x42, 0x31, 0x33, 0x6c, 0x4d, 0x56, 0xe1, 0x05, 0x2e, 0x58, - 0x2d, 0x94, 0xf7, 0xb7, 0x2d, 0x2f, 0xa5, 0xd5, 0x2e, 0x79, 0x8d, 0x39, 0x50, 0xf9, 0x19, 0x5e, 0xf8, 0x0a, 0xf3, - 0x76, 0xb4, 0xfb, 0xc2, 0x1f, 0x1d, 0xd0, 0x53, 0x08, 0x18, 0xe9, 0x7e, 0x6f, 0x08, 0xf7, 0x14, 0xbd, 0xcc, 0xc5, - 0x61, 0xdb, 0x41, 0xf7, 0x02, 0x73, 0x75, 0x5d, 0x65, 0x2d, 0xc0, 0x14, 0x1a, 0x1c, 0x54, 0xe1, 0x8c, 0xc0, 0x5c, - 0xbd, 0x28, 0x0b, 0x2e, 0x40, 0xbc, 0xef, 0x0b, 0x93, 0x53, 0x46, 0x03, 0xf8, 0x39, 0x2b, 0x1f, 0x9d, 0xea, 0x73, - 0x70, 0x19, 0x37, 0x6c, 0xe2, 0x5b, 0xe1, 0x53, 0x81, 0x95, 0xb4, 0xc6, 0xa1, 0x11, 0x1d, 0xd3, 0x05, 0x98, 0x6d, - 0x00, 0x05, 0x77, 0xe7, 0xc3, 0xd6, 0x42, 0x05, 0xcf, 0xe3, 0xd6, 0x5e, 0xb3, 0x26, 0xc4, 0x99, 0x34, 0x05, 0x77, - 0xdb, 0x45, 0x11, 0x98, 0xdf, 0xfe, 0x5b, 0x61, 0x91, 0x60, 0x40, 0xa5, 0x26, 0x09, 0xc2, 0x13, 0x94, 0x46, 0xba, - 0x95, 0x9b, 0x09, 0xa4, 0x13, 0x11, 0xde, 0x30, 0xbf, 0xd9, 0x3a, 0x5f, 0x1d, 0x35, 0x10, 0x15, 0x35, 0x50, 0x01, - 0x35, 0x90, 0xf5, 0xed, 0x5f, 0xc0, 0x42, 0xd8, 0x08, 0x55, 0x22, 0x08, 0x88, 0xb0, 0xd0, 0x86, 0x0f, 0x28, 0x92, - 0x10, 0xf2, 0x06, 0x50, 0x31, 0x25, 0xcf, 0xc0, 0x68, 0x1c, 0x5e, 0xef, 0x01, 0xf7, 0x4b, 0xcb, 0x30, 0x78, 0x4e, - 0xc1, 0xe4, 0xbf, 0xf4, 0xf9, 0x50, 0xbd, 0x5c, 0x1d, 0x84, 0xf0, 0x5b, 0x88, 0x15, 0xe1, 0xf8, 0x8b, 0x9f, 0x80, - 0x6c, 0x2a, 0x2c, 0x8f, 0x8e, 0x24, 0x08, 0xfc, 0x10, 0x45, 0x38, 0xe0, 0x19, 0x9e, 0x65, 0x5b, 0x44, 0xcf, 0xcf, - 0x4a, 0x55, 0xb3, 0x92, 0xc1, 0xac, 0x0a, 0x4f, 0xe3, 0xe8, 0x86, 0x30, 0x10, 0x5c, 0xa8, 0xdd, 0x37, 0x08, 0x81, - 0xb2, 0xe5, 0xc6, 0xd0, 0xa5, 0xa7, 0x60, 0x3e, 0x1a, 0x47, 0x6f, 0x18, 0x3c, 0xf2, 0x6b, 0xc2, 0xed, 0x30, 0xcd, - 0x32, 0x6d, 0x98, 0xc7, 0x46, 0xe0, 0xa4, 0x4e, 0x51, 0xf2, 0x49, 0x72, 0x11, 0x47, 0xcd, 0xab, 0x08, 0x35, 0xe0, - 0xdf, 0x06, 0x47, 0x3d, 0x9a, 0xd0, 0xf1, 0xd8, 0x07, 0xbf, 0xc9, 0x88, 0xd9, 0x64, 0xeb, 0xb5, 0xa8, 0x08, 0x7a, - 0x62, 0x37, 0x18, 0xb0, 0x12, 0x6f, 0x81, 0x7d, 0xb0, 0x1c, 0x2c, 0xf9, 0x59, 0xc4, 0xca, 0x9f, 0x52, 0x18, 0xac, - 0x9e, 0x33, 0x84, 0x70, 0x16, 0x84, 0x8d, 0xfe, 0xcf, 0x67, 0x1a, 0xae, 0x9f, 0x9f, 0xaf, 0x63, 0x44, 0xa4, 0x0f, - 0x22, 0x57, 0x63, 0x47, 0x44, 0x10, 0xb6, 0x4c, 0x0f, 0x5c, 0x99, 0xef, 0xbc, 0x75, 0xf5, 0xd0, 0x86, 0x8b, 0x03, - 0x03, 0x6a, 0x14, 0x18, 0xad, 0xe0, 0x9c, 0x94, 0x03, 0x07, 0x25, 0x84, 0x66, 0x45, 0x3c, 0x23, 0x57, 0x10, 0x09, - 0x2f, 0x43, 0x3d, 0x30, 0x2c, 0x08, 0x24, 0xa8, 0x19, 0x48, 0x50, 0x99, 0xaf, 0x3d, 0x86, 0x59, 0xe7, 0x66, 0xb6, - 0x33, 0xd4, 0x73, 0x41, 0x7e, 0x7e, 0xd2, 0xf1, 0x18, 0x58, 0xda, 0xa3, 0xa3, 0x02, 0x22, 0x88, 0x01, 0x05, 0x2f, - 0x25, 0xc0, 0x40, 0x03, 0x5e, 0x6c, 0x69, 0xc0, 0x17, 0xda, 0x78, 0x1d, 0x18, 0x5b, 0x9f, 0x32, 0xc8, 0xc5, 0x3f, - 0xd5, 0x9e, 0x26, 0x84, 0x1c, 0xb6, 0xfa, 0x3a, 0xdd, 0x8d, 0x90, 0xd8, 0xff, 0xa0, 0x4d, 0xa0, 0x31, 0x47, 0xba, - 0xab, 0x8d, 0xf9, 0xa9, 0xa6, 0x47, 0xac, 0x26, 0x21, 0x5d, 0x90, 0x2e, 0xcf, 0xa7, 0xfd, 0x03, 0x57, 0xac, 0xd2, - 0xc8, 0xc1, 0x05, 0xe8, 0xb3, 0x01, 0x01, 0x0a, 0x54, 0x9a, 0x4a, 0xd0, 0x22, 0x2e, 0x92, 0x92, 0x0d, 0xc3, 0x0c, - 0xc2, 0x14, 0x56, 0x2b, 0x41, 0xb7, 0xd6, 0x00, 0x78, 0x67, 0x66, 0xff, 0x94, 0x3e, 0xd8, 0x74, 0xe3, 0xcd, 0x23, - 0x80, 0x80, 0x1c, 0xb6, 0x4b, 0x76, 0x5d, 0x6c, 0x55, 0x66, 0x61, 0x2d, 0x63, 0x2b, 0xb7, 0xeb, 0x31, 0xf6, 0xb3, - 0xd8, 0xe5, 0x13, 0x20, 0x44, 0x6d, 0xc9, 0x34, 0x62, 0x09, 0x43, 0xd6, 0xb5, 0x21, 0x1b, 0x6d, 0x28, 0x3c, 0x95, - 0xc8, 0x81, 0x4b, 0x34, 0x41, 0xf2, 0x1d, 0x97, 0xe0, 0x10, 0x5e, 0x78, 0x84, 0xff, 0x02, 0x2c, 0x52, 0x81, 0x19, - 0x96, 0xeb, 0x35, 0xd4, 0xf3, 0x78, 0x9f, 0x6d, 0x07, 0x27, 0x95, 0x5b, 0x63, 0x97, 0x76, 0xe2, 0x71, 0xd9, 0x84, - 0xc4, 0x19, 0xf4, 0xeb, 0x2b, 0xa2, 0xfe, 0x61, 0x3b, 0x7d, 0xe2, 0xdf, 0x2b, 0x73, 0x3b, 0x10, 0x1b, 0xd6, 0x1b, - 0xac, 0x3e, 0x80, 0x96, 0x3f, 0xca, 0xfc, 0x43, 0x65, 0x81, 0x49, 0x82, 0xda, 0x5e, 0xc4, 0x1e, 0xeb, 0x21, 0x46, - 0x6a, 0x8b, 0xbb, 0x47, 0x88, 0x7f, 0xb4, 0x13, 0xc5, 0x80, 0x27, 0x15, 0xff, 0x1c, 0xa3, 0x1e, 0x84, 0xa2, 0xb6, - 0x1e, 0x36, 0x40, 0x69, 0x57, 0x9b, 0x4a, 0x8c, 0x0c, 0x09, 0xe4, 0x1b, 0x17, 0x5e, 0xd0, 0x9c, 0x44, 0x0a, 0xe4, - 0xe4, 0xaa, 0x8b, 0xf7, 0xd9, 0x96, 0x30, 0xd7, 0xdb, 0xc1, 0x31, 0x73, 0xb5, 0x91, 0x15, 0xf1, 0xcf, 0xc0, 0xce, - 0x70, 0x23, 0x59, 0x3a, 0xf0, 0xa9, 0x1a, 0xf8, 0xfc, 0x9a, 0x1b, 0x8a, 0xa2, 0x50, 0xff, 0x67, 0xfb, 0xc8, 0x1c, - 0xfc, 0x4e, 0x03, 0xf1, 0x31, 0x73, 0x3a, 0x92, 0xad, 0x50, 0x6b, 0xce, 0x8e, 0x97, 0x6d, 0x47, 0x18, 0x14, 0x36, - 0x7a, 0x5f, 0x85, 0xac, 0x62, 0x6f, 0xa7, 0x22, 0x98, 0xd3, 0x8d, 0xaa, 0x9c, 0x53, 0xb9, 0x65, 0x54, 0x4b, 0x4d, - 0x03, 0x44, 0xb8, 0xf2, 0x89, 0xe4, 0x79, 0x66, 0xc2, 0x3f, 0x18, 0x8c, 0xab, 0x47, 0x0a, 0x7f, 0xbe, 0x2f, 0x76, - 0xc8, 0x6e, 0x74, 0xb8, 0xad, 0xa0, 0x79, 0xa1, 0x82, 0x07, 0x1c, 0x95, 0x2c, 0x21, 0x52, 0xe4, 0xea, 0x50, 0xd5, - 0x4c, 0xd9, 0x3e, 0x46, 0x08, 0x21, 0xed, 0x71, 0xd6, 0x0d, 0xad, 0x1e, 0x7a, 0xa4, 0x72, 0x9a, 0xdc, 0xa1, 0xb9, - 0x2e, 0x40, 0x85, 0x11, 0x48, 0x57, 0x9f, 0xd9, 0x5d, 0x2a, 0x21, 0x7a, 0xf9, 0xc6, 0x85, 0x30, 0x76, 0x56, 0x96, - 0xb8, 0x30, 0xa3, 0xb6, 0x61, 0x74, 0xdd, 0xc6, 0x70, 0x36, 0x30, 0x66, 0x1a, 0x94, 0xb4, 0x20, 0xd4, 0x75, 0x8f, - 0x5e, 0x66, 0x26, 0xd0, 0x63, 0x4e, 0x68, 0x83, 0xe1, 0x19, 0xd1, 0x60, 0xd9, 0x54, 0x80, 0x05, 0xdf, 0xaa, 0x48, - 0xad, 0xcd, 0x26, 0x8b, 0x3f, 0xe8, 0xd8, 0x3c, 0xed, 0x97, 0x57, 0xcc, 0x73, 0xe1, 0xa8, 0xdb, 0x6f, 0x99, 0x8f, - 0x47, 0xf7, 0xf4, 0xf5, 0xf5, 0x8b, 0x9f, 0x5f, 0xbd, 0x5c, 0xaf, 0xdb, 0xac, 0xd9, 0x3e, 0xc3, 0x3f, 0xe8, 0x32, - 0x1e, 0x6c, 0x19, 0x05, 0xe8, 0xe8, 0xe8, 0x90, 0x1b, 0x17, 0x9e, 0xcf, 0x7c, 0x01, 0x71, 0x83, 0xf4, 0x10, 0xe7, - 0x45, 0x19, 0x13, 0xe4, 0x36, 0xea, 0x47, 0x77, 0x11, 0x28, 0xa1, 0x82, 0x87, 0x29, 0xb7, 0x67, 0x7f, 0x00, 0x81, - 0x89, 0xa0, 0x3e, 0x44, 0x00, 0x81, 0x78, 0xa5, 0xb8, 0x20, 0xcc, 0x27, 0x40, 0x14, 0xef, 0x09, 0x70, 0xa6, 0x26, - 0x6a, 0xd5, 0x44, 0xc5, 0x05, 0x90, 0x44, 0x1b, 0x8e, 0x92, 0x9e, 0x98, 0x00, 0xde, 0x10, 0x94, 0xd2, 0xfe, 0xea, - 0xe5, 0xce, 0x5d, 0x2a, 0x47, 0xfd, 0x56, 0x9a, 0xe3, 0x99, 0xfb, 0x9c, 0xc1, 0xe7, 0xac, 0xe7, 0x4f, 0x07, 0x71, - 0x9c, 0xe3, 0x25, 0x11, 0xc7, 0xfe, 0x59, 0xc4, 0xd5, 0xa2, 0x60, 0x5f, 0xb8, 0x5c, 0xaa, 0x74, 0x75, 0x9b, 0xca, - 0xe4, 0xb6, 0x39, 0x3e, 0x8e, 0x8b, 0xe4, 0xb6, 0xa9, 0x92, 0x5b, 0x84, 0xef, 0x52, 0x99, 0xdc, 0xd9, 0x94, 0xbb, - 0xa6, 0x82, 0x9b, 0x2f, 0x2c, 0xe0, 0x50, 0xb4, 0x45, 0x1b, 0xcb, 0xed, 0xa2, 0x36, 0xc5, 0x15, 0x0d, 0x30, 0xf8, - 0xef, 0x3d, 0x1b, 0x3f, 0x0c, 0x5f, 0x82, 0x4b, 0x93, 0x26, 0xf2, 0x03, 0x48, 0x3f, 0xad, 0xca, 0xc0, 0x7d, 0x46, - 0x5a, 0xbd, 0xd9, 0xa5, 0x68, 0xb6, 0x7b, 0x8d, 0xc6, 0x0c, 0xf6, 0x6e, 0x46, 0x72, 0x5f, 0x6c, 0xd6, 0x30, 0xf1, - 0x75, 0x0e, 0xb3, 0xf5, 0xfa, 0x30, 0x47, 0x66, 0xc3, 0x4d, 0x59, 0xac, 0x07, 0xb3, 0x21, 0x6e, 0xe1, 0xdf, 0x32, - 0x84, 0x56, 0x6c, 0x30, 0x1b, 0x12, 0x36, 0x98, 0x35, 0xda, 0x43, 0x6b, 0x68, 0x67, 0xb6, 0xe2, 0x06, 0x42, 0x68, - 0xce, 0x86, 0x27, 0xa6, 0xa4, 0x74, 0xf9, 0xf6, 0x8b, 0x56, 0x01, 0xfd, 0x54, 0x2d, 0x78, 0x99, 0xc4, 0x1d, 0xe8, - 0x8b, 0x5e, 0xda, 0xa7, 0x5b, 0x0b, 0x72, 0x7a, 0x52, 0xb9, 0xda, 0x53, 0x84, 0x4d, 0x4f, 0xea, 0xb8, 0x38, 0x36, - 0xcd, 0xb8, 0x2e, 0xa5, 0xfb, 0x0e, 0x35, 0x23, 0xbf, 0x3b, 0x58, 0x00, 0x82, 0x54, 0xf0, 0xc8, 0x0b, 0x17, 0x4e, - 0x29, 0x84, 0x8b, 0x83, 0xca, 0x0e, 0x4c, 0x72, 0xd2, 0xea, 0xe5, 0xc6, 0xd2, 0x3f, 0x77, 0x11, 0x4d, 0x29, 0xa6, - 0x24, 0xf3, 0x25, 0x73, 0x03, 0x16, 0xba, 0x4d, 0x79, 0x66, 0xa0, 0x57, 0x1a, 0xe2, 0x31, 0x81, 0x78, 0x48, 0xbd, - 0xc2, 0x18, 0x78, 0xc5, 0xb3, 0x66, 0x31, 0x60, 0x43, 0x74, 0x72, 0x8a, 0xe9, 0xe0, 0xaf, 0x6c, 0xd1, 0x86, 0xc7, - 0x02, 0xff, 0x1a, 0x92, 0x59, 0x53, 0x96, 0x09, 0x02, 0x12, 0xc6, 0x4d, 0x79, 0x0c, 0x7b, 0x09, 0xe1, 0xcc, 0x56, - 0xcc, 0x06, 0x6c, 0xd8, 0x9c, 0x95, 0x15, 0x3b, 0xbe, 0x62, 0x43, 0x96, 0x09, 0xb6, 0x62, 0xc3, 0x55, 0x0c, 0x40, - 0xf0, 0x93, 0x01, 0x41, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x28, 0x88, 0xe6, 0x8b, 0x15, 0xf1, 0x9b, 0xdd, 0xde, 0xe3, - 0xb7, 0xc0, 0x02, 0xad, 0xb6, 0xff, 0xf7, 0xa1, 0x0c, 0xd8, 0x53, 0x16, 0x26, 0x66, 0x6e, 0x61, 0x55, 0x74, 0x00, - 0x95, 0x12, 0x61, 0x0a, 0x03, 0x99, 0xc3, 0xcc, 0x40, 0x2d, 0xd0, 0x1a, 0xe4, 0x03, 0x3d, 0x6c, 0x66, 0x70, 0xc4, - 0xc0, 0x3b, 0x34, 0x64, 0x66, 0x8c, 0x09, 0xe3, 0x1c, 0xa6, 0x98, 0x19, 0xf0, 0xcc, 0xd2, 0xd6, 0x46, 0x1a, 0x59, - 0xae, 0x9f, 0xf7, 0xff, 0xd6, 0xb1, 0x1a, 0x14, 0xcd, 0xf6, 0x10, 0x1d, 0x12, 0x62, 0x3f, 0x86, 0xb0, 0xc9, 0x5c, - 0x6a, 0xc3, 0x7c, 0x9f, 0x74, 0x52, 0xfb, 0x09, 0x7f, 0x86, 0x1b, 0xb3, 0x03, 0x40, 0x47, 0x86, 0xcd, 0xfa, 0xcb, - 0x9a, 0xca, 0xeb, 0xc3, 0xde, 0x28, 0x95, 0xfb, 0xde, 0x9d, 0x0e, 0xe2, 0x44, 0x86, 0xde, 0x7a, 0xb8, 0x7c, 0xa8, - 0x87, 0x80, 0x19, 0x83, 0xb9, 0x65, 0x46, 0xdf, 0x0a, 0x91, 0x5c, 0x10, 0x09, 0x2c, 0x09, 0xa6, 0x84, 0xc1, 0xde, - 0x3a, 0x3a, 0x32, 0xd5, 0x58, 0x03, 0x9e, 0x27, 0x45, 0x20, 0x18, 0xf8, 0x08, 0xca, 0x80, 0x26, 0xca, 0xdc, 0x86, - 0x93, 0x0f, 0xcc, 0xfd, 0xc2, 0xe5, 0xed, 0x63, 0xe1, 0xb4, 0xad, 0xe6, 0x7a, 0xbc, 0x2c, 0x70, 0x57, 0xde, 0x4b, - 0x5a, 0x05, 0x37, 0xb2, 0x37, 0x79, 0xca, 0xdc, 0xad, 0xfb, 0x52, 0x9d, 0xfd, 0xcd, 0x74, 0xca, 0x66, 0x3a, 0xbb, - 0xcd, 0x84, 0x71, 0x25, 0xbf, 0x66, 0x15, 0x69, 0x4e, 0xd6, 0x44, 0x2d, 0xa8, 0xf8, 0x81, 0x2e, 0x40, 0x3b, 0xca, - 0xed, 0xbd, 0x2a, 0x9c, 0x5c, 0x39, 0xb9, 0x3a, 0xcc, 0x0d, 0x71, 0x45, 0xe6, 0x42, 0x1d, 0x02, 0xbc, 0xbc, 0x28, - 0x1f, 0x1f, 0xe0, 0x52, 0xfc, 0x22, 0xc7, 0x2e, 0xca, 0xa9, 0x90, 0x5a, 0x0a, 0x16, 0x21, 0x83, 0xaa, 0x2e, 0x06, - 0xf6, 0xca, 0xee, 0x3d, 0xd1, 0xe7, 0x83, 0x2a, 0x62, 0xde, 0xd0, 0x3c, 0xf7, 0xf1, 0x2d, 0x4d, 0xb1, 0x53, 0x13, - 0x67, 0xe4, 0x43, 0x16, 0xe7, 0x20, 0x9b, 0x0d, 0xaa, 0xd7, 0x7e, 0x1b, 0x6d, 0x5c, 0x34, 0x63, 0xd1, 0x37, 0x4f, - 0x9c, 0x7c, 0x57, 0x18, 0xe3, 0x00, 0xeb, 0xe8, 0x8f, 0x30, 0xb5, 0x60, 0xcf, 0x12, 0x4f, 0xa1, 0x93, 0x5b, 0x9b, - 0x76, 0x17, 0xa6, 0xdd, 0x99, 0xb4, 0x0e, 0x94, 0x03, 0xd2, 0xec, 0xca, 0x74, 0xee, 0xfc, 0xf7, 0x1d, 0xbc, 0x74, - 0xbb, 0x81, 0x48, 0xdc, 0x8b, 0x47, 0xc6, 0x18, 0xe2, 0x35, 0xd8, 0x88, 0xaa, 0xa3, 0xa3, 0x1f, 0x9c, 0xf7, 0x6d, - 0x25, 0xcb, 0x7e, 0x2d, 0x1c, 0xd8, 0x16, 0x53, 0xe9, 0xf2, 0xc6, 0x32, 0x5b, 0x82, 0x5d, 0xe7, 0xe1, 0xfe, 0x78, - 0xf8, 0xcf, 0x44, 0xc8, 0xb4, 0x58, 0x57, 0xf1, 0x97, 0x72, 0x5c, 0x7a, 0x88, 0x6a, 0x88, 0x40, 0x5a, 0x59, 0x97, - 0x86, 0xa6, 0xa3, 0xd7, 0x33, 0x3a, 0x96, 0x37, 0x6f, 0xa4, 0xd4, 0x43, 0xfb, 0x22, 0xb7, 0x4e, 0xe0, 0xd1, 0xc2, - 0x1a, 0x43, 0x73, 0x57, 0x7a, 0x27, 0xd9, 0x80, 0xa8, 0xf5, 0x71, 0x87, 0x92, 0x48, 0x2c, 0xaa, 0xbb, 0x10, 0x0e, - 0x77, 0x21, 0x98, 0x97, 0x41, 0xdb, 0x20, 0x76, 0xbb, 0x0b, 0xda, 0x06, 0x4e, 0xdd, 0x36, 0x70, 0x7b, 0x30, 0x58, - 0xd8, 0xfb, 0xf0, 0x72, 0x2c, 0xc7, 0xc2, 0xf1, 0x07, 0xaf, 0xed, 0x03, 0x40, 0xa0, 0xf6, 0x61, 0xc5, 0x13, 0x07, - 0x82, 0xc4, 0x19, 0x8e, 0xbe, 0xe7, 0xec, 0xc6, 0x5a, 0x0e, 0xcf, 0x17, 0x4b, 0xcd, 0xc6, 0xe6, 0x8e, 0x1a, 0x54, - 0x7c, 0x75, 0x3f, 0xaf, 0x3f, 0xb2, 0x9a, 0x6e, 0xfc, 0x35, 0x84, 0x91, 0x70, 0xca, 0x0e, 0xa3, 0x90, 0xb0, 0xc1, - 0xac, 0xaa, 0x78, 0x6d, 0x10, 0xef, 0x41, 0x9b, 0x70, 0x82, 0x45, 0xed, 0x82, 0x2a, 0xc2, 0x36, 0xde, 0x58, 0x10, - 0xe5, 0xe1, 0xd5, 0x8e, 0xd1, 0xf4, 0x6a, 0x03, 0x81, 0x8e, 0xfb, 0x51, 0x33, 0x6a, 0xb0, 0xd4, 0x05, 0x65, 0xf6, - 0x11, 0xc6, 0xd5, 0xe5, 0x99, 0x89, 0xd3, 0x5e, 0xea, 0xd5, 0x7f, 0xcc, 0xc0, 0x00, 0x5f, 0x80, 0x97, 0x58, 0x18, - 0xdd, 0x75, 0xa0, 0x1b, 0x50, 0x5f, 0x36, 0xd8, 0x10, 0xad, 0xd7, 0xad, 0xf2, 0x19, 0x28, 0x77, 0xcd, 0x25, 0xec, - 0x35, 0x97, 0x70, 0xd7, 0x5c, 0xc2, 0x5f, 0x73, 0x09, 0x73, 0xcd, 0x25, 0xfc, 0x35, 0x97, 0x07, 0xa1, 0xce, 0xab, - 0xa0, 0x51, 0x31, 0x87, 0xb8, 0x8a, 0xda, 0x46, 0xc6, 0x83, 0x0b, 0xcf, 0x43, 0x96, 0xa8, 0x72, 0xf9, 0x03, 0x98, - 0xb1, 0x7c, 0xdb, 0x56, 0xc2, 0xb8, 0x4d, 0x31, 0x05, 0x91, 0xd3, 0x8f, 0x8e, 0x2a, 0x77, 0xe7, 0x41, 0x6b, 0x98, - 0x72, 0xbc, 0xb2, 0x4e, 0xb4, 0xbf, 0x83, 0x4e, 0xde, 0xfc, 0xfa, 0x90, 0xca, 0x0d, 0x11, 0xce, 0xe4, 0xfe, 0xb0, - 0x5d, 0x52, 0x8a, 0xdc, 0x84, 0x27, 0xe7, 0x89, 0x36, 0x22, 0x08, 0x42, 0x94, 0x28, 0x9c, 0x11, 0x69, 0xf7, 0xbb, - 0x77, 0x85, 0x37, 0xaa, 0x28, 0x6f, 0x56, 0xf2, 0x38, 0x07, 0x27, 0x76, 0x63, 0x85, 0x81, 0x7a, 0xe0, 0x42, 0x90, - 0x99, 0x84, 0xdf, 0x9b, 0xb9, 0x25, 0x67, 0x59, 0x99, 0xf4, 0xa1, 0x99, 0x1b, 0x02, 0xf6, 0xff, 0xb2, 0xf7, 0xae, - 0xcb, 0x6d, 0x23, 0xc9, 0xba, 0xe8, 0xab, 0x48, 0x0c, 0x37, 0x1b, 0x30, 0x8b, 0x14, 0xe5, 0xbd, 0x67, 0x22, 0x0e, - 0xa8, 0x32, 0xc3, 0x96, 0xdb, 0xd3, 0x9e, 0xf1, 0x6d, 0x6c, 0x77, 0x4f, 0xf7, 0x30, 0x78, 0xd8, 0x10, 0x50, 0x14, - 0xe0, 0x06, 0x01, 0x1a, 0x00, 0x25, 0xd2, 0x24, 0xde, 0x7d, 0x47, 0x66, 0xd6, 0x15, 0x04, 0x65, 0xcf, 0x5a, 0x7b, - 0xfd, 0x3a, 0xe7, 0x8f, 0x2d, 0x16, 0x0a, 0x85, 0xba, 0x57, 0x56, 0x5e, 0xbe, 0xaf, 0xe4, 0xe7, 0xaa, 0xcf, 0xf6, - 0xdb, 0x20, 0x64, 0xbb, 0x20, 0x62, 0x37, 0xc5, 0x36, 0x28, 0xad, 0x23, 0xf1, 0xa3, 0x32, 0xfc, 0x2d, 0xbd, 0x5e, - 0x1e, 0x42, 0xbc, 0x4f, 0x2f, 0xcd, 0xcf, 0xd2, 0x56, 0x14, 0xe0, 0x3e, 0x42, 0x8f, 0xea, 0x40, 0xb0, 0x13, 0x9e, - 0xf0, 0x00, 0x4e, 0x56, 0xb3, 0x8a, 0xbf, 0x4f, 0x41, 0x9c, 0x28, 0x38, 0x04, 0x5c, 0x6d, 0x3f, 0xa6, 0x5f, 0xc1, - 0xf0, 0xa5, 0x83, 0x2d, 0x87, 0x37, 0xc5, 0xb6, 0xc7, 0x4a, 0xfe, 0x0e, 0xd8, 0xb7, 0x7a, 0x32, 0x56, 0xb7, 0x07, - 0xce, 0xba, 0x94, 0xa2, 0xe3, 0x4d, 0x71, 0x78, 0x7b, 0x3e, 0xdb, 0x6f, 0x83, 0x88, 0xed, 0x82, 0x0c, 0x6b, 0x9d, - 0x34, 0x1c, 0x07, 0x43, 0xf8, 0x2c, 0x46, 0xd8, 0xff, 0x65, 0x3d, 0xf0, 0x12, 0x52, 0x43, 0x81, 0x8b, 0xc1, 0x86, - 0xa3, 0xb5, 0x5d, 0xa6, 0x81, 0x9b, 0x1a, 0xf4, 0xfa, 0x9e, 0x42, 0x94, 0x97, 0x8c, 0xe6, 0x46, 0xb0, 0x6e, 0x0c, - 0xb9, 0x38, 0x1c, 0x37, 0xcb, 0x21, 0x2f, 0x69, 0x3a, 0x0d, 0x42, 0xe9, 0xce, 0xb2, 0x86, 0x24, 0xca, 0x3e, 0x08, - 0xb5, 0x6b, 0xcb, 0x7e, 0x1b, 0xd8, 0xbe, 0xfc, 0xd1, 0x30, 0xf6, 0x2f, 0x96, 0x8f, 0x85, 0x74, 0x11, 0xcf, 0x41, - 0x10, 0xb5, 0x9f, 0x67, 0xc3, 0x8d, 0x7f, 0xb1, 0x7e, 0x2c, 0x94, 0xdf, 0x78, 0x6e, 0xcb, 0x21, 0x69, 0xd6, 0xc2, - 0x17, 0xc6, 0x29, 0xc1, 0x95, 0xa1, 0xed, 0x70, 0x10, 0xfa, 0x6f, 0xb3, 0x46, 0x70, 0x63, 0x43, 0xfb, 0x7c, 0xe1, - 0xc3, 0xd6, 0x46, 0x63, 0x4d, 0x31, 0xdd, 0x42, 0xff, 0x26, 0xb3, 0xa5, 0x3d, 0x8d, 0x4a, 0x5e, 0x9c, 0x9a, 0x46, - 0x2c, 0x84, 0x01, 0x43, 0x3f, 0x99, 0x77, 0xa0, 0x9a, 0x3b, 0x1e, 0x81, 0x4c, 0x3e, 0xd0, 0x83, 0x35, 0xa9, 0x55, - 0x7f, 0x0d, 0x33, 0xf9, 0x7f, 0xa4, 0xc2, 0x62, 0x74, 0xb7, 0x0d, 0x33, 0xf5, 0x47, 0x24, 0xff, 0x60, 0x39, 0xdf, - 0xa5, 0x5e, 0xa8, 0xfd, 0x58, 0x58, 0x81, 0x41, 0x89, 0xaa, 0x01, 0x3d, 0x10, 0x41, 0x55, 0x06, 0x69, 0x86, 0xd5, - 0x39, 0xe8, 0x77, 0x4f, 0xab, 0x8e, 0xe4, 0x90, 0xd6, 0x6a, 0x48, 0x05, 0x53, 0xa5, 0x06, 0xf9, 0xe1, 0x70, 0x9b, - 0x32, 0x5d, 0x06, 0x5c, 0xd2, 0x6f, 0x53, 0xa5, 0x14, 0xfe, 0x82, 0x00, 0x74, 0x0e, 0xee, 0xf1, 0xe5, 0x18, 0x48, - 0x33, 0x2c, 0xfc, 0xd6, 0xec, 0xf8, 0x9a, 0x84, 0xdb, 0x24, 0xb8, 0x18, 0xe0, 0x1c, 0x5d, 0x85, 0xe5, 0x6d, 0x0a, - 0x11, 0x54, 0x25, 0xd4, 0xb7, 0x32, 0x0d, 0x4a, 0x5b, 0x0d, 0xc2, 0x9a, 0x84, 0x3a, 0x93, 0x6c, 0x54, 0xda, 0x6e, - 0x14, 0x66, 0x8b, 0xb8, 0x9e, 0x11, 0xd6, 0x9c, 0xcd, 0x54, 0x03, 0x93, 0x86, 0xe3, 0xa6, 0xd1, 0x5a, 0x54, 0xa8, - 0x29, 0xcc, 0x6b, 0x5c, 0x55, 0xaa, 0xba, 0x9b, 0x53, 0x4b, 0x69, 0xd9, 0x5e, 0x75, 0x93, 0x6c, 0xc8, 0x65, 0x28, - 0xc3, 0x60, 0x23, 0x47, 0x30, 0x81, 0x24, 0x39, 0xf3, 0x37, 0xf2, 0x0f, 0xb5, 0xe9, 0x5a, 0xc0, 0x1c, 0x63, 0x96, - 0x0d, 0x0b, 0x7a, 0x05, 0xee, 0x81, 0x56, 0x7a, 0x3e, 0xcd, 0x2e, 0xf2, 0x20, 0x19, 0x16, 0x7a, 0xd9, 0x64, 0xfc, - 0x8b, 0x30, 0xd2, 0x64, 0xc6, 0x4a, 0x16, 0xd9, 0xae, 0x4e, 0x89, 0xf3, 0x38, 0x81, 0xed, 0xd1, 0xf4, 0x96, 0xef, - 0x33, 0x88, 0x0a, 0x02, 0x05, 0x33, 0xe6, 0xcb, 0x2e, 0x9e, 0xf8, 0x3e, 0xb3, 0x4c, 0xdd, 0x87, 0x83, 0x31, 0x63, - 0xfb, 0xfd, 0x7e, 0xde, 0xef, 0xab, 0xf9, 0xd6, 0xef, 0x27, 0x4f, 0xcd, 0xdf, 0x1e, 0x30, 0x28, 0xc8, 0x89, 0x68, - 0x2a, 0x44, 0xf0, 0x0f, 0xc9, 0x63, 0x24, 0xa3, 0x3b, 0xee, 0x73, 0xcb, 0xf3, 0xb3, 0x3a, 0x02, 0xc1, 0x3c, 0x1c, - 0x2e, 0x15, 0xd8, 0xb5, 0x44, 0x91, 0x90, 0xe5, 0x3f, 0x06, 0xe3, 0x99, 0xfb, 0x00, 0x4b, 0x06, 0x20, 0x6c, 0x95, - 0xa7, 0xeb, 0x3d, 0x5f, 0x05, 0xef, 0x74, 0xbc, 0x6b, 0xac, 0xc8, 0x40, 0xdc, 0x02, 0x1b, 0xb1, 0xd6, 0x1e, 0x90, - 0x33, 0x05, 0x38, 0x5e, 0x1c, 0x0e, 0xe7, 0xf2, 0x97, 0x6e, 0xb6, 0x4e, 0xa0, 0x52, 0xe0, 0xf6, 0xe8, 0xe4, 0xe0, - 0x7f, 0x00, 0xcd, 0xa0, 0x1c, 0xe6, 0xf5, 0xf6, 0x0f, 0xe6, 0xe4, 0xa7, 0xa7, 0xf8, 0x27, 0x3c, 0x44, 0xa7, 0xdf, - 0xee, 0xcd, 0x1f, 0x14, 0x95, 0x87, 0x83, 0x5a, 0xfc, 0xe7, 0x9c, 0x57, 0xf0, 0x0b, 0xdf, 0x04, 0x66, 0x93, 0xa9, - 0x77, 0xf2, 0x4d, 0x9e, 0x33, 0xf5, 0x1a, 0xaf, 0x98, 0x7c, 0x87, 0xc3, 0xb9, 0x18, 0xd5, 0xdb, 0x91, 0x13, 0xed, - 0x94, 0x63, 0x1c, 0x0c, 0xfe, 0x8b, 0x68, 0x9b, 0x10, 0x60, 0x28, 0x97, 0x68, 0x66, 0xe3, 0xca, 0x12, 0xcf, 0xd2, - 0xf9, 0xe5, 0xa4, 0x2e, 0x77, 0x5a, 0xf1, 0xb4, 0x07, 0x16, 0xb7, 0x35, 0x78, 0x01, 0xdc, 0x59, 0x6c, 0x5d, 0x29, - 0x38, 0x5c, 0x40, 0x9c, 0xe2, 0x04, 0x44, 0xd0, 0x7e, 0x5f, 0xe2, 0xbd, 0x82, 0x3e, 0xe9, 0x27, 0x08, 0x86, 0x7c, - 0x2d, 0x01, 0x77, 0xbd, 0x5e, 0x8d, 0xf1, 0xbd, 0x14, 0x82, 0xeb, 0x33, 0x0d, 0x40, 0x0b, 0x7e, 0x97, 0x0f, 0xe5, - 0xf4, 0x9b, 0x08, 0x3c, 0x5b, 0xf6, 0x26, 0xca, 0xdd, 0x86, 0xa7, 0xfd, 0xd8, 0x42, 0x00, 0x96, 0xe2, 0x99, 0x12, - 0x2c, 0xc8, 0x29, 0xe6, 0xe2, 0xff, 0x05, 0x1f, 0x31, 0xdf, 0x93, 0x2e, 0x62, 0xeb, 0xed, 0xa3, 0x0b, 0x03, 0x09, - 0x34, 0x1d, 0x80, 0x1f, 0xaf, 0x02, 0xba, 0x32, 0x3e, 0xb3, 0x96, 0xf5, 0x58, 0x1f, 0xff, 0x29, 0xb8, 0x4f, 0x3f, - 0x56, 0xf8, 0xe8, 0x70, 0x5c, 0xa5, 0xa3, 0x1d, 0xa5, 0x20, 0x3a, 0xba, 0x7d, 0x3e, 0x15, 0xd9, 0x77, 0x15, 0x90, - 0x5b, 0x8e, 0xda, 0x53, 0x01, 0x58, 0x6c, 0xe9, 0x08, 0x7c, 0x9a, 0xe5, 0x13, 0xf2, 0xbd, 0x9e, 0x8a, 0xab, 0x4b, - 0x9d, 0x2e, 0x9e, 0x8e, 0xa7, 0xf0, 0x3f, 0x10, 0x7b, 0x58, 0xd8, 0xb9, 0x1d, 0xbb, 0x2e, 0x7e, 0x10, 0x6f, 0x6b, - 0x3b, 0xfa, 0x63, 0x07, 0x91, 0x8e, 0x7b, 0x72, 0xa1, 0xbe, 0x84, 0x54, 0x72, 0xa1, 0x6e, 0x20, 0x76, 0xa1, 0xc6, - 0x3b, 0x2e, 0x62, 0xad, 0xbf, 0xa9, 0x51, 0xb0, 0x12, 0x70, 0xa6, 0xbd, 0x01, 0x83, 0x0d, 0xac, 0x5b, 0x96, 0xc1, - 0xdf, 0x70, 0x4d, 0x13, 0xb8, 0x61, 0x91, 0xf5, 0xde, 0x60, 0x2b, 0xbd, 0x01, 0x47, 0xcb, 0xc4, 0xb9, 0x94, 0x24, - 0x65, 0x8b, 0x8c, 0xab, 0x47, 0x21, 0x55, 0xd3, 0xfd, 0x8d, 0xa8, 0xef, 0x85, 0xc8, 0x83, 0x55, 0xca, 0xa2, 0x62, - 0x05, 0x32, 0x7b, 0xf0, 0xf7, 0x90, 0x91, 0xa3, 0x1c, 0x38, 0x0a, 0xfd, 0xb3, 0x09, 0x74, 0x1e, 0x11, 0xe9, 0x3c, - 0x12, 0x6c, 0xa5, 0x1e, 0x0a, 0x2b, 0x2f, 0x20, 0x3a, 0x58, 0x1d, 0xf1, 0xa6, 0xf2, 0x24, 0x54, 0x6c, 0xca, 0x44, - 0x1e, 0x07, 0xb5, 0x04, 0x8c, 0x15, 0x04, 0x73, 0x96, 0x4b, 0x17, 0xa4, 0xaa, 0xd1, 0xc3, 0x22, 0x73, 0xff, 0x20, - 0x28, 0xff, 0x0f, 0x2a, 0x27, 0x5c, 0x5f, 0x86, 0x00, 0x47, 0xfb, 0x03, 0x88, 0x12, 0x63, 0xfd, 0xa2, 0x65, 0x74, - 0xc9, 0x9c, 0x4d, 0x6d, 0x2f, 0x41, 0xc6, 0x76, 0xf8, 0x15, 0x42, 0xab, 0x85, 0x22, 0x8b, 0x86, 0x0b, 0xa6, 0xdb, - 0x53, 0x5a, 0x75, 0x0f, 0x1b, 0x9e, 0x94, 0x1e, 0x2a, 0xf5, 0x6d, 0x4c, 0x60, 0x59, 0xa5, 0x0c, 0xdf, 0x4e, 0xa8, - 0x3a, 0x31, 0xa8, 0x58, 0x37, 0x6c, 0x09, 0x87, 0x58, 0x4c, 0x1a, 0xeb, 0x6c, 0xc0, 0x23, 0x96, 0xc0, 0x3f, 0x1b, - 0x3e, 0x66, 0x4b, 0x1e, 0x4d, 0x36, 0x57, 0xcb, 0x7e, 0xbf, 0xf4, 0x42, 0xaf, 0x9e, 0x65, 0x3f, 0x44, 0xf3, 0x59, - 0x3e, 0xf7, 0x51, 0x71, 0x31, 0x19, 0x0c, 0x36, 0x7e, 0x36, 0x1c, 0xb2, 0x64, 0x38, 0x9c, 0x64, 0x3f, 0xc0, 0x6b, - 0x3f, 0xf0, 0x48, 0x2d, 0xa9, 0xe4, 0x2a, 0x83, 0xfd, 0x7d, 0xc0, 0x23, 0x9f, 0x75, 0x7e, 0x5a, 0x36, 0x5d, 0xba, - 0x9f, 0x59, 0x1d, 0x10, 0xe9, 0x0e, 0xb0, 0xf1, 0xb6, 0x41, 0x47, 0xfe, 0xed, 0x0e, 0x29, 0x75, 0x93, 0x01, 0xd8, - 0x8d, 0x06, 0x38, 0x64, 0xaa, 0x97, 0x22, 0xab, 0x97, 0x32, 0xd5, 0x4b, 0xb2, 0x72, 0x09, 0x16, 0x12, 0x53, 0xe5, - 0x36, 0xb2, 0x72, 0xcb, 0x86, 0xeb, 0xe1, 0x60, 0x6b, 0xc5, 0x65, 0x73, 0x0b, 0xf7, 0x85, 0x15, 0x05, 0xfe, 0xdf, - 0xb0, 0x05, 0xbb, 0x93, 0xc7, 0xc0, 0x35, 0x3a, 0x26, 0x45, 0x5e, 0xc5, 0xee, 0xd8, 0x0d, 0xd8, 0x61, 0xe1, 0x2f, - 0xb8, 0x4e, 0x8e, 0xd9, 0x0e, 0x1f, 0x85, 0x5e, 0xc1, 0x6e, 0x7c, 0x02, 0xda, 0x05, 0x5b, 0x03, 0x64, 0x63, 0x5b, - 0x7c, 0x74, 0x7b, 0x38, 0x5c, 0x7b, 0x3e, 0xbb, 0xc7, 0x1f, 0xe7, 0xb7, 0x87, 0xc3, 0xce, 0x33, 0xea, 0xbd, 0x37, - 0x3c, 0x61, 0x8f, 0x78, 0x32, 0x79, 0x73, 0xc5, 0xe3, 0xc9, 0x60, 0xf0, 0xc6, 0x5f, 0xf0, 0x7a, 0xf6, 0x06, 0xb4, - 0x03, 0xe7, 0x0b, 0xa9, 0x6b, 0xf6, 0x6e, 0x78, 0xe6, 0x2d, 0x70, 0x6c, 0x6e, 0xe0, 0xe8, 0xed, 0xf7, 0xbd, 0x5b, - 0x1e, 0x79, 0x37, 0xa4, 0x62, 0x5a, 0x71, 0xc5, 0xf1, 0xb6, 0xc5, 0xfd, 0x74, 0xc5, 0x43, 0x78, 0x84, 0x55, 0x99, - 0xbe, 0x09, 0x1e, 0xf9, 0x6c, 0xa5, 0x59, 0xe0, 0xee, 0x31, 0xc7, 0x9a, 0xec, 0x84, 0x66, 0xe2, 0xaf, 0xb0, 0x7f, - 0xde, 0xa8, 0xfe, 0xa1, 0xf9, 0x5f, 0xea, 0x7e, 0x02, 0xb7, 0x2f, 0xb2, 0x20, 0xb1, 0x47, 0xfc, 0x0d, 0xbb, 0xe3, - 0x86, 0x6d, 0xf6, 0xcc, 0x94, 0x7d, 0xa2, 0xd4, 0xf8, 0x81, 0x52, 0xd7, 0x16, 0x24, 0x73, 0xeb, 0xca, 0x87, 0xc0, - 0xe1, 0x80, 0xfc, 0x74, 0x8b, 0x38, 0x08, 0xad, 0x9b, 0xac, 0xe6, 0x8a, 0x72, 0x2e, 0xb4, 0x51, 0xe6, 0xe5, 0xc0, - 0x62, 0x96, 0x52, 0x68, 0x2c, 0x00, 0x10, 0x4c, 0x0a, 0xad, 0xbd, 0x97, 0x01, 0xe4, 0x04, 0x0d, 0x7f, 0x6c, 0xae, - 0x4a, 0xb2, 0x96, 0x2d, 0x09, 0x51, 0xb6, 0xeb, 0xe1, 0x25, 0x42, 0xa6, 0xf5, 0xfb, 0xe7, 0x44, 0xb2, 0x36, 0xa9, - 0xae, 0x6a, 0xb4, 0x04, 0x54, 0x64, 0x09, 0x98, 0xf8, 0x95, 0xe6, 0x13, 0x80, 0x27, 0x1d, 0x0f, 0xaa, 0x1f, 0x78, - 0xcd, 0x04, 0x91, 0x6d, 0x54, 0xfe, 0xa4, 0x78, 0x8a, 0x64, 0x04, 0xc5, 0x0f, 0xb5, 0xca, 0x58, 0x18, 0xe6, 0x81, - 0x02, 0xf2, 0xee, 0xdd, 0xa9, 0x6f, 0xd1, 0xd6, 0x74, 0xec, 0xd9, 0x5a, 0x85, 0x5a, 0xa8, 0x29, 0x5c, 0x72, 0x88, - 0xae, 0x40, 0x03, 0x45, 0x24, 0xe3, 0xc9, 0xeb, 0xc1, 0xe5, 0x24, 0xba, 0xe2, 0x02, 0x9d, 0xf1, 0xf5, 0x4d, 0x37, - 0x9d, 0x45, 0x3f, 0x54, 0xf3, 0x09, 0x29, 0xc9, 0x0e, 0x87, 0x6c, 0x54, 0xd5, 0xc5, 0x7a, 0x1a, 0xca, 0x9f, 0x1e, - 0x82, 0xaf, 0x17, 0xd4, 0x6b, 0xb2, 0x4a, 0xf5, 0x0f, 0x54, 0x29, 0x2f, 0x1a, 0x5e, 0xfa, 0x3f, 0x54, 0x72, 0xdf, - 0x03, 0xd2, 0x5a, 0x5e, 0x72, 0xf9, 0x7e, 0x84, 0x18, 0x23, 0x7e, 0xe0, 0x95, 0x3c, 0x62, 0xa1, 0x9a, 0xc2, 0x35, - 0x8f, 0x10, 0xe4, 0x2d, 0xd3, 0xc1, 0xdf, 0x7a, 0xe2, 0x74, 0x7f, 0xa2, 0xb4, 0x8b, 0x2f, 0x2c, 0xa6, 0x95, 0x23, - 0xdd, 0x80, 0x1c, 0x6c, 0x98, 0x2e, 0x0a, 0xb2, 0x4d, 0x69, 0x04, 0x6d, 0xb4, 0x1c, 0xd8, 0x70, 0x2a, 0xb5, 0xe1, - 0xcc, 0x35, 0x04, 0xf7, 0xf9, 0x79, 0x3a, 0x5a, 0xc0, 0x87, 0x54, 0xb7, 0x97, 0xf8, 0x79, 0xd8, 0x68, 0x81, 0xcc, - 0x8e, 0xf8, 0xcc, 0x26, 0x92, 0x4e, 0xea, 0x5c, 0x01, 0xbb, 0x9d, 0x5d, 0x83, 0x1c, 0x31, 0x73, 0x5f, 0xa1, 0xfa, - 0x16, 0x0d, 0xb8, 0x32, 0xd6, 0xbe, 0x26, 0x19, 0x0b, 0xaf, 0xca, 0x69, 0x38, 0x00, 0x18, 0xba, 0x8c, 0xbe, 0xb6, - 0xdc, 0x64, 0xd9, 0xeb, 0x02, 0x82, 0x20, 0x4a, 0xe2, 0xf1, 0x01, 0xef, 0xcb, 0x6a, 0xa8, 0x51, 0xf2, 0xb1, 0xec, - 0x18, 0xbe, 0x5e, 0xa2, 0xbf, 0x1b, 0x73, 0x89, 0x01, 0xaf, 0xab, 0xb6, 0xa0, 0x70, 0x9e, 0x1f, 0x0e, 0xe7, 0xf9, - 0xc8, 0x78, 0x96, 0x81, 0x6a, 0x65, 0x5a, 0x07, 0x4b, 0x33, 0x5f, 0x2c, 0xfc, 0xc5, 0xce, 0x49, 0x44, 0x14, 0x04, - 0x76, 0x24, 0x3c, 0x88, 0xd4, 0x8f, 0x2a, 0x4f, 0x77, 0xaa, 0xcf, 0xf6, 0x0b, 0x9b, 0x48, 0x2f, 0x28, 0x99, 0x7c, - 0x12, 0xec, 0x55, 0x7f, 0x07, 0x61, 0x43, 0x78, 0xf3, 0xaa, 0xd7, 0x59, 0xa6, 0x66, 0x25, 0x48, 0x98, 0x31, 0x47, - 0xf0, 0x38, 0xec, 0x34, 0xb6, 0xe1, 0xb1, 0x11, 0xcb, 0x96, 0xde, 0x9a, 0xdd, 0xb2, 0x15, 0xbb, 0x51, 0x75, 0x5a, - 0xf0, 0x70, 0x3a, 0xbc, 0x0c, 0x70, 0xf5, 0xad, 0xcf, 0x39, 0xbf, 0xa5, 0x13, 0x6c, 0x3d, 0xe0, 0xd1, 0x44, 0xcc, - 0xd6, 0x3f, 0x44, 0x6a, 0xf1, 0xac, 0x87, 0x7c, 0x41, 0xeb, 0x4f, 0xcc, 0x6e, 0x4d, 0xf2, 0xed, 0x80, 0x2f, 0x26, - 0xeb, 0x1f, 0x22, 0x78, 0xf5, 0x07, 0xb0, 0x62, 0x64, 0xce, 0x2c, 0x5b, 0xff, 0x10, 0xe1, 0x98, 0xdd, 0xfe, 0x10, - 0xd1, 0xa8, 0xad, 0xe4, 0xbe, 0x74, 0xd3, 0x80, 0xb0, 0x72, 0xc3, 0x62, 0x78, 0x0d, 0xc4, 0x33, 0x6d, 0x24, 0x5d, - 0x4b, 0x43, 0x6f, 0xcc, 0xc3, 0x69, 0x1c, 0xac, 0xa9, 0x15, 0xf2, 0xcc, 0x10, 0xb3, 0xf8, 0x87, 0x68, 0xce, 0x56, - 0x58, 0x91, 0x0d, 0x8f, 0x07, 0x97, 0x93, 0xcd, 0x15, 0x5f, 0x03, 0xf9, 0xd9, 0x64, 0x63, 0xb6, 0xa8, 0x1b, 0x2e, - 0x66, 0x9b, 0x1f, 0xa2, 0xf9, 0x64, 0x05, 0x3d, 0x6b, 0x0f, 0x98, 0xf7, 0x12, 0x44, 0x28, 0x09, 0xa9, 0x29, 0x37, - 0xbd, 0x1e, 0x5b, 0x8f, 0x83, 0x5b, 0xb6, 0xbe, 0x0c, 0x6e, 0xd8, 0x7a, 0x0c, 0x44, 0x1c, 0xd4, 0xef, 0xde, 0x06, - 0x16, 0x5f, 0xc4, 0xd6, 0x97, 0x26, 0x6d, 0xf3, 0x43, 0xc4, 0xdc, 0xc1, 0x69, 0xe0, 0x82, 0xb5, 0xce, 0xbc, 0x15, - 0x83, 0x4b, 0xc8, 0xd2, 0x8b, 0xd9, 0x66, 0x78, 0xc9, 0xd6, 0x23, 0x9c, 0xea, 0x89, 0xcf, 0x6e, 0xf9, 0x0d, 0x4b, - 0xf8, 0xaa, 0x89, 0xaf, 0x36, 0xa0, 0x11, 0x3d, 0xca, 0xa0, 0xaf, 0xa0, 0x56, 0x28, 0x8b, 0x85, 0x51, 0xb9, 0x6f, - 0xc1, 0x01, 0x05, 0x69, 0x1b, 0x20, 0x48, 0xe2, 0xd9, 0x5d, 0x87, 0xeb, 0x8f, 0x52, 0x18, 0x70, 0x13, 0x98, 0x01, - 0x03, 0xd3, 0xcf, 0xe0, 0x87, 0x95, 0x2e, 0x11, 0xe2, 0xec, 0xa7, 0x94, 0x24, 0xf3, 0xfc, 0xbd, 0x48, 0x73, 0xb7, - 0x70, 0x9d, 0xc2, 0xac, 0x28, 0x50, 0xfd, 0x94, 0x94, 0x06, 0x16, 0x2a, 0x91, 0xa9, 0x14, 0xfc, 0xb2, 0x76, 0xda, - 0x75, 0x76, 0x8c, 0xce, 0x75, 0x7e, 0x39, 0x71, 0x4e, 0x27, 0x7d, 0xff, 0x81, 0x63, 0xd8, 0x42, 0x06, 0x2e, 0xfc, - 0xa9, 0x27, 0x8c, 0x53, 0x2b, 0x10, 0x53, 0xc9, 0xb3, 0xa7, 0xf0, 0x99, 0xd0, 0xea, 0xe8, 0xc2, 0xf7, 0x83, 0x42, - 0x9b, 0xa4, 0x5b, 0x90, 0xa4, 0xe0, 0x29, 0x7a, 0xce, 0x79, 0x1b, 0xa8, 0x14, 0x23, 0x5a, 0x10, 0x69, 0xeb, 0x36, - 0x73, 0x90, 0xb6, 0x34, 0xdf, 0x35, 0xf1, 0x73, 0x58, 0xc0, 0x45, 0xb4, 0xb0, 0x35, 0x3c, 0xaa, 0x62, 0xe5, 0xde, - 0xe4, 0x39, 0xc2, 0x19, 0x5d, 0xca, 0x04, 0xc0, 0xf5, 0x7e, 0x11, 0xd6, 0x0a, 0xaf, 0xa8, 0x59, 0xe4, 0x45, 0x4d, - 0x9f, 0x6c, 0x81, 0xfb, 0x58, 0x94, 0x28, 0x70, 0xd6, 0x82, 0x01, 0x5b, 0x61, 0xc9, 0x4e, 0x0a, 0x9b, 0xa2, 0x25, - 0xf4, 0xf6, 0xf8, 0xe9, 0xa0, 0x66, 0x32, 0x80, 0x26, 0x80, 0xc6, 0xe3, 0x5f, 0x00, 0x6a, 0xfa, 0xb1, 0x16, 0xeb, - 0x2a, 0x28, 0x95, 0x72, 0x13, 0x7e, 0x06, 0x86, 0x19, 0x7e, 0x28, 0xe4, 0x36, 0x51, 0x22, 0xe7, 0xc7, 0xa2, 0x14, - 0xcb, 0x52, 0x54, 0x49, 0xbb, 0xa1, 0xe0, 0x11, 0xe1, 0x36, 0x68, 0xcc, 0xdc, 0x9e, 0xe8, 0xa2, 0x15, 0xa1, 0x1c, - 0x9b, 0x75, 0x8c, 0x34, 0xca, 0xec, 0x64, 0xd7, 0xc9, 0x42, 0xfb, 0x7d, 0x95, 0x43, 0xd6, 0x01, 0x6b, 0x24, 0x5f, - 0xaf, 0x39, 0x74, 0xdb, 0x28, 0x2f, 0xee, 0x3d, 0x5f, 0xc1, 0x69, 0x8e, 0x27, 0x76, 0xd7, 0xeb, 0x4e, 0x91, 0x88, - 0x57, 0x38, 0xa9, 0xf2, 0x91, 0x2c, 0x1c, 0x77, 0xee, 0xb4, 0x16, 0xab, 0xca, 0x65, 0x3d, 0xb5, 0x38, 0x22, 0xf0, - 0xa9, 0x3c, 0xda, 0x0b, 0x6d, 0x8b, 0x62, 0x21, 0x8c, 0x1e, 0x9d, 0xf0, 0x93, 0x12, 0x58, 0x5f, 0x87, 0xc3, 0xd2, - 0x8f, 0x38, 0xfa, 0x9d, 0x46, 0xa3, 0x05, 0x21, 0x0d, 0x4f, 0xbd, 0x68, 0xb4, 0xa8, 0x8b, 0x3a, 0xcc, 0x9e, 0xe6, - 0x7a, 0xa0, 0x30, 0x8c, 0x40, 0xfd, 0xe0, 0x2a, 0x83, 0xcf, 0x22, 0x44, 0xcd, 0x03, 0xd3, 0x6c, 0x08, 0x47, 0x5d, - 0xe0, 0xa1, 0x15, 0xb4, 0x98, 0x99, 0x8f, 0x42, 0x0c, 0x1f, 0xd2, 0xc5, 0xf9, 0x13, 0xb2, 0xf2, 0x01, 0x76, 0x87, - 0xee, 0x42, 0x39, 0x67, 0x2a, 0x06, 0xf8, 0x51, 0x40, 0x3e, 0x4a, 0xc0, 0xcd, 0x00, 0xd9, 0x23, 0x4b, 0x00, 0xb1, - 0x62, 0x74, 0x34, 0xf9, 0xdc, 0xf7, 0x22, 0x05, 0xef, 0xec, 0xb3, 0x5c, 0x4d, 0x18, 0x0a, 0x9f, 0x18, 0xe8, 0xe6, - 0x37, 0x7e, 0x7b, 0xde, 0x82, 0x91, 0x5d, 0x92, 0xe2, 0xb5, 0x66, 0xb8, 0xdf, 0x80, 0xdb, 0x11, 0x50, 0xd6, 0x54, - 0xc7, 0x24, 0xdb, 0x34, 0x44, 0x32, 0x60, 0x46, 0x8c, 0x08, 0x2a, 0xcb, 0x85, 0xff, 0xdd, 0xcb, 0xa2, 0xc0, 0x01, - 0x5c, 0xcd, 0x64, 0xf0, 0xda, 0x85, 0x51, 0x01, 0x70, 0x4e, 0x43, 0xa7, 0xb4, 0x57, 0x55, 0x87, 0x64, 0xd5, 0xfc, - 0x60, 0x36, 0x6f, 0x1a, 0x26, 0x46, 0x04, 0xd1, 0x45, 0x38, 0xc1, 0xf4, 0x8a, 0xf4, 0xb5, 0x92, 0xd3, 0xd1, 0xaa, - 0xa3, 0xb5, 0xc4, 0xc4, 0x5c, 0x51, 0xfc, 0x35, 0xe0, 0x71, 0x83, 0x57, 0x27, 0x69, 0x3a, 0x51, 0x3d, 0x7a, 0xfc, - 0x3a, 0x4d, 0x27, 0x25, 0xee, 0x0a, 0xbf, 0x01, 0x17, 0xcd, 0x36, 0x1f, 0xfa, 0xf1, 0x0b, 0x8a, 0xb8, 0xa8, 0xc1, - 0x95, 0x77, 0xaa, 0xaf, 0x54, 0x1f, 0x41, 0x2d, 0x3c, 0x31, 0xb2, 0x16, 0x9e, 0x5c, 0xb2, 0xd6, 0x82, 0x60, 0x66, - 0x73, 0xe0, 0x42, 0x7e, 0xa5, 0x14, 0xf1, 0x26, 0x12, 0x6a, 0x31, 0x68, 0x3d, 0x66, 0xce, 0xaa, 0xd1, 0x42, 0x65, - 0x46, 0x68, 0xdf, 0xd6, 0xa2, 0xf3, 0x1b, 0xf9, 0x29, 0x4f, 0xed, 0xcb, 0xf6, 0x38, 0x1f, 0xef, 0xd1, 0x5d, 0x75, - 0x96, 0x99, 0x94, 0xf1, 0xc9, 0x2c, 0x41, 0xe1, 0x2e, 0xc1, 0x06, 0x24, 0xd9, 0x6f, 0x75, 0x80, 0x8c, 0xda, 0x6b, - 0xbf, 0xeb, 0x2c, 0x5f, 0xdd, 0x6c, 0x0d, 0x45, 0xa5, 0x56, 0x92, 0xe2, 0x20, 0xc3, 0x75, 0x5b, 0xf9, 0x70, 0x71, - 0x01, 0x3d, 0x63, 0x24, 0x32, 0xcf, 0x9f, 0xc8, 0x97, 0xe0, 0x9c, 0x71, 0x56, 0x08, 0x4c, 0x18, 0xab, 0x77, 0xad, - 0xa5, 0xd2, 0x90, 0x62, 0xec, 0x68, 0x94, 0x65, 0x95, 0xa5, 0xcb, 0x6c, 0x2d, 0x61, 0xcb, 0x2a, 0x72, 0x0b, 0xbb, - 0xcd, 0x64, 0x35, 0xdf, 0x55, 0xdc, 0x41, 0xf9, 0x66, 0xab, 0x8c, 0xef, 0x25, 0xb2, 0x77, 0x1b, 0x28, 0xe1, 0xe9, - 0xe8, 0x2f, 0x48, 0xbf, 0xcd, 0x30, 0x4e, 0xb9, 0xad, 0xa4, 0x05, 0x38, 0xfd, 0xc3, 0xe1, 0x5d, 0x85, 0x41, 0x83, - 0x23, 0x8c, 0x23, 0xeb, 0xf7, 0x17, 0x95, 0x57, 0x63, 0xa2, 0x8e, 0xcf, 0xea, 0xf7, 0x2b, 0x7a, 0x38, 0xad, 0x46, - 0xab, 0x74, 0x8b, 0xec, 0x84, 0x36, 0x56, 0x7e, 0x50, 0x2b, 0x60, 0xf6, 0xd6, 0xe7, 0xd3, 0x01, 0xe8, 0x58, 0x80, - 0x44, 0xb3, 0x99, 0x48, 0xcc, 0x49, 0xf7, 0x24, 0x3c, 0x3e, 0xb0, 0xc0, 0x01, 0xa6, 0xe2, 0xff, 0x12, 0xde, 0x0c, - 0x6c, 0xd0, 0x28, 0xd1, 0xd7, 0xe8, 0xaa, 0x36, 0x37, 0x3a, 0x5e, 0x7a, 0x0a, 0x89, 0xac, 0x60, 0xd5, 0xdc, 0x97, - 0x1b, 0x38, 0xed, 0xa1, 0xe6, 0x50, 0x59, 0x82, 0xbf, 0xfd, 0x32, 0x3f, 0x1c, 0x56, 0x19, 0x14, 0xb6, 0x5b, 0x0b, - 0xed, 0x8d, 0x59, 0xaa, 0xa1, 0x22, 0x1c, 0x74, 0xbe, 0x12, 0xb3, 0x7a, 0x44, 0x7f, 0xcf, 0x0f, 0x87, 0x15, 0x81, - 0x01, 0x87, 0xa5, 0xcc, 0x44, 0x0b, 0xc5, 0xd2, 0x3a, 0x9b, 0x51, 0x1d, 0x78, 0x60, 0x62, 0xce, 0xc2, 0x1d, 0x80, - 0x36, 0xa9, 0x55, 0xa0, 0x57, 0x11, 0xfd, 0xc4, 0xfd, 0xda, 0x7e, 0xbd, 0x1e, 0x99, 0xa5, 0x23, 0x37, 0xc6, 0x02, - 0x80, 0x03, 0xcf, 0x6b, 0x92, 0xe7, 0xe4, 0x6b, 0x68, 0xf7, 0xe4, 0x42, 0xfe, 0x04, 0x65, 0x0b, 0xcf, 0x55, 0xd3, - 0xca, 0x62, 0xc5, 0x55, 0xf5, 0xea, 0x82, 0x57, 0x26, 0xd3, 0x2a, 0xad, 0x44, 0xa5, 0x04, 0x03, 0xea, 0x12, 0xaf, - 0x35, 0xcd, 0x28, 0xb5, 0x51, 0x67, 0xa2, 0x06, 0x6c, 0xb0, 0x9f, 0xaa, 0x8d, 0x4e, 0xce, 0xe5, 0xf3, 0x4b, 0xe3, - 0xf0, 0x69, 0x57, 0x6f, 0x66, 0x2a, 0x07, 0xfe, 0x5a, 0xf9, 0xd0, 0xea, 0x31, 0xd0, 0x01, 0x39, 0xfd, 0x31, 0x2c, - 0x26, 0x76, 0x87, 0xe6, 0xed, 0xee, 0xb2, 0xba, 0x48, 0xef, 0x34, 0x25, 0xb3, 0x7a, 0xcb, 0x67, 0x56, 0x8f, 0x0e, - 0x78, 0xf1, 0x50, 0xef, 0x15, 0x66, 0x12, 0xc1, 0xc5, 0x50, 0x4d, 0x22, 0xbb, 0x03, 0xad, 0x79, 0x54, 0x31, 0x01, - 0x7e, 0x50, 0x6a, 0x4d, 0xef, 0xed, 0xae, 0x50, 0xa7, 0x14, 0x1e, 0xb7, 0x96, 0xfc, 0xc0, 0xdc, 0x69, 0xd7, 0x3a, - 0x1f, 0xcf, 0x2f, 0x7d, 0xbf, 0x91, 0x27, 0xb4, 0xd9, 0x99, 0x9c, 0xfe, 0xc9, 0x5b, 0xfd, 0xc3, 0x54, 0xdf, 0x42, - 0x77, 0x82, 0x3e, 0x43, 0x57, 0x55, 0x77, 0x25, 0xb6, 0x30, 0xd4, 0x13, 0x8b, 0xbc, 0x90, 0x27, 0xad, 0xb1, 0xe3, - 0x60, 0x6f, 0x80, 0x13, 0xbf, 0x3c, 0x1c, 0xc4, 0x55, 0xee, 0xb3, 0xf3, 0xae, 0x91, 0x95, 0x03, 0x58, 0x41, 0x14, - 0x8c, 0x5b, 0xf3, 0xb1, 0x0d, 0xd2, 0x25, 0xae, 0xc6, 0xc7, 0x6f, 0x28, 0x96, 0xc9, 0x26, 0xe2, 0xe2, 0x22, 0xff, - 0xe1, 0x09, 0x90, 0x96, 0xf5, 0xfb, 0xd1, 0xd3, 0xcb, 0xe9, 0x93, 0x61, 0x14, 0x80, 0x63, 0x97, 0xbd, 0xbc, 0x8c, - 0xf9, 0xea, 0x92, 0x59, 0xa6, 0xb0, 0xc8, 0x37, 0x03, 0xaa, 0x4b, 0x56, 0x4b, 0xd7, 0x2b, 0xc0, 0xd2, 0xe5, 0x37, - 0xf7, 0x61, 0x6a, 0x40, 0x23, 0x6b, 0xee, 0x4e, 0x73, 0x2d, 0x50, 0xea, 0x79, 0x3f, 0x33, 0xe4, 0xeb, 0x32, 0xe8, - 0x0a, 0xd2, 0x3d, 0x8f, 0x48, 0x2f, 0xf7, 0xd2, 0xe9, 0x7e, 0x5f, 0x0a, 0xb0, 0xd4, 0x97, 0xe2, 0x33, 0x28, 0x2c, - 0x1a, 0xdf, 0x08, 0xd0, 0xd6, 0x50, 0x4d, 0x7b, 0xa5, 0xa8, 0x7a, 0x41, 0xaf, 0x14, 0x9f, 0x7b, 0x7a, 0xa8, 0xcc, - 0x97, 0xa5, 0xa3, 0xff, 0x09, 0x35, 0x17, 0x9c, 0x10, 0x33, 0x31, 0x07, 0x50, 0x09, 0xda, 0xf8, 0x16, 0x47, 0x1b, - 0x9f, 0xea, 0x55, 0xdc, 0xf4, 0x79, 0x6d, 0x2d, 0x73, 0x42, 0xd8, 0x74, 0x2f, 0x01, 0x2a, 0xf2, 0x4a, 0x78, 0x04, - 0xcb, 0x2f, 0x7f, 0xc8, 0xd3, 0x15, 0xa2, 0x75, 0xdc, 0xb3, 0xcc, 0xa5, 0xb1, 0x7f, 0x69, 0x30, 0x7d, 0x7d, 0xbb, - 0x2d, 0xf2, 0x53, 0x13, 0x13, 0xd6, 0x63, 0x45, 0xdf, 0xbc, 0x0d, 0x57, 0x02, 0x05, 0x0e, 0x25, 0x12, 0xdb, 0x54, - 0xa1, 0x88, 0x07, 0x49, 0x9f, 0x2e, 0x5a, 0x9f, 0x06, 0x98, 0x5a, 0xcb, 0x81, 0x39, 0x84, 0xab, 0xb8, 0xf0, 0xd1, - 0xd3, 0xb7, 0x98, 0x85, 0xf3, 0x89, 0xf7, 0xc1, 0x2b, 0x46, 0xe6, 0xe3, 0x3e, 0x2a, 0x95, 0xf4, 0xcf, 0xc3, 0x61, - 0x56, 0xcd, 0x7d, 0x87, 0x3e, 0xd2, 0x43, 0x95, 0x0b, 0xca, 0xde, 0x18, 0x93, 0x08, 0x94, 0xc6, 0x78, 0x1f, 0x07, - 0xc7, 0x79, 0x9f, 0x06, 0x90, 0xda, 0x27, 0xde, 0x91, 0x92, 0xc3, 0x73, 0x8e, 0x39, 0xa1, 0xb4, 0x22, 0xac, 0xe2, - 0xdb, 0x0c, 0xe5, 0xba, 0x53, 0x0a, 0x26, 0x39, 0x24, 0x18, 0xfe, 0xaa, 0x79, 0x13, 0x2b, 0x10, 0x76, 0xcd, 0xbc, - 0x1a, 0x3d, 0xaa, 0x92, 0xb0, 0x14, 0x71, 0xbf, 0xbf, 0xcb, 0x3c, 0xc3, 0xde, 0xf0, 0xc8, 0x30, 0x72, 0xb0, 0xdc, - 0x1f, 0xd5, 0x89, 0xc8, 0x3d, 0xba, 0xc0, 0xa8, 0x2c, 0x3c, 0x6f, 0xe8, 0x4a, 0x83, 0x4a, 0xb2, 0xe3, 0xaf, 0xb8, - 0x06, 0xd4, 0xd6, 0x18, 0x31, 0x14, 0x30, 0x0a, 0x5e, 0xdb, 0x1f, 0x42, 0x16, 0x65, 0xeb, 0x37, 0x38, 0xe6, 0x83, - 0xfb, 0x88, 0xe3, 0x1d, 0xce, 0x42, 0x4b, 0xc8, 0x93, 0x3b, 0x06, 0x69, 0x1a, 0x4b, 0x23, 0xe0, 0x44, 0x24, 0xdb, - 0x58, 0x0a, 0x47, 0x00, 0x01, 0x81, 0x6e, 0xca, 0x0c, 0x63, 0x3a, 0x18, 0x79, 0x1e, 0xf5, 0x8c, 0xf7, 0x2a, 0x3c, - 0x85, 0x34, 0xd9, 0xbe, 0x9e, 0xbf, 0x37, 0x82, 0xac, 0xdc, 0x72, 0x8e, 0x87, 0xc5, 0x37, 0xce, 0xbe, 0xca, 0xc9, - 0x53, 0xcc, 0x32, 0xd2, 0x3b, 0xc5, 0xbc, 0x80, 0x3f, 0x95, 0xa5, 0x3e, 0x47, 0xe9, 0x2d, 0xf3, 0xc9, 0x2a, 0x92, - 0x2e, 0xbd, 0x4d, 0xbf, 0x1f, 0x8f, 0xd4, 0xa1, 0xe6, 0xef, 0xe3, 0x91, 0x3c, 0xc3, 0x36, 0x2c, 0x61, 0xa1, 0x55, - 0x30, 0x06, 0x90, 0xc4, 0x46, 0x44, 0x83, 0xd1, 0xde, 0x1c, 0x0e, 0xe7, 0x1b, 0x73, 0x96, 0xec, 0xc1, 0xf5, 0x95, - 0x27, 0xe6, 0x1d, 0xf8, 0x32, 0x8f, 0x09, 0x22, 0x36, 0xf3, 0x36, 0xac, 0x06, 0x0f, 0x76, 0x70, 0x7d, 0xc4, 0x16, - 0xc5, 0x5a, 0xc7, 0x52, 0x59, 0x07, 0xa7, 0x75, 0x6c, 0x9a, 0x91, 0x52, 0x64, 0x9f, 0x63, 0x7f, 0xef, 0x06, 0x57, - 0xd7, 0xc6, 0xa0, 0xd6, 0xb8, 0xc3, 0xdc, 0x39, 0x15, 0x50, 0x8f, 0xe9, 0x0a, 0xaa, 0x67, 0x15, 0xf9, 0xf2, 0x5b, - 0x3b, 0x07, 0x04, 0x8d, 0x40, 0xe0, 0xa2, 0xf1, 0xbf, 0xeb, 0x52, 0xce, 0xbb, 0x80, 0x10, 0xdf, 0xa5, 0xa0, 0x4f, - 0x67, 0xb0, 0x89, 0xcd, 0x27, 0x10, 0x8b, 0xa6, 0xfb, 0x5c, 0x6b, 0xe6, 0x8b, 0x11, 0xed, 0xcc, 0xba, 0x5b, 0xe4, - 0x56, 0x0b, 0x91, 0x8c, 0x9e, 0x6d, 0x26, 0xdc, 0x76, 0x28, 0x67, 0x24, 0x60, 0x82, 0xd6, 0x56, 0x4a, 0x3e, 0xd7, - 0xbd, 0x4e, 0xd0, 0x1e, 0x48, 0x5a, 0xf7, 0x6f, 0x16, 0x9d, 0x51, 0x72, 0x72, 0xbd, 0xc9, 0x19, 0xa4, 0x60, 0xc1, - 0xf6, 0x32, 0x27, 0xdc, 0x00, 0x1f, 0xd9, 0x2c, 0x39, 0x4d, 0x83, 0x3c, 0x16, 0xba, 0x66, 0xef, 0xdb, 0xfc, 0xb2, - 0x80, 0x0e, 0x25, 0x8b, 0x46, 0x88, 0x07, 0xd8, 0x39, 0x24, 0x57, 0x05, 0xea, 0xa6, 0x81, 0xae, 0x5c, 0x39, 0x53, - 0x4c, 0x81, 0x0b, 0xa1, 0x20, 0x6a, 0x47, 0x27, 0x51, 0x39, 0xef, 0x93, 0xea, 0x32, 0x9f, 0x16, 0xd2, 0x34, 0x90, - 0x4f, 0x2b, 0xc7, 0x3c, 0x70, 0x67, 0x1b, 0xd7, 0x04, 0x06, 0x3a, 0xb5, 0xaf, 0x45, 0x39, 0xc7, 0x2a, 0xa2, 0xf7, - 0xf9, 0xfb, 0xca, 0x9e, 0x3e, 0x88, 0xb0, 0x51, 0x81, 0xc6, 0x52, 0x62, 0x6c, 0xe4, 0xf8, 0xb7, 0x44, 0xd9, 0x90, - 0x21, 0x20, 0x84, 0xb4, 0x91, 0xd3, 0x0f, 0x3b, 0x68, 0x25, 0xd3, 0xfe, 0x9f, 0x24, 0x7e, 0x1b, 0xec, 0xe5, 0xd4, - 0x9f, 0x7a, 0xc4, 0xe3, 0xb5, 0x46, 0x8f, 0x29, 0xe9, 0x36, 0xc8, 0x53, 0xe5, 0x29, 0x48, 0x26, 0x8c, 0x25, 0x04, - 0x8b, 0x72, 0xc1, 0x73, 0x5e, 0x71, 0x09, 0xf7, 0x51, 0xcb, 0x8a, 0x08, 0x55, 0x89, 0x9c, 0x3e, 0x5f, 0x01, 0xcf, - 0x04, 0x04, 0x3a, 0xc6, 0x48, 0xa3, 0x0a, 0xbe, 0x04, 0xc6, 0x42, 0x52, 0x76, 0x9a, 0x91, 0xe0, 0xb2, 0xfb, 0x11, - 0x89, 0x52, 0x5f, 0x90, 0x92, 0xf4, 0x8d, 0xa8, 0xf1, 0x4a, 0xac, 0x22, 0x12, 0xc8, 0x50, 0x43, 0xc4, 0xaa, 0x7a, - 0xea, 0x5e, 0x15, 0x93, 0xc1, 0xa0, 0xf2, 0xe5, 0xf4, 0xc4, 0x1b, 0x1a, 0x2a, 0xef, 0xba, 0xa2, 0x9d, 0x9e, 0x69, - 0xa5, 0xbc, 0x85, 0xb4, 0x04, 0x4d, 0xc3, 0x48, 0x73, 0x28, 0x75, 0x25, 0xdd, 0x8d, 0x41, 0x7c, 0xc9, 0x44, 0xcf, - 0x76, 0x6a, 0x47, 0x69, 0x4b, 0xda, 0x43, 0x48, 0xcf, 0x5d, 0xf2, 0x31, 0x0b, 0xb9, 0xba, 0x53, 0x4e, 0xca, 0xab, - 0x10, 0x9d, 0xdc, 0xf7, 0x18, 0x12, 0x81, 0x3e, 0xe7, 0x18, 0xd6, 0x45, 0x43, 0x9d, 0xc3, 0x0a, 0x31, 0x5b, 0x28, - 0x61, 0xbe, 0x64, 0x3c, 0x95, 0x0c, 0x1a, 0x00, 0x19, 0xf0, 0xd9, 0xcb, 0xc0, 0xf2, 0x57, 0x10, 0x3f, 0xda, 0xf8, - 0x70, 0xf8, 0x52, 0x53, 0x88, 0xed, 0x17, 0xd8, 0x0c, 0xe1, 0x51, 0x3d, 0xe0, 0x99, 0x6f, 0xe2, 0x04, 0x2d, 0x47, - 0x9c, 0xcc, 0x8e, 0x26, 0xb2, 0x57, 0x3d, 0x84, 0x53, 0x59, 0x81, 0x3a, 0xca, 0x3a, 0x2b, 0xe1, 0x47, 0x98, 0xea, - 0x56, 0x62, 0x2d, 0xd0, 0xe6, 0x6a, 0xc5, 0x5a, 0x00, 0x07, 0x7e, 0x0e, 0xc1, 0x13, 0xf9, 0x1c, 0x5c, 0x0c, 0x0a, - 0xf0, 0x39, 0x00, 0x5e, 0xe4, 0x8e, 0xce, 0xfd, 0xe9, 0x81, 0x65, 0x35, 0xc2, 0x70, 0x54, 0x11, 0xeb, 0xd7, 0x6c, - 0x47, 0x3e, 0x70, 0x3b, 0xc6, 0xe7, 0xda, 0x63, 0xc9, 0x72, 0xc2, 0xcc, 0xdc, 0xab, 0x25, 0x7a, 0xde, 0xa4, 0x71, - 0x33, 0x7a, 0xb4, 0xaf, 0xe5, 0xff, 0x82, 0x5e, 0x06, 0xfd, 0x2d, 0xdc, 0xf2, 0x9a, 0x3f, 0x2c, 0xaf, 0x01, 0xd3, - 0x2b, 0x88, 0x94, 0x51, 0x23, 0x32, 0x86, 0xb0, 0x49, 0x75, 0x73, 0x9b, 0x54, 0x17, 0x02, 0x9e, 0x8e, 0x48, 0x75, - 0x2d, 0xa4, 0x8d, 0x7c, 0x5a, 0x07, 0x32, 0x16, 0xe9, 0xed, 0x4f, 0x7f, 0x7b, 0xf6, 0xe9, 0xd5, 0xaf, 0x3f, 0x2d, - 0x5e, 0xbd, 0x7d, 0xf9, 0xea, 0xed, 0xab, 0x4f, 0xbf, 0x13, 0x84, 0xc7, 0x54, 0xa8, 0x0c, 0xef, 0xdf, 0x7d, 0x7c, - 0xe5, 0x64, 0xb0, 0x61, 0xc6, 0xb2, 0xf6, 0x8d, 0x1c, 0x0c, 0x81, 0xc8, 0x06, 0x21, 0x83, 0xec, 0x94, 0xcc, 0x31, - 0x13, 0x73, 0x8c, 0xbd, 0x13, 0x98, 0x6c, 0x81, 0xef, 0x58, 0xe6, 0x25, 0x23, 0x72, 0x55, 0x68, 0xfd, 0x80, 0x16, - 0xbc, 0x01, 0x17, 0x99, 0x34, 0xbf, 0xfd, 0x95, 0x20, 0xf6, 0x69, 0x25, 0xe5, 0xbe, 0xda, 0xd6, 0x3c, 0xdf, 0xde, - 0xef, 0x25, 0x9c, 0xff, 0x5c, 0x1a, 0x51, 0x0b, 0x70, 0x00, 0x3e, 0x87, 0x3f, 0xae, 0xb4, 0x25, 0x4d, 0x66, 0xd1, - 0x7e, 0xc6, 0x10, 0x74, 0x69, 0xf0, 0x41, 0xec, 0x91, 0x97, 0xfa, 0x64, 0x21, 0x81, 0x3b, 0x62, 0xf8, 0xb4, 0x22, - 0xe8, 0x15, 0x23, 0x8a, 0x4b, 0xae, 0x50, 0x29, 0x25, 0xff, 0x46, 0xd9, 0x45, 0x85, 0x9c, 0x15, 0xec, 0x4e, 0x91, - 0x23, 0xe3, 0x07, 0xc1, 0xc4, 0x97, 0x83, 0xfb, 0x2f, 0xf1, 0x0e, 0x67, 0x8a, 0x23, 0x39, 0xe1, 0x1f, 0x33, 0x0c, - 0xec, 0xcf, 0xc1, 0xe7, 0xd5, 0x61, 0x5e, 0xde, 0xe8, 0x53, 0x6e, 0xc9, 0xc7, 0x93, 0xe5, 0x15, 0x18, 0xec, 0x97, - 0xaa, 0xb9, 0x6b, 0x5e, 0xcf, 0x96, 0x73, 0xb6, 0x9f, 0x45, 0xf3, 0xe0, 0x96, 0xcd, 0xb2, 0x79, 0xb0, 0x6a, 0xf8, - 0x9a, 0xdd, 0xf0, 0xb5, 0x55, 0xb5, 0xb5, 0x5d, 0xb5, 0xc9, 0x86, 0xdf, 0x80, 0x84, 0x70, 0x0d, 0x7e, 0xc9, 0x09, - 0xbb, 0xf5, 0xd9, 0x06, 0x24, 0xda, 0x15, 0xdb, 0xc0, 0x45, 0x6c, 0xcd, 0x5f, 0x55, 0xde, 0x86, 0x95, 0xec, 0x7c, - 0xcc, 0x72, 0x9c, 0x7f, 0x3e, 0x3c, 0xa0, 0xbd, 0x50, 0x3f, 0xbb, 0x54, 0xcf, 0x26, 0xca, 0x6e, 0xb6, 0x19, 0x2d, - 0xee, 0xd2, 0x6a, 0x13, 0x66, 0xe8, 0x59, 0x0e, 0x1f, 0x6d, 0xa5, 0xe0, 0xa7, 0x17, 0xf8, 0x25, 0x6b, 0xe2, 0xfc, - 0x9e, 0xb6, 0xed, 0xaa, 0xc4, 0x56, 0xd0, 0xa2, 0xc8, 0x6a, 0x85, 0x07, 0xe6, 0xfc, 0x29, 0x2c, 0x60, 0xec, 0x39, - 0xce, 0x79, 0xed, 0x8f, 0x90, 0xf1, 0xde, 0x01, 0x40, 0xcb, 0x1c, 0x07, 0x78, 0xc4, 0x8a, 0x51, 0x34, 0x78, 0xe7, - 0x97, 0xca, 0x6a, 0xa5, 0x39, 0x09, 0x6d, 0x23, 0x56, 0x2d, 0x47, 0xaa, 0x66, 0x44, 0xfa, 0x20, 0x3d, 0xef, 0x7b, - 0x44, 0x35, 0xd8, 0x93, 0x79, 0x1d, 0xd8, 0xa7, 0x77, 0xad, 0x55, 0xdd, 0xf9, 0x3d, 0x55, 0xba, 0xe4, 0xc8, 0x96, - 0x9f, 0x2e, 0xc3, 0x7b, 0xf5, 0xa7, 0xe4, 0xfa, 0x50, 0xe0, 0x08, 0x0f, 0x55, 0xc0, 0xf9, 0x7a, 0x25, 0xda, 0x9d, - 0x08, 0xbb, 0x72, 0x09, 0x08, 0xf1, 0x25, 0x4d, 0x73, 0x3c, 0x8e, 0x68, 0x22, 0xc2, 0x26, 0x46, 0x7f, 0x61, 0xf7, - 0xa1, 0xc4, 0x72, 0x9e, 0x6b, 0x50, 0x72, 0xc9, 0xe0, 0x3d, 0x69, 0xaf, 0x41, 0xb3, 0xbc, 0x2a, 0x35, 0x99, 0xc8, - 0x41, 0xf9, 0x70, 0x28, 0x60, 0x2f, 0x35, 0x7e, 0x9a, 0xf0, 0x13, 0x96, 0xb7, 0xf6, 0xd6, 0x94, 0xa2, 0x92, 0x06, - 0xa8, 0xc0, 0xc7, 0x0c, 0xfe, 0x77, 0x67, 0x88, 0x05, 0x53, 0x74, 0xfc, 0x70, 0x26, 0xe6, 0xd6, 0x73, 0xab, 0xac, - 0xa3, 0x6c, 0x8d, 0x76, 0x02, 0x4e, 0x75, 0x9c, 0x24, 0xc2, 0xa9, 0xf7, 0x88, 0x8b, 0xba, 0x97, 0x43, 0xd4, 0x0d, - 0xfb, 0x54, 0xe9, 0x60, 0xcb, 0x69, 0x1a, 0x1c, 0x89, 0x5f, 0xa9, 0xcf, 0xde, 0x5b, 0x41, 0x04, 0x29, 0xb2, 0x11, - 0x25, 0x69, 0x1c, 0x8b, 0x1c, 0xb6, 0xf7, 0x85, 0xdc, 0xff, 0xfb, 0x7d, 0x08, 0x27, 0xad, 0x82, 0xb8, 0xf4, 0x04, - 0x22, 0xc2, 0xd1, 0xe1, 0x47, 0x84, 0x27, 0x52, 0x55, 0xf8, 0xbe, 0x3e, 0x71, 0x63, 0x76, 0x2f, 0xcc, 0x51, 0xbd, - 0x05, 0x18, 0xc6, 0x7a, 0x6b, 0x11, 0x92, 0x68, 0xa5, 0x19, 0x6d, 0x3d, 0x20, 0x46, 0xbc, 0x5b, 0x5b, 0x64, 0x30, - 0xd6, 0x96, 0x44, 0x02, 0xf8, 0x2d, 0x09, 0x19, 0xda, 0x36, 0x02, 0x33, 0x86, 0xb7, 0xb3, 0xe2, 0xd2, 0x75, 0xd8, - 0xe6, 0x1c, 0xbe, 0x90, 0x85, 0x66, 0x1d, 0x51, 0x9a, 0x20, 0xe4, 0x1f, 0x70, 0xb2, 0x50, 0x18, 0xcd, 0x8b, 0xa3, - 0x74, 0x92, 0x58, 0xdf, 0x75, 0x95, 0x0a, 0x36, 0x9b, 0x8f, 0xa8, 0x2f, 0x3b, 0x4a, 0xbe, 0x06, 0x27, 0x1d, 0x27, - 0x59, 0xe4, 0x20, 0x6a, 0x51, 0x39, 0x1f, 0x93, 0xb0, 0xb4, 0xab, 0x53, 0x6d, 0xd6, 0xeb, 0xa2, 0xac, 0xab, 0x17, - 0x22, 0x52, 0xf4, 0x3e, 0xea, 0xd1, 0x23, 0x09, 0xa9, 0xd0, 0xaa, 0xd4, 0x2e, 0x8f, 0xc0, 0x6d, 0x53, 0x2b, 0xb6, - 0xe5, 0x12, 0x96, 0xa8, 0xf1, 0x9f, 0xa0, 0x8f, 0x72, 0x71, 0x2f, 0x03, 0x34, 0x3a, 0x9e, 0x9a, 0xb7, 0x1e, 0x78, - 0xe5, 0x28, 0xbf, 0xb4, 0xda, 0xa4, 0x5f, 0x01, 0x99, 0xd1, 0xfe, 0xd1, 0x52, 0x02, 0x99, 0x81, 0x99, 0xb4, 0x34, - 0x24, 0x72, 0x14, 0xb3, 0x34, 0xff, 0x13, 0x57, 0x6c, 0x85, 0x48, 0xc3, 0x6a, 0xee, 0xf1, 0x9f, 0x2a, 0xaf, 0x96, - 0x6b, 0x99, 0x69, 0x6e, 0x96, 0x38, 0x56, 0x2c, 0x2e, 0xea, 0x75, 0x25, 0xb2, 0x40, 0x88, 0x23, 0x4c, 0x63, 0x3d, - 0xf5, 0x46, 0x69, 0xf5, 0x1e, 0x09, 0x65, 0x7e, 0xc2, 0xde, 0x8e, 0xbd, 0x1e, 0x64, 0x21, 0x8e, 0x2d, 0x07, 0x9b, - 0xad, 0xf7, 0xa9, 0x4c, 0x45, 0x7c, 0x56, 0x17, 0x67, 0x9b, 0x4a, 0x9c, 0xd5, 0x89, 0x38, 0xfb, 0x11, 0x72, 0xfe, - 0x78, 0x46, 0x45, 0x9f, 0xdd, 0xa7, 0x75, 0x52, 0x6c, 0x6a, 0x7a, 0xf2, 0x12, 0xcb, 0xf8, 0xf1, 0x8c, 0xb8, 0x6a, - 0xce, 0x68, 0x24, 0xe3, 0xd1, 0xd9, 0xfb, 0x0c, 0x48, 0x5e, 0xcf, 0xd2, 0x15, 0x0c, 0xde, 0x59, 0x98, 0xc7, 0x67, - 0xa5, 0xb8, 0x05, 0x8b, 0x53, 0xd9, 0xf9, 0x1e, 0x64, 0x58, 0x85, 0x7f, 0x8a, 0x33, 0x80, 0x76, 0x3d, 0x4b, 0xeb, - 0xb3, 0xb4, 0x3a, 0xcb, 0x8b, 0xfa, 0x4c, 0x49, 0xe1, 0x10, 0xc6, 0x0f, 0xef, 0xe9, 0x2b, 0xbb, 0xbc, 0xcd, 0xe2, - 0x2e, 0x8b, 0xfc, 0x29, 0x7a, 0x15, 0x11, 0x93, 0x46, 0x25, 0xbc, 0x76, 0x7f, 0xdb, 0xdc, 0x3f, 0xbc, 0x6e, 0xec, - 0x7e, 0x76, 0xc7, 0x88, 0x2e, 0xa8, 0xc7, 0x2b, 0x49, 0xa9, 0xa0, 0x80, 0xc0, 0x89, 0x66, 0x8d, 0x07, 0x77, 0x1c, - 0xf0, 0x6a, 0x60, 0x4b, 0xb6, 0xf6, 0xf9, 0xd3, 0x58, 0x86, 0x69, 0x6f, 0x02, 0xfc, 0xab, 0xec, 0x4d, 0xd7, 0xc1, - 0x12, 0xef, 0x5b, 0xc8, 0x36, 0xf4, 0xea, 0x05, 0x7f, 0xe6, 0xe5, 0xea, 0x6f, 0xf6, 0x3b, 0x00, 0x61, 0x40, 0xcc, - 0xaa, 0x8f, 0x26, 0xee, 0x9d, 0x95, 0x65, 0xe7, 0x64, 0xd9, 0xf5, 0xd0, 0xaf, 0x49, 0x8c, 0x4a, 0x2b, 0x4b, 0xe9, - 0x64, 0x29, 0x21, 0x0b, 0xf8, 0xc4, 0x68, 0x6a, 0x23, 0x80, 0xb0, 0x1d, 0xa5, 0xf2, 0x85, 0xca, 0x8b, 0x28, 0x9c, - 0x13, 0x3c, 0x4f, 0xc4, 0xe8, 0xce, 0x4a, 0x06, 0x0c, 0x87, 0x10, 0xcc, 0x41, 0x5b, 0xec, 0x0d, 0xdd, 0x44, 0xfc, - 0xf5, 0xb2, 0x28, 0x5f, 0xc5, 0xe4, 0x53, 0xb0, 0x3b, 0xf9, 0xb8, 0x84, 0xc7, 0xe5, 0xc9, 0xc7, 0x21, 0x7a, 0x24, - 0x9c, 0x7c, 0x0c, 0xbe, 0x47, 0x72, 0x5e, 0x77, 0x3d, 0x4e, 0x90, 0x5b, 0x48, 0xf7, 0xb7, 0x63, 0x12, 0xa0, 0x79, - 0x0d, 0xcb, 0x51, 0x53, 0x71, 0xcd, 0xcc, 0x18, 0xcf, 0x1b, 0xbd, 0x3f, 0x76, 0xbc, 0x65, 0x0a, 0xc5, 0x2c, 0xe6, - 0x35, 0xfc, 0x9e, 0x55, 0x81, 0xba, 0xeb, 0x6d, 0x92, 0x5b, 0x66, 0xf5, 0x1c, 0xed, 0xbe, 0xef, 0xea, 0x44, 0x50, - 0xfb, 0x3b, 0xec, 0x79, 0x66, 0xbd, 0xab, 0x62, 0xe0, 0x52, 0x25, 0x3b, 0x64, 0xaa, 0x9a, 0x1e, 0xa8, 0x94, 0x06, - 0x4f, 0x2f, 0xad, 0xcb, 0x97, 0x4a, 0x1b, 0x79, 0xa6, 0xf9, 0x0d, 0xe0, 0xc5, 0xd4, 0x65, 0xb1, 0xfb, 0xe6, 0xbe, - 0x82, 0xdb, 0x78, 0xbf, 0xbf, 0xae, 0x3c, 0xf3, 0x13, 0x17, 0x80, 0xbd, 0xa9, 0xd0, 0x3a, 0x81, 0x52, 0xc3, 0x3a, - 0xbc, 0x4e, 0x44, 0xf4, 0x67, 0xbb, 0x5c, 0x67, 0xae, 0x03, 0x46, 0x14, 0xf1, 0xdb, 0x78, 0xf4, 0x07, 0x28, 0xae, - 0x8d, 0x3d, 0x20, 0xac, 0x43, 0x42, 0x9f, 0x11, 0x80, 0xd4, 0xa3, 0x8f, 0x92, 0x3f, 0x41, 0xb3, 0xa2, 0xb9, 0x63, - 0xf2, 0x73, 0x7d, 0xa5, 0xf4, 0xf7, 0xeb, 0xca, 0x23, 0x73, 0x4a, 0xdb, 0x4c, 0x63, 0xb5, 0xa6, 0x12, 0x08, 0xaf, - 0xa8, 0x64, 0x15, 0x3e, 0x9b, 0x37, 0xa2, 0xdf, 0x97, 0x47, 0x78, 0x5a, 0xfd, 0xb4, 0xc5, 0xf8, 0x56, 0x40, 0x34, - 0x12, 0x7e, 0xbf, 0x5f, 0x01, 0xcc, 0x8b, 0x6c, 0x66, 0xf7, 0x71, 0x40, 0x95, 0x12, 0x4d, 0xe3, 0x6c, 0x9e, 0xdf, - 0xd3, 0x9b, 0xb2, 0x83, 0x4e, 0x9d, 0x2a, 0x70, 0xc1, 0x55, 0xc9, 0x78, 0x65, 0x3d, 0x91, 0xcf, 0x6f, 0x6e, 0x36, - 0x69, 0x16, 0xbf, 0x2b, 0x7f, 0xc1, 0xb1, 0xd5, 0x75, 0x78, 0x60, 0xea, 0x74, 0xed, 0x3c, 0xd2, 0xda, 0x0b, 0x01, - 0x11, 0xed, 0x1a, 0x6a, 0xbd, 0xb0, 0xd0, 0x23, 0x3d, 0x11, 0xce, 0x49, 0xa2, 0xa6, 0x1d, 0x68, 0x69, 0x84, 0xbe, - 0xbe, 0xe6, 0xf4, 0x17, 0x06, 0x6b, 0x9f, 0x8f, 0x19, 0x90, 0x95, 0xe8, 0xc7, 0xea, 0xa1, 0xb1, 0x99, 0x43, 0xcf, - 0x5a, 0x95, 0x67, 0x5e, 0x75, 0x38, 0x20, 0x3e, 0x8c, 0xfe, 0x92, 0xdf, 0xef, 0xbf, 0xa0, 0xf9, 0xc7, 0x84, 0x1a, - 0x3f, 0xdb, 0x0c, 0xd0, 0xb5, 0xef, 0xca, 0x03, 0x51, 0xcf, 0xb5, 0x4a, 0x10, 0xe2, 0x0d, 0x62, 0xa2, 0x19, 0x31, - 0x07, 0xa7, 0x1d, 0x6a, 0xfe, 0x49, 0x6a, 0x40, 0x88, 0x12, 0xaf, 0x63, 0xca, 0x82, 0x9c, 0x36, 0x71, 0xa4, 0x1f, - 0x85, 0x13, 0xf9, 0x41, 0x54, 0x45, 0x76, 0x07, 0x17, 0x0c, 0xa6, 0xde, 0xd3, 0x7e, 0x89, 0x7e, 0x4b, 0x38, 0x72, - 0x8e, 0x56, 0x85, 0x20, 0x72, 0x42, 0x58, 0x6b, 0x08, 0x13, 0xc4, 0x06, 0xf1, 0xb2, 0xef, 0x92, 0x0c, 0x47, 0x0a, - 0x2e, 0xeb, 0xd8, 0x31, 0xe6, 0xea, 0xa8, 0x7a, 0x0d, 0x60, 0xbc, 0x72, 0x04, 0xcd, 0x46, 0x91, 0x5d, 0x42, 0x54, - 0x91, 0xe3, 0x09, 0xa8, 0x1d, 0x94, 0xc6, 0x66, 0x7a, 0x3e, 0x0e, 0xf2, 0xd1, 0xa2, 0x42, 0x9d, 0x13, 0xcb, 0x78, - 0x0d, 0xc0, 0xda, 0xb9, 0xea, 0xe7, 0x59, 0x0d, 0x9e, 0x34, 0xc4, 0xe7, 0x63, 0xb4, 0xbd, 0xb2, 0x39, 0xa8, 0xb6, - 0xd3, 0x59, 0x79, 0xc5, 0x74, 0x39, 0x30, 0xee, 0x1b, 0x5e, 0x51, 0x9c, 0xe1, 0x07, 0x0f, 0xb6, 0x38, 0x7f, 0xba, - 0xa1, 0xf6, 0x63, 0x6e, 0xd4, 0xc3, 0x40, 0x6b, 0xc1, 0x9b, 0x82, 0x58, 0x7f, 0xdf, 0x75, 0x64, 0x7b, 0xa7, 0x45, - 0x46, 0x93, 0xcf, 0x7e, 0xfe, 0xbe, 0x4c, 0x57, 0x29, 0xdc, 0x97, 0x9c, 0x2c, 0x9a, 0x79, 0x08, 0xec, 0x0d, 0x31, - 0x5c, 0x1f, 0x15, 0x1e, 0x51, 0xd6, 0xef, 0xc3, 0xef, 0xab, 0x0c, 0x4c, 0x31, 0x70, 0x5d, 0x21, 0x18, 0x0f, 0x81, - 0x20, 0x1e, 0xa6, 0xd1, 0xc9, 0xa0, 0x06, 0x6d, 0xf8, 0x06, 0x20, 0x33, 0xc0, 0x23, 0x73, 0xe9, 0x11, 0x70, 0x17, - 0xb8, 0xf6, 0x64, 0x3c, 0xf6, 0x27, 0xa6, 0xa1, 0x51, 0x53, 0x9a, 0xe9, 0xb9, 0xf1, 0x9b, 0x8e, 0x6a, 0xb9, 0x76, - 0xfe, 0xe3, 0x4b, 0x7e, 0x83, 0x5e, 0xd0, 0xf2, 0x72, 0x1f, 0xa9, 0xcb, 0x7d, 0x46, 0x71, 0x99, 0x48, 0x0e, 0x0b, - 0x62, 0x59, 0xc2, 0x81, 0xc7, 0xa8, 0x64, 0xb1, 0xa5, 0xc7, 0xaa, 0x68, 0xf9, 0xa2, 0xdc, 0x20, 0x1d, 0x3a, 0x21, - 0x58, 0xa2, 0x82, 0x60, 0x09, 0x8c, 0x8b, 0x58, 0xf3, 0xcd, 0x20, 0x67, 0xf1, 0x6c, 0x33, 0xe7, 0x48, 0x58, 0x97, - 0x1c, 0x0e, 0x85, 0x04, 0x9b, 0xc9, 0x66, 0xeb, 0x39, 0x5b, 0xfb, 0x0c, 0x94, 0x00, 0xa5, 0x4c, 0x13, 0x94, 0xa6, - 0x15, 0x5b, 0x71, 0xd3, 0x1a, 0xac, 0x56, 0x53, 0xb6, 0xaa, 0x29, 0x3b, 0xa7, 0x29, 0x47, 0x15, 0x94, 0x9c, 0x50, - 0x8a, 0x32, 0x0c, 0x60, 0xc4, 0x26, 0xd1, 0x55, 0x86, 0x3e, 0xde, 0x09, 0x8f, 0xa0, 0x8a, 0x88, 0x7c, 0xc2, 0x10, - 0x02, 0x13, 0x51, 0x5c, 0xa8, 0x42, 0x31, 0x40, 0x46, 0x24, 0x10, 0x4c, 0x54, 0xea, 0x14, 0x98, 0x8f, 0xa6, 0x8a, - 0x61, 0xd3, 0x9e, 0x28, 0xdf, 0x53, 0xc7, 0x3d, 0xca, 0x36, 0xff, 0x10, 0xbb, 0x20, 0x44, 0xee, 0xc6, 0x9d, 0xfa, - 0x19, 0xf1, 0xde, 0xee, 0x08, 0xe3, 0x27, 0x3b, 0x6e, 0x11, 0xae, 0x08, 0xb6, 0x54, 0x73, 0x88, 0xc5, 0xbc, 0x9a, - 0x24, 0xa8, 0x65, 0x49, 0xfc, 0x0d, 0x4f, 0x06, 0x39, 0x5b, 0x82, 0x07, 0xed, 0x9c, 0x65, 0x80, 0xbf, 0x62, 0xb5, - 0xe8, 0xf7, 0xda, 0x5b, 0x82, 0xfc, 0xb4, 0xb1, 0x1b, 0x85, 0x89, 0x11, 0x24, 0xea, 0x76, 0x65, 0x20, 0x3f, 0xbc, - 0xc7, 0xe9, 0x78, 0xec, 0x29, 0x63, 0x6e, 0x65, 0x7a, 0x99, 0xce, 0x95, 0x7c, 0x23, 0xf7, 0xd2, 0x87, 0x5e, 0x82, - 0x9d, 0x03, 0xde, 0x40, 0xda, 0xc0, 0x8f, 0xb0, 0x5d, 0x78, 0x6d, 0x90, 0x30, 0x23, 0xc0, 0x16, 0xc7, 0xc7, 0x48, - 0x09, 0x0c, 0xe1, 0x38, 0x4b, 0x01, 0x98, 0x46, 0x5f, 0x66, 0x2b, 0xfb, 0x32, 0xab, 0x35, 0x5b, 0x2a, 0xa7, 0x7b, - 0xe7, 0xd6, 0xed, 0x7c, 0x26, 0x01, 0xc0, 0xa4, 0xce, 0x81, 0x38, 0x33, 0xc1, 0x2e, 0x4d, 0x22, 0xcb, 0x87, 0x30, - 0xbf, 0x15, 0x2f, 0xcb, 0x62, 0xa5, 0xba, 0xa2, 0xed, 0x33, 0x93, 0xcf, 0x48, 0x27, 0xa1, 0x02, 0x0a, 0x0a, 0xb9, - 0xd6, 0xa7, 0x6f, 0xc3, 0xb7, 0x41, 0xa1, 0x81, 0xd9, 0x2a, 0xdc, 0xd3, 0x64, 0x8d, 0xd4, 0x1b, 0x55, 0xbf, 0x4f, - 0xae, 0x81, 0x54, 0x67, 0x0e, 0x2d, 0x7b, 0x56, 0x61, 0x80, 0xd8, 0x51, 0x9f, 0x91, 0x50, 0x07, 0x52, 0x0f, 0x18, - 0x42, 0xb4, 0x4d, 0x1f, 0x7f, 0x32, 0x24, 0xba, 0x00, 0x5b, 0x88, 0x36, 0xf0, 0xe3, 0x4f, 0xb0, 0xcf, 0x82, 0xf0, - 0x98, 0xe6, 0x6f, 0x20, 0xe9, 0xd8, 0xc0, 0x69, 0xf5, 0x29, 0xf8, 0x20, 0xc9, 0xc1, 0x44, 0x1d, 0xbc, 0xdc, 0x5f, - 0xfa, 0x7d, 0xd8, 0xb2, 0x73, 0x29, 0xd5, 0xb1, 0x52, 0x6f, 0xdb, 0xda, 0x0f, 0xa2, 0x2d, 0x38, 0xb2, 0x88, 0xbf, - 0xcf, 0x10, 0x11, 0xcc, 0x0c, 0x22, 0xec, 0x5a, 0xa8, 0xbb, 0x3d, 0xa5, 0x96, 0x45, 0xbd, 0xed, 0x29, 0xa5, 0x6e, - 0xc3, 0xf0, 0xdd, 0x04, 0x33, 0xc5, 0x0d, 0x7f, 0x93, 0x79, 0xa1, 0xde, 0x78, 0x8c, 0x63, 0xfc, 0xda, 0xf3, 0xf7, - 0x4b, 0x5e, 0xcd, 0x36, 0xca, 0x84, 0x79, 0xcb, 0x97, 0xb3, 0x50, 0x76, 0xb5, 0x34, 0xee, 0x7c, 0xf6, 0x96, 0x6a, - 0x3e, 0xf8, 0x87, 0x43, 0x02, 0xf1, 0x46, 0xf1, 0xd5, 0x6d, 0x23, 0xb7, 0xae, 0xc9, 0xe6, 0xaa, 0x04, 0xd4, 0xef, - 0xf3, 0x35, 0xee, 0xb7, 0x58, 0xff, 0xee, 0x69, 0x90, 0xb1, 0x9a, 0xe1, 0x8a, 0x29, 0x7c, 0x0a, 0x00, 0x83, 0xc3, - 0xa9, 0x20, 0x2d, 0xf0, 0x86, 0x97, 0xc3, 0xcb, 0xc9, 0x86, 0x4c, 0xba, 0x1b, 0x1f, 0xb9, 0xb3, 0x40, 0xd5, 0xfb, - 0x1d, 0xc5, 0x49, 0x83, 0x44, 0x63, 0xaf, 0xc1, 0x67, 0x59, 0x46, 0xb9, 0x68, 0xe2, 0x3e, 0x24, 0x5f, 0xe9, 0x01, - 0xcc, 0x55, 0x28, 0x01, 0xa2, 0xdf, 0x58, 0x16, 0x1b, 0xd1, 0xb6, 0xd8, 0xc0, 0x52, 0xaa, 0xe6, 0x7a, 0x35, 0x7d, - 0xf6, 0x4a, 0x34, 0xef, 0xa3, 0x19, 0xa7, 0x34, 0x1a, 0x70, 0x9c, 0x46, 0xe1, 0xf6, 0xdd, 0x9d, 0x28, 0x97, 0x19, - 0x58, 0xb2, 0x55, 0x38, 0xc5, 0x65, 0xa3, 0xce, 0x88, 0x67, 0x79, 0xac, 0x00, 0x3a, 0x1e, 0x12, 0x00, 0xd5, 0x05, - 0x01, 0x15, 0xd1, 0x52, 0x7a, 0x2b, 0xb4, 0x58, 0xa8, 0x37, 0x1c, 0xa5, 0xf0, 0x47, 0xfa, 0xf3, 0x20, 0x9f, 0x02, - 0x10, 0xbb, 0x3e, 0x8e, 0x5e, 0x16, 0x25, 0x7d, 0xaa, 0x98, 0xe5, 0x72, 0x30, 0x81, 0x5d, 0x9d, 0xc8, 0x50, 0x2b, - 0xc8, 0x5b, 0x75, 0xe5, 0xad, 0x4c, 0xde, 0xc6, 0x38, 0x25, 0x3f, 0x70, 0xd3, 0xb1, 0x46, 0x0c, 0xbc, 0xf2, 0xb4, - 0x4e, 0x13, 0xa4, 0xc9, 0x05, 0x30, 0x0c, 0xf1, 0xfb, 0xcc, 0x7b, 0xe6, 0x39, 0x52, 0x15, 0x24, 0xb3, 0xbb, 0xcc, - 0x53, 0x17, 0x51, 0x7d, 0xe5, 0xd4, 0xd2, 0x99, 0xd3, 0x8f, 0x00, 0xde, 0x63, 0x6a, 0xd2, 0x90, 0x8f, 0x70, 0x5b, - 0x8a, 0xaf, 0xb7, 0xea, 0x1a, 0x2f, 0x8d, 0xce, 0xdd, 0xcb, 0x97, 0xee, 0x34, 0xe8, 0xa7, 0x20, 0x28, 0xe7, 0xb3, - 0x52, 0xc0, 0x9e, 0x32, 0x9b, 0xeb, 0xd5, 0xaa, 0x15, 0x5a, 0x87, 0xc3, 0x58, 0x3b, 0x0a, 0x69, 0x75, 0x16, 0xb0, - 0xd5, 0x48, 0xa7, 0x04, 0x08, 0xc1, 0x71, 0x1a, 0x76, 0x82, 0x71, 0x97, 0x4e, 0x23, 0xb2, 0x5e, 0x29, 0x49, 0x17, - 0x66, 0x90, 0xfc, 0x93, 0xbc, 0x9e, 0x01, 0x2d, 0x01, 0x1c, 0x8a, 0x58, 0xc2, 0xc3, 0x49, 0x72, 0x05, 0xd0, 0xe9, - 0x70, 0x50, 0x69, 0x68, 0xce, 0x6a, 0x96, 0xcc, 0x27, 0xb1, 0x54, 0x55, 0x1e, 0x0e, 0x9e, 0x72, 0x33, 0xe8, 0xf7, - 0xb3, 0x69, 0xa9, 0x5c, 0x00, 0x82, 0x58, 0x17, 0x06, 0x88, 0x47, 0x5a, 0x78, 0xb2, 0xe8, 0x53, 0x12, 0xbf, 0x9c, - 0x25, 0x73, 0x93, 0x0d, 0xef, 0xc0, 0x08, 0x36, 0xe3, 0xba, 0xa4, 0x4c, 0x7b, 0x54, 0x7e, 0xcf, 0xe8, 0xa9, 0xed, - 0x6b, 0xad, 0xb6, 0x88, 0x75, 0x1d, 0x5c, 0x95, 0xa8, 0xa7, 0xf8, 0xa0, 0x24, 0xc1, 0xfb, 0x85, 0x73, 0x33, 0x52, - 0xbe, 0x16, 0xb9, 0x1f, 0xb4, 0x33, 0xb5, 0x72, 0xe0, 0x08, 0xe4, 0x58, 0x45, 0x25, 0xaf, 0x77, 0x1d, 0x82, 0x47, - 0x77, 0xa5, 0x02, 0xe5, 0xe0, 0xa7, 0x20, 0x46, 0xd7, 0x57, 0x9d, 0x35, 0xd4, 0x4c, 0xa3, 0xca, 0x23, 0xe8, 0xd4, - 0x01, 0x3c, 0x29, 0x78, 0xa9, 0xd5, 0x8f, 0x87, 0x83, 0x67, 0x7e, 0xf0, 0x77, 0x99, 0xbe, 0x85, 0x98, 0x28, 0xa7, - 0x1a, 0x21, 0x71, 0xa5, 0x24, 0x11, 0x1f, 0x2f, 0x5a, 0x56, 0x8c, 0xca, 0xf0, 0x9e, 0x57, 0xaa, 0x7c, 0x75, 0xaa, - 0xf2, 0x62, 0xa4, 0x6d, 0x09, 0xbc, 0x26, 0xff, 0x10, 0xb9, 0xe6, 0xad, 0xaf, 0xbb, 0xca, 0xd0, 0x47, 0xb2, 0x02, - 0x1d, 0xc1, 0x56, 0x96, 0x92, 0x03, 0x3e, 0xa9, 0xee, 0xaa, 0x55, 0xeb, 0x73, 0xca, 0x36, 0xc2, 0x4d, 0x7e, 0x1d, - 0x3b, 0x38, 0x52, 0x7e, 0x83, 0xe7, 0x02, 0xd8, 0x6b, 0xc0, 0xde, 0x9c, 0xb3, 0xa2, 0x79, 0x70, 0x48, 0xdb, 0x02, - 0x8d, 0xcc, 0xdc, 0xce, 0xd5, 0x7d, 0x5b, 0x1e, 0xa5, 0x31, 0x44, 0xa6, 0x3d, 0x30, 0x1d, 0x6c, 0x46, 0xf9, 0xef, - 0x29, 0xbf, 0x55, 0x38, 0x06, 0xbe, 0x9d, 0x7a, 0x07, 0x50, 0xf5, 0xb4, 0x41, 0xc6, 0x9a, 0x61, 0x68, 0x65, 0x97, - 0x4b, 0xa1, 0x25, 0x68, 0xa9, 0x9b, 0x20, 0x38, 0x3f, 0x22, 0xca, 0x11, 0x80, 0x2e, 0x52, 0xc0, 0x04, 0x3f, 0xa5, - 0xed, 0xee, 0xf7, 0xd7, 0xa9, 0x47, 0xee, 0x5d, 0xa1, 0x46, 0x09, 0x25, 0x18, 0xfb, 0x89, 0xc6, 0x0c, 0x3a, 0xba, - 0x22, 0x27, 0x3c, 0x6b, 0x75, 0x58, 0xd7, 0x4d, 0x19, 0x94, 0xc5, 0x31, 0xaf, 0xa6, 0xb3, 0x3f, 0x1e, 0xed, 0xeb, - 0x06, 0x59, 0xc8, 0xff, 0x60, 0x3d, 0x24, 0x83, 0xee, 0x41, 0x28, 0x44, 0x6f, 0x1e, 0xcc, 0xf0, 0x3f, 0xb6, 0xe1, - 0xd9, 0x77, 0xdc, 0xa8, 0x13, 0xc4, 0x1c, 0x71, 0xbc, 0xf4, 0x14, 0x6d, 0x3d, 0xdc, 0x02, 0xd9, 0x1a, 0x2f, 0x6f, - 0xed, 0x35, 0x90, 0x53, 0x1c, 0xff, 0x2d, 0xcf, 0xd4, 0xca, 0x06, 0x3f, 0x3d, 0x65, 0x3b, 0xf0, 0xf0, 0x22, 0x04, - 0x14, 0xc3, 0xb2, 0xf1, 0xb7, 0x96, 0xe3, 0x8c, 0xfe, 0x9b, 0x47, 0x0c, 0x83, 0x45, 0xe4, 0xc7, 0x97, 0xa5, 0x10, - 0x5f, 0x85, 0xf7, 0xa9, 0xf2, 0x6e, 0xc9, 0x29, 0xf3, 0x56, 0x0f, 0xa3, 0xeb, 0x92, 0xf4, 0x5d, 0xf2, 0xb1, 0x35, - 0x6c, 0x7f, 0x68, 0xf7, 0x9b, 0x21, 0x82, 0x10, 0xca, 0xf1, 0x73, 0x46, 0x27, 0x34, 0x3e, 0xac, 0x66, 0xa7, 0xd7, - 0xef, 0x9d, 0xe3, 0x05, 0x5b, 0xa3, 0x01, 0x1e, 0x0f, 0x5d, 0xcc, 0x13, 0x35, 0x74, 0xba, 0xae, 0x9d, 0x83, 0x07, - 0x06, 0x59, 0x9e, 0x7c, 0xc7, 0xb0, 0xc4, 0xfe, 0x24, 0xe2, 0x49, 0x5b, 0xb5, 0xb1, 0x39, 0x52, 0x6d, 0xd4, 0x0c, - 0xfc, 0xe0, 0x15, 0x14, 0x18, 0x5d, 0x90, 0x16, 0x60, 0x1c, 0x8e, 0x00, 0x64, 0xc5, 0x38, 0x1e, 0x19, 0x4c, 0x60, - 0x48, 0x37, 0x14, 0x05, 0xe0, 0xe1, 0x71, 0x3c, 0x08, 0x19, 0x40, 0xba, 0xe0, 0xa1, 0x61, 0x9b, 0x84, 0x94, 0x9f, - 0xe7, 0x79, 0xad, 0x86, 0xd0, 0x77, 0x16, 0xaa, 0x63, 0x3f, 0xd2, 0x5e, 0xb1, 0xae, 0x55, 0xe9, 0xc8, 0x56, 0x07, - 0xe8, 0x1b, 0x32, 0xf0, 0xad, 0x63, 0x0b, 0x80, 0x68, 0x89, 0x2f, 0xa9, 0x57, 0xfb, 0x32, 0x66, 0x85, 0x7a, 0x7d, - 0x61, 0xda, 0xf5, 0x42, 0x5a, 0x14, 0x50, 0x71, 0xdb, 0xaa, 0xed, 0x91, 0x9c, 0xff, 0xf0, 0xae, 0xa3, 0x1d, 0x9f, - 0x9d, 0x1a, 0x5b, 0x42, 0x99, 0x5b, 0x3c, 0x91, 0xd5, 0xd1, 0x96, 0xea, 0x54, 0x1f, 0x70, 0xa9, 0x49, 0x75, 0x66, - 0x60, 0x78, 0x8d, 0x00, 0xe5, 0x16, 0x22, 0x69, 0x1c, 0xf6, 0xce, 0x27, 0x83, 0x82, 0xb9, 0x45, 0x02, 0x12, 0xd8, - 0xc6, 0xd6, 0x2e, 0x9a, 0xeb, 0xd7, 0x97, 0xd4, 0xab, 0xda, 0x54, 0xf5, 0xe0, 0x8d, 0x17, 0x38, 0x7b, 0xa7, 0xb5, - 0x80, 0x00, 0x0a, 0x5b, 0xcb, 0x72, 0x70, 0xee, 0x76, 0x55, 0x4b, 0x45, 0x19, 0xf5, 0xfb, 0xe7, 0x5f, 0x52, 0x54, - 0xc4, 0x9e, 0x2a, 0x4e, 0x59, 0xbf, 0xdd, 0x32, 0x17, 0x95, 0x25, 0x6f, 0x50, 0x45, 0x6b, 0x75, 0xd4, 0x54, 0xae, - 0x9b, 0xab, 0x96, 0x4c, 0x10, 0xa3, 0xfb, 0x74, 0xad, 0x73, 0xa7, 0xde, 0x7b, 0x15, 0x47, 0x0c, 0x04, 0x37, 0xdd, - 0xe3, 0x83, 0x83, 0xd0, 0xa8, 0x28, 0x17, 0xdc, 0x28, 0xad, 0x2a, 0x29, 0x85, 0xbc, 0x55, 0xd1, 0x9c, 0xe9, 0x23, - 0x00, 0x22, 0xc0, 0x2a, 0x51, 0xff, 0x87, 0x2f, 0x8d, 0xf1, 0xe0, 0x81, 0xaf, 0xc9, 0x75, 0x6c, 0xbd, 0x7f, 0x5a, - 0x23, 0xad, 0x36, 0x8e, 0x49, 0xad, 0x7a, 0xd9, 0x2a, 0x5e, 0x76, 0xaf, 0x53, 0x31, 0x78, 0xfe, 0x3f, 0xf7, 0x01, - 0x6a, 0x44, 0x4b, 0x19, 0xdc, 0xba, 0x1a, 0xa0, 0xf1, 0xe1, 0x58, 0xf8, 0xc6, 0x0f, 0x19, 0xe7, 0x83, 0x19, 0x3a, - 0xaa, 0xcd, 0xc1, 0x01, 0xc1, 0x51, 0xdd, 0xa3, 0x31, 0x61, 0x16, 0xce, 0x3d, 0x08, 0x54, 0x9f, 0xb8, 0xcf, 0xb8, - 0xf6, 0x82, 0x36, 0x81, 0x4f, 0xd6, 0x75, 0x4d, 0x11, 0xe0, 0x22, 0x36, 0x26, 0x62, 0x88, 0xcb, 0x26, 0x91, 0xfa, - 0x66, 0x0c, 0x0a, 0x80, 0xe2, 0x69, 0x45, 0x72, 0xe9, 0x22, 0xcd, 0x2b, 0x51, 0xd6, 0xba, 0x19, 0x15, 0x2b, 0x86, - 0x00, 0xf0, 0x10, 0x14, 0x57, 0x95, 0x99, 0xd0, 0x88, 0x0d, 0xa4, 0xb2, 0x14, 0xac, 0x1a, 0x16, 0x7e, 0xd3, 0x7e, - 0x93, 0x9c, 0xf4, 0xce, 0xc7, 0xad, 0x73, 0xc7, 0xbe, 0x77, 0x14, 0x52, 0xda, 0x43, 0x31, 0x41, 0x10, 0xfc, 0xb4, - 0x0e, 0xe7, 0xcf, 0xf8, 0x53, 0x02, 0x53, 0x91, 0xcd, 0x18, 0x70, 0x10, 0x22, 0x32, 0xe3, 0xf7, 0x1c, 0x3e, 0xe5, - 0xe5, 0x24, 0x1c, 0x0e, 0x7d, 0xd0, 0x87, 0xf2, 0x6c, 0x16, 0x0e, 0xc5, 0x5c, 0x7a, 0xaf, 0x83, 0xb5, 0x2e, 0xe4, - 0xf5, 0x24, 0x44, 0xb4, 0xd0, 0xd0, 0x07, 0xe7, 0x75, 0xd7, 0x1c, 0x61, 0x09, 0x40, 0x13, 0x47, 0x5f, 0xd6, 0xef, - 0x47, 0x9e, 0x36, 0xb4, 0x48, 0x71, 0xd1, 0x28, 0xb3, 0x59, 0x2e, 0x3b, 0x61, 0xe3, 0xda, 0x2d, 0x10, 0x8a, 0x87, - 0x69, 0x0b, 0x55, 0xeb, 0xa9, 0x5e, 0xcf, 0x4d, 0xbb, 0xef, 0x1e, 0x54, 0xab, 0x1c, 0xe9, 0xac, 0x4d, 0x57, 0x6a, - 0x75, 0xcb, 0xa8, 0x5a, 0x67, 0x69, 0x44, 0x95, 0x9b, 0xe4, 0xae, 0x51, 0x0b, 0x3e, 0xd9, 0xd0, 0x65, 0xca, 0xce, - 0xd6, 0xe0, 0xc4, 0x91, 0xe7, 0x92, 0x5b, 0xbe, 0x3b, 0xaf, 0xe8, 0xee, 0x54, 0xfb, 0x16, 0xe0, 0xde, 0x0c, 0x1b, - 0x32, 0xe7, 0x35, 0x76, 0x1a, 0x84, 0x49, 0xe0, 0x47, 0xec, 0x63, 0x86, 0x6c, 0x30, 0xa0, 0xa3, 0x90, 0xfe, 0xd7, - 0x96, 0x39, 0x12, 0x30, 0xf9, 0xeb, 0xb9, 0xdf, 0x2c, 0x8a, 0x1c, 0x16, 0xe3, 0xfb, 0x0d, 0x46, 0x1a, 0xab, 0x35, - 0x18, 0x96, 0xb7, 0x88, 0xfc, 0xa9, 0xdd, 0x31, 0x4d, 0x75, 0xbc, 0x59, 0xaf, 0x35, 0xbf, 0x7a, 0xfa, 0x54, 0xd7, - 0xe7, 0xbf, 0x7d, 0x7f, 0x19, 0xd6, 0xcc, 0xfe, 0x10, 0x84, 0xd2, 0xee, 0xdd, 0xe2, 0xdc, 0x91, 0xe8, 0x1d, 0x2b, - 0xcd, 0xec, 0xd2, 0x2e, 0xd9, 0xa5, 0x29, 0xed, 0x23, 0xb9, 0x5e, 0x7d, 0xa3, 0xbc, 0xb1, 0xf3, 0x8a, 0xe9, 0xfe, - 0xbd, 0xd0, 0x3b, 0xca, 0xa9, 0x9a, 0x40, 0x44, 0x93, 0x76, 0x24, 0x6e, 0xf7, 0xca, 0xf0, 0xc9, 0x24, 0x6f, 0x97, - 0x70, 0xd4, 0x35, 0x2c, 0x37, 0xdf, 0xfe, 0x25, 0xaf, 0x3a, 0x2b, 0xdc, 0x7e, 0x69, 0xcc, 0xda, 0x9f, 0x82, 0xb8, - 0xaa, 0x3f, 0xbd, 0xf7, 0x35, 0x53, 0xf2, 0x7f, 0xd5, 0x63, 0xe0, 0xea, 0x27, 0xd3, 0x8e, 0xee, 0x29, 0x84, 0x0d, - 0x66, 0x3f, 0x3f, 0x7e, 0x68, 0xd1, 0x35, 0xba, 0x40, 0x91, 0x1c, 0x40, 0xe7, 0x2e, 0x19, 0xe1, 0xfd, 0x8e, 0x71, - 0xee, 0x5f, 0xfd, 0xaa, 0x26, 0x47, 0x88, 0x68, 0x17, 0xe1, 0x00, 0x20, 0xee, 0x34, 0x95, 0x75, 0xa8, 0x01, 0xfa, - 0x80, 0xc0, 0x3a, 0xf4, 0x6d, 0x06, 0x70, 0xd0, 0x47, 0x9b, 0x67, 0x11, 0xc8, 0xeb, 0xde, 0x1d, 0xbb, 0x66, 0x3b, - 0x9f, 0x3f, 0x5d, 0xa5, 0xde, 0x1d, 0x3a, 0x04, 0x9f, 0x8f, 0xfd, 0xe9, 0x65, 0xa0, 0xd5, 0x9e, 0xd7, 0xec, 0xfa, - 0xb1, 0x60, 0x3b, 0xb6, 0x7b, 0x8c, 0x48, 0x45, 0xdd, 0xf9, 0x87, 0x97, 0x26, 0x7a, 0xde, 0x79, 0xe1, 0x96, 0x2f, - 0x01, 0x3c, 0x90, 0xc5, 0x80, 0xe2, 0xb3, 0xf4, 0x7e, 0x61, 0x09, 0xa8, 0xc9, 0x6f, 0xf8, 0xda, 0x7b, 0x4b, 0xa9, - 0x0b, 0xf8, 0x73, 0x40, 0xe9, 0x93, 0x9c, 0x7b, 0xb7, 0xc3, 0x1b, 0xff, 0xe2, 0x09, 0x38, 0x4f, 0xac, 0x86, 0x0b, - 0xf8, 0xab, 0xe0, 0x43, 0xef, 0x76, 0x80, 0x89, 0x25, 0x1f, 0x7a, 0xab, 0x01, 0xa4, 0x2a, 0x5c, 0x48, 0x8c, 0x7d, - 0xf8, 0x2d, 0xc8, 0x19, 0xfe, 0xf1, 0xbb, 0xc6, 0x60, 0xfd, 0x2d, 0x28, 0x34, 0x1a, 0x6b, 0xa9, 0x42, 0x96, 0x62, - 0x71, 0x26, 0xc0, 0x26, 0x1c, 0x77, 0xfb, 0x62, 0x55, 0x9b, 0xb5, 0xa0, 0x3f, 0x1f, 0xf0, 0x3d, 0x1a, 0xab, 0xab, - 0x72, 0x2e, 0xca, 0x0f, 0x48, 0x9f, 0xea, 0xf8, 0x18, 0x15, 0x9b, 0xba, 0x3b, 0x9d, 0x6a, 0xd5, 0x91, 0xf6, 0xbb, - 0x72, 0x0d, 0x76, 0xbc, 0x4e, 0x8e, 0x2c, 0x85, 0x67, 0x1d, 0x76, 0x5e, 0x3a, 0x25, 0x3a, 0x0c, 0xe3, 0xdd, 0x56, - 0x3d, 0x63, 0x28, 0xcf, 0x0d, 0xc6, 0x74, 0xc1, 0x23, 0xfe, 0x74, 0x90, 0xcb, 0xd0, 0x98, 0x77, 0xc8, 0x86, 0xa1, - 0x7c, 0x68, 0x91, 0x21, 0x21, 0xe2, 0x3d, 0x54, 0x02, 0xb6, 0x2d, 0x28, 0x93, 0x02, 0xce, 0xa2, 0xc1, 0xef, 0xb5, - 0x97, 0x03, 0xef, 0x41, 0xe4, 0x37, 0xd2, 0xa5, 0x5c, 0x62, 0xa3, 0x13, 0xc7, 0xb2, 0xd0, 0xce, 0xe3, 0xfa, 0xeb, - 0x18, 0xd4, 0xef, 0x95, 0x7e, 0x83, 0x72, 0xf6, 0x07, 0xc9, 0x3a, 0x6d, 0x3c, 0x31, 0xfe, 0xed, 0x2a, 0xff, 0x14, - 0x2d, 0xf5, 0xf0, 0xff, 0x19, 0x53, 0x28, 0xfd, 0x75, 0x5a, 0x46, 0x9b, 0xd5, 0x52, 0x94, 0x22, 0x8f, 0xc4, 0xc9, - 0xd7, 0x22, 0x3b, 0x97, 0xef, 0x7c, 0x0a, 0xfd, 0x02, 0xd0, 0xb2, 0x4f, 0x90, 0xd1, 0xbf, 0x32, 0xc1, 0x87, 0xbf, - 0x6a, 0xe7, 0xda, 0x9c, 0x8f, 0x27, 0xf9, 0x95, 0xb5, 0x77, 0x3b, 0x5e, 0x24, 0x46, 0x31, 0x96, 0xfb, 0xaa, 0x9b, - 0x95, 0x13, 0x95, 0x1c, 0x18, 0xe9, 0x9a, 0xec, 0xe5, 0x4a, 0xd6, 0xed, 0x74, 0x2b, 0x81, 0x88, 0x2a, 0xf0, 0x1e, - 0xe3, 0x2a, 0xf6, 0x11, 0x4c, 0xd7, 0x1d, 0x97, 0xd1, 0x8e, 0xf7, 0x8c, 0x57, 0x27, 0xca, 0x0a, 0x6e, 0x37, 0xa2, - 0x3d, 0xa1, 0xa3, 0x9f, 0x26, 0xb5, 0x65, 0xe1, 0x00, 0xe4, 0x2e, 0x61, 0x2c, 0x1b, 0x82, 0x15, 0x83, 0xd2, 0xd7, - 0x6b, 0x4a, 0x96, 0x05, 0x58, 0x74, 0x76, 0x19, 0x81, 0x18, 0xd6, 0x4d, 0x73, 0x42, 0xc7, 0x4b, 0x17, 0xe7, 0xbd, - 0x56, 0x91, 0x82, 0x67, 0xb4, 0xe8, 0x98, 0x9b, 0x8e, 0x74, 0x63, 0xb4, 0xb7, 0xcf, 0x0d, 0x42, 0x8a, 0xe7, 0x0f, - 0x6c, 0xb5, 0x2e, 0x2e, 0x12, 0xaf, 0x90, 0x89, 0x16, 0xc4, 0x52, 0x04, 0x66, 0xbc, 0xd0, 0x34, 0xc2, 0x04, 0x65, - 0x4a, 0xb0, 0x68, 0x8d, 0x0e, 0xed, 0x0f, 0x4b, 0xd8, 0x3d, 0xc6, 0x08, 0x10, 0xa8, 0x32, 0xfd, 0x1a, 0xb6, 0x26, - 0xcc, 0xa6, 0x2e, 0x36, 0x40, 0x5b, 0xc5, 0xd0, 0x20, 0xac, 0x0d, 0x31, 0x1f, 0xd2, 0xfc, 0xf6, 0x5f, 0x58, 0x8c, - 0xed, 0x09, 0xc4, 0xf6, 0x6e, 0xd7, 0x24, 0x4c, 0xf7, 0x5a, 0xdc, 0x58, 0x2f, 0xb7, 0xa7, 0x1c, 0x53, 0x3b, 0xd6, - 0x46, 0xed, 0x58, 0x4b, 0xbd, 0x63, 0xad, 0xf5, 0x8e, 0x75, 0xdb, 0xf0, 0x67, 0x99, 0x17, 0xb3, 0x04, 0xf4, 0xbb, - 0x2b, 0xae, 0x1a, 0x04, 0xcd, 0xd8, 0xb0, 0x1b, 0xf8, 0x2d, 0xb1, 0x76, 0x4b, 0xff, 0x62, 0xc9, 0x16, 0xa6, 0x0f, - 0x74, 0xeb, 0x00, 0xcb, 0x88, 0x9a, 0x7c, 0x87, 0xbc, 0x9b, 0xce, 0x8a, 0xc2, 0xed, 0x89, 0x2d, 0x7c, 0x76, 0x6d, - 0xde, 0xbc, 0x7b, 0x1c, 0x41, 0xee, 0x1d, 0xf7, 0xee, 0x86, 0xd7, 0xfe, 0x85, 0x6e, 0x81, 0x9c, 0xcc, 0x72, 0x06, - 0x52, 0x47, 0x7c, 0x82, 0x68, 0x65, 0x4f, 0xf9, 0x4e, 0xc8, 0x9d, 0x6d, 0xfd, 0xf8, 0xce, 0xdd, 0xd6, 0x6e, 0x1f, - 0xdf, 0xb1, 0x6a, 0x44, 0xb1, 0xe2, 0x34, 0x45, 0xc2, 0x2c, 0xda, 0x00, 0x4f, 0xbd, 0x7c, 0xbf, 0x63, 0xc7, 0x1c, - 0xee, 0x1e, 0x77, 0x74, 0xbc, 0x9c, 0x03, 0x76, 0xf7, 0x1f, 0x6d, 0xc2, 0xc6, 0x4a, 0xd7, 0x2a, 0x74, 0xb8, 0x7b, - 0x9c, 0x69, 0x3c, 0x87, 0x23, 0xf9, 0x74, 0xac, 0xb1, 0x41, 0x50, 0xd7, 0xe7, 0x0c, 0x6a, 0xc7, 0xee, 0x6b, 0xc2, - 0x2e, 0x3b, 0xe6, 0xb5, 0xae, 0x79, 0x7b, 0xe5, 0xa9, 0xd8, 0x10, 0xd0, 0xe1, 0x6b, 0x75, 0x83, 0xfc, 0x4b, 0xe0, - 0x14, 0x01, 0x20, 0x87, 0xe3, 0x25, 0x8f, 0x7d, 0x9f, 0x66, 0x69, 0xbd, 0x43, 0xad, 0x45, 0x65, 0x59, 0x86, 0xb5, - 0xf7, 0x83, 0x56, 0x0c, 0x4b, 0x4d, 0xff, 0x74, 0x1c, 0xb8, 0x9d, 0xed, 0x56, 0xc6, 0x2e, 0xe3, 0x71, 0x71, 0xf1, - 0xeb, 0x69, 0xa1, 0x5c, 0xbb, 0x79, 0x1b, 0xbf, 0x69, 0xb5, 0x64, 0x69, 0xad, 0x87, 0xbc, 0xb4, 0x2c, 0x22, 0x10, - 0xc0, 0x70, 0xa4, 0xec, 0x62, 0x09, 0xf7, 0x08, 0xab, 0x7b, 0x10, 0x4a, 0xe6, 0x85, 0x8b, 0x27, 0x2c, 0x86, 0x44, - 0x80, 0xed, 0x0e, 0x15, 0xdb, 0xc2, 0xc5, 0x13, 0xb6, 0xe1, 0x45, 0xbf, 0x9f, 0xa9, 0x4e, 0x21, 0xeb, 0xce, 0x92, - 0x6f, 0x54, 0x73, 0xac, 0xa1, 0x66, 0x6b, 0x93, 0x6c, 0x8d, 0x73, 0x5b, 0xf1, 0x71, 0xdb, 0x56, 0x7c, 0xac, 0xac, - 0x75, 0xe9, 0x5e, 0xef, 0x51, 0x5d, 0x00, 0x5b, 0xff, 0xcd, 0xf1, 0xca, 0xf5, 0x7c, 0x46, 0x00, 0x5f, 0x0b, 0x3e, - 0x9e, 0x2c, 0xd0, 0xab, 0x64, 0xe1, 0xdf, 0x0c, 0xd4, 0xf8, 0x3b, 0x9d, 0xbb, 0x00, 0xe8, 0x4a, 0xca, 0x2b, 0x20, - 0xef, 0x20, 0xc7, 0xdc, 0xb2, 0x2b, 0xef, 0x4e, 0xbe, 0xc3, 0xae, 0x79, 0x3d, 0x5b, 0xcc, 0xd9, 0x0e, 0x9c, 0x0a, - 0x92, 0x81, 0xbd, 0xac, 0xd8, 0x2e, 0x88, 0xed, 0x84, 0xdf, 0x09, 0x98, 0xf2, 0x19, 0x04, 0x71, 0x05, 0x37, 0x10, - 0x87, 0x27, 0xff, 0x1c, 0xdc, 0xb5, 0x36, 0xeb, 0x3b, 0x66, 0x75, 0x4e, 0xb0, 0x66, 0x56, 0x0f, 0x06, 0xcb, 0x66, - 0xb2, 0xea, 0xf7, 0xbd, 0x9d, 0x76, 0x7c, 0xba, 0x95, 0x3a, 0xb1, 0xd3, 0x5a, 0xad, 0x05, 0xbb, 0x96, 0x5a, 0x17, - 0x63, 0xe8, 0x01, 0xe2, 0xa7, 0x9b, 0x01, 0xbf, 0xeb, 0x58, 0x5b, 0xde, 0x35, 0x5b, 0xb0, 0x1d, 0x5c, 0x82, 0x9a, - 0xf6, 0xb2, 0x3f, 0xa9, 0x5c, 0xd0, 0x8e, 0x5d, 0x12, 0x0f, 0x67, 0xcc, 0x2a, 0x65, 0x66, 0x9d, 0x54, 0x57, 0xa2, - 0x33, 0xa6, 0xb3, 0xd6, 0xf3, 0xb9, 0x9a, 0x4f, 0x0a, 0x0d, 0xea, 0x77, 0x4e, 0x7c, 0x44, 0x45, 0xe7, 0x09, 0x6c, - 0x2d, 0x2b, 0x88, 0xd5, 0x3e, 0x07, 0x6b, 0xad, 0x76, 0xe9, 0xf7, 0xf2, 0x01, 0xb7, 0x29, 0x87, 0x75, 0x60, 0x50, - 0x73, 0x62, 0x45, 0x3d, 0x64, 0x3b, 0xc6, 0xcd, 0x4f, 0x2f, 0x7f, 0x70, 0xc2, 0x92, 0x15, 0xab, 0xfd, 0xe9, 0xaf, - 0x8f, 0x3d, 0xfd, 0x9d, 0xda, 0xbf, 0x10, 0x7e, 0x30, 0xfe, 0x4f, 0xed, 0xbe, 0xd6, 0x62, 0x54, 0xb6, 0xca, 0x11, - 0x1a, 0x77, 0x2b, 0x69, 0xb2, 0xfc, 0x24, 0x3c, 0x61, 0x2d, 0x78, 0x96, 0xeb, 0x25, 0x9a, 0x15, 0xb0, 0xc2, 0x5a, - 0x26, 0xe1, 0x0a, 0x63, 0xb5, 0xb4, 0xd5, 0xb7, 0x68, 0x9a, 0xe3, 0xc3, 0xb9, 0x36, 0x28, 0x53, 0xce, 0xce, 0x88, - 0xd5, 0x70, 0x19, 0x96, 0x26, 0x14, 0x21, 0xbb, 0xb7, 0x83, 0x1b, 0x3b, 0x65, 0x29, 0x65, 0x38, 0xc7, 0x60, 0xc2, - 0x23, 0x31, 0xaa, 0xf2, 0xfd, 0x7d, 0x49, 0x91, 0xd3, 0xb6, 0x1c, 0x54, 0x21, 0xec, 0x23, 0x89, 0x12, 0xb8, 0x15, - 0x69, 0xa1, 0x48, 0x59, 0xfc, 0xed, 0x00, 0x5d, 0xe0, 0x05, 0xd4, 0xd5, 0xa8, 0xdb, 0x1f, 0x8e, 0x78, 0xf8, 0xc0, - 0xd4, 0x07, 0x46, 0x2c, 0x09, 0xd4, 0xf6, 0x2c, 0x4b, 0x6f, 0x41, 0x85, 0xdf, 0xc3, 0xd5, 0x44, 0xec, 0xe7, 0x96, - 0x14, 0x15, 0xd9, 0x48, 0x6f, 0x68, 0x0d, 0x1e, 0xa1, 0x35, 0xe5, 0xb9, 0x93, 0x6a, 0x93, 0xce, 0x3b, 0x42, 0x8e, - 0xd5, 0xb7, 0x96, 0x30, 0xda, 0x15, 0xbd, 0xb8, 0x77, 0xf4, 0x9e, 0xa7, 0xab, 0x9e, 0xfb, 0x13, 0x57, 0xcc, 0x93, - 0xdb, 0x08, 0xd4, 0xad, 0xa0, 0xba, 0xbd, 0x53, 0x09, 0x16, 0x2c, 0x69, 0xf7, 0xf1, 0xdb, 0x59, 0x3b, 0x10, 0x95, - 0xb1, 0x4a, 0xdf, 0x92, 0x84, 0x3d, 0x31, 0xe8, 0x14, 0xaa, 0x72, 0xbb, 0x3b, 0xda, 0x02, 0xd7, 0x31, 0x4b, 0xd1, - 0x33, 0x5b, 0xe4, 0x6e, 0xf9, 0x77, 0xcf, 0x15, 0x39, 0xfb, 0x25, 0x20, 0x38, 0x35, 0xdf, 0x10, 0x5f, 0x8e, 0xf0, - 0xa8, 0xba, 0x05, 0x8e, 0xd3, 0x77, 0x00, 0xff, 0x70, 0xb8, 0x04, 0x4d, 0x40, 0x2c, 0x58, 0x2f, 0x8d, 0x7b, 0xac, - 0x17, 0x17, 0x9b, 0xdb, 0x24, 0xdf, 0x80, 0x33, 0x03, 0xa5, 0x5a, 0xfa, 0x81, 0x63, 0xb5, 0x80, 0x0a, 0x07, 0xb3, - 0x93, 0x7a, 0x61, 0x19, 0xf5, 0x98, 0x3e, 0x3f, 0x83, 0xbd, 0x23, 0x24, 0x00, 0xee, 0x97, 0x7d, 0x40, 0x02, 0x1e, - 0x3a, 0xb3, 0x03, 0xc2, 0x09, 0xb3, 0xa8, 0x0a, 0x24, 0x92, 0x23, 0xfd, 0xec, 0x31, 0x13, 0xc9, 0x1f, 0xcc, 0x7a, - 0xce, 0x29, 0xd1, 0x63, 0x3d, 0x75, 0x84, 0xf4, 0x58, 0xcf, 0x3a, 0x22, 0x7a, 0xac, 0x67, 0x1d, 0x1f, 0x3d, 0xd6, - 0x33, 0xc7, 0x4e, 0x0f, 0x02, 0x13, 0x20, 0xf2, 0x80, 0xf5, 0x68, 0x32, 0xf5, 0x14, 0xf7, 0x00, 0xd1, 0x20, 0xb0, - 0x9e, 0x14, 0xce, 0x7b, 0x80, 0x3c, 0x46, 0x62, 0x75, 0xd0, 0xfb, 0xcb, 0xf8, 0x87, 0x9e, 0x91, 0x91, 0xc7, 0xad, - 0xc3, 0xea, 0x7f, 0xfd, 0x15, 0x02, 0xe0, 0xf0, 0x6c, 0xea, 0x5d, 0x8e, 0x21, 0xab, 0x2c, 0x23, 0x90, 0xfc, 0xc4, - 0xe0, 0xcb, 0x17, 0x00, 0x55, 0x9f, 0xe9, 0x5a, 0x4d, 0x8e, 0xda, 0x63, 0x0e, 0x5d, 0x31, 0x00, 0x6c, 0xc3, 0x12, - 0x55, 0xb5, 0xb0, 0x09, 0x8b, 0xdb, 0xcf, 0x30, 0x9a, 0xcb, 0xa6, 0x17, 0x34, 0x50, 0x8f, 0x10, 0xfc, 0xd2, 0x7a, - 0x68, 0xad, 0x65, 0xca, 0xa1, 0x6b, 0xa3, 0xa8, 0xb2, 0xa1, 0x2e, 0x61, 0xb5, 0x16, 0x51, 0x4d, 0x14, 0x29, 0x97, - 0x8c, 0xa2, 0x58, 0xaa, 0x60, 0x9f, 0x89, 0x5b, 0x88, 0x9a, 0xa7, 0xad, 0xb6, 0x0a, 0xf6, 0xb7, 0x80, 0xb0, 0x16, - 0xd6, 0x42, 0x3a, 0x83, 0xda, 0x3b, 0xfd, 0x48, 0xf9, 0xcb, 0x0b, 0xb9, 0x9d, 0x5b, 0x28, 0xc2, 0xed, 0x39, 0x28, - 0x6f, 0xea, 0xaa, 0x54, 0x44, 0xa3, 0x25, 0x50, 0xca, 0x9c, 0x20, 0xb2, 0x00, 0x01, 0x1c, 0x37, 0x10, 0xf8, 0xbc, - 0xc6, 0x27, 0xd0, 0x28, 0x04, 0xf2, 0x03, 0xab, 0x70, 0xed, 0x21, 0x2d, 0xb5, 0x46, 0x44, 0x89, 0xf8, 0xd1, 0xd5, - 0x73, 0x6c, 0x5f, 0x3d, 0x8d, 0xb5, 0xa5, 0x34, 0x41, 0xfc, 0xc4, 0x62, 0x0b, 0x31, 0x41, 0x54, 0x87, 0xe8, 0x08, - 0x96, 0x13, 0x42, 0x14, 0xfe, 0x14, 0xfa, 0xa9, 0x81, 0xbf, 0x64, 0xcb, 0x22, 0xaf, 0x09, 0x16, 0xb3, 0x62, 0x80, - 0x56, 0x45, 0xe0, 0x99, 0xce, 0x96, 0xca, 0x9c, 0xe6, 0xd1, 0x91, 0x1d, 0x9c, 0x77, 0x1d, 0xec, 0xa5, 0x2f, 0x63, - 0x27, 0xcb, 0xa6, 0x51, 0x1b, 0x1b, 0x22, 0xe1, 0x15, 0xf9, 0x75, 0x96, 0x1a, 0xe7, 0xc8, 0x5c, 0xae, 0xef, 0xba, - 0xb8, 0xbd, 0xa5, 0x6d, 0xc2, 0x2a, 0x44, 0xa8, 0xdb, 0x86, 0xca, 0xa5, 0x30, 0x1b, 0x9b, 0xa6, 0x01, 0xbe, 0x50, - 0x54, 0x2a, 0x55, 0xa9, 0xad, 0x54, 0x72, 0xc2, 0xbb, 0xbe, 0xa9, 0x45, 0xea, 0x8a, 0x60, 0x1b, 0x33, 0xd4, 0x43, - 0xb9, 0x51, 0x63, 0xdf, 0x76, 0xac, 0xd2, 0x3b, 0x4c, 0x90, 0x33, 0xf2, 0x22, 0x07, 0x17, 0x25, 0x05, 0x99, 0xab, - 0x21, 0xcc, 0x1f, 0x34, 0x7c, 0x5a, 0x58, 0xee, 0xa1, 0x04, 0xcc, 0x8e, 0x1a, 0x1e, 0x45, 0x08, 0x44, 0x5c, 0x2a, - 0xfb, 0x8a, 0x89, 0xdf, 0x53, 0x30, 0x4b, 0x26, 0x74, 0x2f, 0x62, 0x59, 0x84, 0x36, 0x3e, 0x49, 0x92, 0xa9, 0xa7, - 0x29, 0xb8, 0x91, 0xcb, 0x30, 0x47, 0x23, 0xb4, 0xe4, 0x23, 0x07, 0xd2, 0xd7, 0x72, 0x2a, 0xc1, 0x47, 0xd4, 0x29, - 0xe0, 0x78, 0x7e, 0x5e, 0x58, 0x3f, 0x59, 0x2e, 0x31, 0x97, 0xb5, 0xf9, 0x2f, 0x3b, 0x3a, 0x06, 0xbb, 0x3c, 0x4d, - 0x1c, 0x57, 0xff, 0x51, 0x95, 0x14, 0xf7, 0xaf, 0xd3, 0x1c, 0x50, 0x04, 0x33, 0x7b, 0x8a, 0xf1, 0xb1, 0xcf, 0x32, - 0x05, 0xfc, 0xed, 0x7a, 0x6b, 0xc9, 0xc4, 0x2e, 0x69, 0x37, 0x57, 0xc6, 0x2f, 0xb5, 0x61, 0xc7, 0xc1, 0xb9, 0x01, - 0x28, 0xce, 0x1a, 0x1d, 0x96, 0xd7, 0xba, 0x6d, 0x55, 0xa8, 0x40, 0xad, 0xff, 0xb3, 0x5b, 0x98, 0xf2, 0x36, 0x2f, - 0x95, 0xb7, 0x79, 0x68, 0x02, 0x04, 0x22, 0x33, 0xe4, 0x59, 0xd3, 0x31, 0x49, 0xdc, 0x3b, 0x52, 0xd2, 0xbe, 0x23, - 0xc5, 0x0f, 0xde, 0x91, 0x90, 0x6f, 0x09, 0x1d, 0xd9, 0x97, 0x9c, 0x9c, 0x40, 0x99, 0xc1, 0x5e, 0x5e, 0x33, 0xd9, - 0x3f, 0xa0, 0xbd, 0x70, 0x2e, 0xcb, 0x2b, 0xfe, 0x46, 0x78, 0x6b, 0x7f, 0xba, 0x3e, 0xed, 0xaa, 0x7a, 0xf3, 0x8d, - 0x99, 0x79, 0x38, 0x14, 0x87, 0x43, 0x65, 0x82, 0x76, 0x17, 0x5c, 0x0c, 0x72, 0x76, 0xe7, 0xc6, 0xc7, 0x5f, 0x73, - 0x14, 0xb1, 0x95, 0xf2, 0x48, 0xba, 0x50, 0x89, 0xe1, 0xa5, 0x81, 0x87, 0xd9, 0xf1, 0xf1, 0x64, 0x77, 0x75, 0x37, - 0x19, 0x0c, 0x76, 0xaa, 0x6f, 0xb7, 0xbc, 0x9e, 0xed, 0xe6, 0xec, 0x9e, 0xdf, 0x4c, 0xb7, 0xc1, 0xbe, 0x81, 0x6d, - 0x77, 0x77, 0x25, 0x0e, 0x87, 0xdd, 0x53, 0xbe, 0xf0, 0xf7, 0xf7, 0x08, 0xe8, 0xcc, 0xcf, 0xc7, 0x6d, 0x8c, 0x9f, - 0x37, 0x6d, 0x57, 0xad, 0x1d, 0xc0, 0xd3, 0xbf, 0xf2, 0xde, 0xcc, 0x96, 0x73, 0x9f, 0xbd, 0xe7, 0xf7, 0xe0, 0x9f, - 0x8f, 0x9b, 0x24, 0x52, 0x9f, 0x68, 0x97, 0xc9, 0x37, 0xe0, 0x40, 0xbe, 0xf3, 0xd9, 0x27, 0x7e, 0x3f, 0x5b, 0xce, - 0x79, 0x71, 0x38, 0x3c, 0x9a, 0x86, 0x48, 0xd6, 0x14, 0x56, 0xc4, 0x92, 0xe2, 0xf9, 0x41, 0x78, 0xfc, 0x5e, 0x44, - 0x86, 0x48, 0xcb, 0xbd, 0x3b, 0x64, 0x6f, 0x58, 0xe4, 0x07, 0xf0, 0x41, 0xb6, 0xf3, 0x27, 0xb2, 0xa6, 0x74, 0xbf, - 0x78, 0xef, 0x1f, 0x0e, 0xf4, 0xd7, 0x27, 0xff, 0x70, 0x78, 0xc4, 0xee, 0x11, 0x1c, 0x9d, 0xef, 0xa0, 0x7f, 0xf4, - 0xad, 0x03, 0xaa, 0x32, 0xbc, 0x9e, 0x6d, 0xe6, 0xfe, 0xd3, 0x15, 0xbb, 0x05, 0x2e, 0x14, 0xe5, 0x85, 0xf6, 0x86, - 0xdd, 0xa3, 0xd7, 0x19, 0x39, 0x11, 0xcd, 0x76, 0x73, 0x9f, 0xc5, 0xf8, 0x5c, 0xdd, 0x17, 0x93, 0x6f, 0xde, 0x17, - 0x77, 0x6c, 0xdb, 0x7d, 0x5f, 0x94, 0x6f, 0xba, 0xeb, 0x67, 0xcb, 0x76, 0xec, 0x1e, 0x66, 0xd8, 0x35, 0x7f, 0xd3, - 0x1c, 0x3b, 0xc6, 0x7e, 0xf3, 0xc6, 0x08, 0xa0, 0xcc, 0x16, 0x2c, 0x16, 0x1c, 0x94, 0x6a, 0xd5, 0xb6, 0x24, 0xf2, - 0x4a, 0x07, 0xaa, 0xcd, 0x08, 0xee, 0xab, 0x85, 0x9c, 0x79, 0x66, 0xa0, 0x6f, 0x2b, 0x44, 0x0b, 0x87, 0x0d, 0xf8, - 0x1b, 0x6d, 0x1d, 0x63, 0x98, 0x66, 0x35, 0xd3, 0xb6, 0xa8, 0xcb, 0xef, 0x7b, 0xcf, 0xe4, 0x37, 0x32, 0xb0, 0x85, - 0x48, 0x0a, 0xc7, 0xf1, 0xc5, 0x93, 0x13, 0xfe, 0xab, 0x96, 0x47, 0xad, 0xf6, 0x0b, 0xa5, 0x3e, 0xbd, 0xa6, 0x23, - 0x9a, 0xb8, 0x17, 0x6d, 0x19, 0xd6, 0x28, 0x6b, 0x6a, 0xe9, 0x30, 0x8c, 0x6b, 0xd8, 0x97, 0x07, 0x0e, 0x7d, 0x07, - 0x04, 0xda, 0x2a, 0x95, 0x02, 0x2d, 0x1c, 0xc3, 0x28, 0xcc, 0x42, 0xca, 0xc3, 0xc2, 0x2c, 0xe5, 0x3d, 0x16, 0x68, - 0x71, 0xab, 0xee, 0x31, 0xb5, 0xdd, 0x82, 0x08, 0xab, 0xb7, 0x8c, 0xf3, 0xcb, 0x46, 0x15, 0x6e, 0x0b, 0x50, 0x14, - 0x41, 0x19, 0xec, 0x49, 0x6e, 0x5b, 0x28, 0x69, 0x36, 0x0a, 0x6b, 0x71, 0x5b, 0x94, 0xbb, 0x5e, 0xc3, 0x16, 0x78, - 0x41, 0xd5, 0x4f, 0x08, 0xdb, 0xb2, 0x67, 0x1d, 0xca, 0x45, 0xfa, 0x1f, 0x59, 0x7a, 0xbe, 0xdf, 0x9a, 0xf3, 0x3f, - 0x7d, 0x45, 0x1f, 0x95, 0xff, 0xf9, 0x25, 0xfd, 0x64, 0xb0, 0x8c, 0x9c, 0x52, 0xbf, 0x44, 0xa3, 0x9b, 0x34, 0x27, - 0x8c, 0x2d, 0x5f, 0x3f, 0xfd, 0x0e, 0x99, 0x82, 0xe4, 0x50, 0x4a, 0x55, 0x4e, 0xf6, 0xd0, 0x17, 0x5e, 0xf7, 0x61, - 0x26, 0x18, 0x80, 0xf0, 0x1a, 0x6d, 0xaa, 0x09, 0x93, 0x78, 0x70, 0x05, 0xff, 0x37, 0x82, 0x18, 0xb4, 0x4f, 0x14, - 0x75, 0x6c, 0x1b, 0xe9, 0xba, 0xed, 0x1c, 0x24, 0x77, 0xea, 0xca, 0x1f, 0x95, 0x93, 0xff, 0x44, 0x43, 0xe4, 0x15, - 0x57, 0x88, 0x95, 0x05, 0x97, 0x58, 0x0c, 0x15, 0x29, 0xc0, 0x35, 0x04, 0x91, 0xb2, 0x28, 0x29, 0xdc, 0x72, 0x50, - 0x15, 0x01, 0x18, 0x57, 0xab, 0xa3, 0x4e, 0x84, 0x8f, 0x5b, 0x6b, 0x11, 0x82, 0x15, 0x8d, 0x5a, 0x59, 0x2b, 0xf0, - 0x05, 0xe9, 0x4b, 0x87, 0x82, 0x98, 0x1e, 0x85, 0x54, 0x95, 0x0e, 0x05, 0xd2, 0x1c, 0x2a, 0xbe, 0x31, 0xd8, 0x28, - 0x2a, 0xd2, 0xf3, 0x97, 0x26, 0x25, 0x97, 0xc6, 0x8c, 0xf7, 0xa2, 0x8c, 0x44, 0x5e, 0x87, 0xb7, 0x62, 0x5a, 0x20, - 0xdf, 0xe8, 0xf1, 0x83, 0xe0, 0x12, 0xde, 0x0d, 0xb9, 0x57, 0x80, 0x2d, 0x01, 0x3b, 0xc0, 0xbd, 0x32, 0xa3, 0x5c, - 0xa7, 0x75, 0xfd, 0xd6, 0x7a, 0x28, 0x86, 0xe1, 0x63, 0x4b, 0x60, 0x3b, 0x5a, 0x47, 0x47, 0x7a, 0xf8, 0xf0, 0xbf, - 0xae, 0x6a, 0x8e, 0x3a, 0x95, 0xcb, 0xd9, 0xf1, 0x84, 0xa5, 0x88, 0x19, 0x74, 0x7f, 0xdd, 0x5e, 0x0b, 0xa0, 0xdb, - 0x65, 0x31, 0xcf, 0x46, 0x3b, 0xf9, 0xb7, 0x74, 0x63, 0x45, 0x69, 0x13, 0xef, 0xb2, 0xde, 0xd8, 0x1f, 0x8e, 0xfe, - 0xf2, 0xf8, 0xed, 0x84, 0x50, 0x75, 0x36, 0x6c, 0xad, 0xe3, 0x5c, 0xfe, 0xd7, 0x5f, 0xc7, 0x64, 0x05, 0x41, 0x41, - 0x58, 0x76, 0x8a, 0x89, 0x0a, 0x46, 0x91, 0x62, 0xcd, 0xc7, 0x93, 0x35, 0xea, 0x84, 0xd7, 0xfe, 0x52, 0xeb, 0x84, - 0x89, 0x91, 0x95, 0xca, 0x5f, 0xb3, 0x8a, 0xdd, 0xaa, 0xcc, 0x02, 0x32, 0x0f, 0xf2, 0xc9, 0xda, 0x68, 0x30, 0x57, - 0xbc, 0x9e, 0xad, 0xe7, 0x52, 0xf9, 0x0c, 0xa6, 0x9c, 0xe5, 0xe0, 0x64, 0x29, 0xec, 0x8e, 0x04, 0x8a, 0xd6, 0x0c, - 0x5d, 0xfb, 0x53, 0x6c, 0xd5, 0x8b, 0xb4, 0xaa, 0x01, 0x1e, 0x10, 0x62, 0x60, 0xa8, 0xbd, 0x5a, 0x78, 0x68, 0x2d, - 0x80, 0xb5, 0x3f, 0x2a, 0xfd, 0x60, 0x3c, 0x59, 0xf2, 0x05, 0xf2, 0x2f, 0x47, 0x8e, 0xda, 0xbd, 0xdf, 0xf7, 0xee, - 0x40, 0x0a, 0x8e, 0x5c, 0x0b, 0x05, 0x12, 0x01, 0x2d, 0xf8, 0xc6, 0x57, 0x3e, 0x18, 0xd7, 0xa8, 0xad, 0x06, 0x05, - 0xb5, 0xa3, 0x5b, 0x1e, 0x3b, 0x7a, 0xe7, 0xbb, 0x13, 0xfa, 0xea, 0x85, 0x16, 0x8e, 0xbf, 0x71, 0x46, 0xae, 0xd9, - 0xaa, 0x43, 0x8e, 0x68, 0x26, 0x1d, 0x42, 0xc4, 0x8a, 0xad, 0xd9, 0x35, 0xa9, 0x9c, 0x3b, 0x87, 0xec, 0xf4, 0x11, - 0xaa, 0xf4, 0x5a, 0x0f, 0x6f, 0x27, 0x4a, 0x77, 0x7b, 0xbc, 0x9b, 0x7c, 0xcf, 0x26, 0x22, 0x06, 0x03, 0xda, 0x20, - 0x9c, 0x91, 0x75, 0x88, 0x54, 0x3a, 0x40, 0x08, 0x1c, 0x13, 0xd0, 0xf4, 0xdf, 0xdf, 0x92, 0x28, 0xe0, 0x48, 0x1b, - 0x21, 0x6b, 0xd9, 0xe1, 0x90, 0x83, 0x46, 0xb9, 0xf9, 0xd3, 0x2b, 0xd4, 0x69, 0x0e, 0xcc, 0xd3, 0x25, 0xec, 0x39, - 0x78, 0xa4, 0x17, 0xc7, 0x47, 0xfa, 0x7f, 0x47, 0x13, 0x35, 0xfe, 0xcf, 0x35, 0x51, 0x4a, 0x8b, 0xe4, 0xa8, 0x96, - 0xbe, 0x4b, 0x1d, 0x05, 0x17, 0x79, 0x47, 0x2d, 0x64, 0xcf, 0xb2, 0x71, 0xa3, 0x9a, 0xf7, 0xff, 0x6b, 0x65, 0xfe, - 0xbf, 0xa6, 0x95, 0x61, 0x4a, 0x76, 0x2c, 0xd5, 0xcc, 0x03, 0xad, 0x62, 0x98, 0xbd, 0x26, 0x09, 0x91, 0xe1, 0xd2, - 0x80, 0x1f, 0x55, 0xb0, 0x8f, 0xd3, 0x6a, 0x9d, 0x85, 0x3b, 0x54, 0xa2, 0xde, 0x88, 0xdb, 0x34, 0x7f, 0x56, 0xff, - 0x5b, 0x94, 0x05, 0x4c, 0xed, 0xdb, 0x32, 0x8d, 0x03, 0xb2, 0xf0, 0x67, 0x61, 0x89, 0x93, 0x1b, 0xdb, 0xf8, 0x5a, - 0x8e, 0xa7, 0xfd, 0xaa, 0x33, 0xf3, 0x40, 0x02, 0x35, 0xb0, 0x94, 0xe4, 0x5c, 0x56, 0x16, 0xf7, 0x08, 0xdd, 0xfc, - 0x53, 0x59, 0x16, 0xa5, 0xd7, 0xfb, 0x94, 0xa4, 0xd5, 0xd9, 0x4a, 0xd4, 0x49, 0x11, 0x2b, 0x28, 0x9b, 0x14, 0x60, - 0xf4, 0x61, 0xe5, 0x89, 0x38, 0x38, 0x43, 0xa0, 0x86, 0xb3, 0x3a, 0x09, 0x01, 0x68, 0x58, 0x21, 0xec, 0x9f, 0x41, - 0x0b, 0xcf, 0xc2, 0x38, 0x5c, 0x03, 0x4c, 0x4e, 0x5a, 0x9d, 0xad, 0xcb, 0xe2, 0x2e, 0x8d, 0x45, 0x3c, 0xea, 0x29, - 0x4a, 0x96, 0xb7, 0xb9, 0x2b, 0xe7, 0xfa, 0xfb, 0x3f, 0x29, 0x80, 0xdd, 0x80, 0xd9, 0xb6, 0xc0, 0x0e, 0x00, 0x12, - 0x14, 0xc8, 0x16, 0xea, 0x34, 0x3a, 0x53, 0x4b, 0x05, 0xde, 0x73, 0x3d, 0xc0, 0xdf, 0xe6, 0x80, 0x65, 0x5c, 0x17, - 0x32, 0x60, 0x04, 0x01, 0x8c, 0xc0, 0x41, 0x09, 0x18, 0x3a, 0x43, 0xdc, 0x56, 0xe5, 0xac, 0x85, 0xe6, 0x4a, 0xb7, - 0x25, 0x37, 0x8d, 0x72, 0xb6, 0x12, 0x01, 0xf4, 0xd5, 0x4d, 0x89, 0xd3, 0xe5, 0xb2, 0x95, 0x84, 0x7d, 0xfb, 0xae, - 0x9d, 0x2a, 0xf2, 0xf8, 0x28, 0x0d, 0x79, 0x05, 0x7e, 0xca, 0x38, 0x92, 0x44, 0x89, 0xe0, 0x6d, 0xde, 0x98, 0x71, - 0x78, 0xd5, 0xa6, 0x9c, 0xda, 0x9b, 0xf5, 0x02, 0x70, 0x9e, 0xa0, 0x2d, 0x03, 0x8c, 0x05, 0x0c, 0xce, 0x85, 0x58, - 0xf2, 0x14, 0xc1, 0x2f, 0x9d, 0x48, 0x61, 0xdc, 0xe5, 0x30, 0xcc, 0x83, 0xa2, 0x77, 0x49, 0xfd, 0xd1, 0xef, 0xa3, - 0x36, 0x19, 0x0c, 0x41, 0x25, 0x80, 0xca, 0xba, 0x41, 0x62, 0x60, 0x55, 0x5a, 0x48, 0x5c, 0x42, 0xbc, 0xcc, 0x57, - 0xd3, 0x34, 0x0a, 0x1e, 0xd5, 0x13, 0x42, 0x38, 0xc1, 0xf8, 0x10, 0x37, 0x40, 0xc0, 0x60, 0x15, 0x17, 0x18, 0x24, - 0xcf, 0x25, 0xba, 0x3f, 0x9e, 0xef, 0x18, 0xe0, 0xca, 0x79, 0x4f, 0xb5, 0xab, 0x07, 0xf6, 0x72, 0x95, 0x2e, 0x19, - 0x21, 0xac, 0xf8, 0xbf, 0x88, 0xbc, 0x6f, 0x87, 0x09, 0xa8, 0x6d, 0xe4, 0x8f, 0x41, 0x62, 0x2e, 0x13, 0x45, 0x10, - 0x8f, 0xb2, 0x82, 0x25, 0x69, 0xb0, 0x19, 0x25, 0x29, 0x68, 0x34, 0x31, 0x86, 0x4c, 0x85, 0x76, 0x48, 0x1a, 0xcd, - 0xc6, 0x64, 0x1f, 0x43, 0x5e, 0xc3, 0xc5, 0x62, 0x81, 0xf7, 0xbd, 0x16, 0xaa, 0x83, 0x6d, 0x69, 0x0e, 0x01, 0x27, - 0x09, 0xf6, 0xd4, 0x15, 0x29, 0x09, 0xb3, 0xd1, 0xa7, 0x90, 0x73, 0x03, 0x3a, 0x4e, 0x1a, 0x43, 0xf5, 0x81, 0x49, - 0x78, 0x15, 0xa1, 0x93, 0xb2, 0x42, 0x58, 0xc0, 0x7d, 0x23, 0xa3, 0xd1, 0x4a, 0x1a, 0x04, 0xde, 0x66, 0xd8, 0x0a, - 0x6c, 0x42, 0xc3, 0x5f, 0x65, 0x1e, 0xa6, 0xd5, 0xac, 0x04, 0x73, 0xbe, 0x81, 0x4a, 0x8c, 0x27, 0xcb, 0x2b, 0xbe, - 0x71, 0xb1, 0x12, 0x93, 0xd9, 0x72, 0x3e, 0x59, 0x4b, 0xaa, 0xb9, 0xdc, 0x5b, 0xb3, 0x8c, 0x2d, 0x61, 0xff, 0x30, - 0xc8, 0x8f, 0x0e, 0xec, 0x68, 0xaa, 0x69, 0x93, 0x00, 0x93, 0xe9, 0x9c, 0xf3, 0xe1, 0x25, 0xa2, 0xc9, 0xea, 0xd4, - 0x9d, 0x4c, 0x55, 0x3b, 0xb8, 0x26, 0x67, 0x72, 0x7a, 0xa4, 0x9e, 0x6a, 0xdd, 0x4b, 0x3e, 0xda, 0x0e, 0xab, 0xd1, - 0xd6, 0x0f, 0xc0, 0xad, 0x53, 0xd8, 0xe9, 0xbb, 0x61, 0x35, 0xda, 0xf9, 0x1a, 0x76, 0x97, 0x14, 0x02, 0xd5, 0x97, - 0xb2, 0x26, 0x73, 0xf1, 0xba, 0xb8, 0xf7, 0x0a, 0xf6, 0xc4, 0x1f, 0xe8, 0x5f, 0x25, 0x7b, 0xe2, 0xdb, 0x4c, 0xae, - 0xbf, 0xa5, 0x5d, 0xa3, 0x31, 0xd3, 0xf1, 0xda, 0x15, 0x58, 0xa1, 0x01, 0xf2, 0x0b, 0x76, 0xb4, 0x57, 0x39, 0x08, - 0x04, 0xe8, 0x5e, 0x82, 0xa3, 0x28, 0x20, 0x6a, 0x5a, 0x55, 0x1e, 0x9d, 0xee, 0xfd, 0x3d, 0xbe, 0x11, 0x02, 0x36, - 0x79, 0x6a, 0xdd, 0x5b, 0xc6, 0xfe, 0xe1, 0x00, 0x21, 0xf4, 0x72, 0xfa, 0x8d, 0xb6, 0xac, 0x1e, 0xed, 0x58, 0xee, - 0x1b, 0x46, 0x3d, 0x05, 0x63, 0x18, 0xba, 0xb0, 0x8a, 0x91, 0x3c, 0x03, 0xb2, 0xc6, 0x6f, 0x10, 0x5d, 0xc0, 0xa2, - 0xd7, 0xfb, 0x74, 0x44, 0x83, 0x08, 0xa8, 0xf4, 0x9a, 0xa3, 0x16, 0xf9, 0x5c, 0x15, 0xa2, 0xf7, 0xde, 0xda, 0x79, - 0x33, 0x23, 0x59, 0x26, 0x8d, 0x54, 0xbb, 0x95, 0xc5, 0xba, 0xf2, 0x66, 0x27, 0xa4, 0x8b, 0x39, 0x86, 0xca, 0xe0, - 0x71, 0x00, 0x4a, 0xcf, 0x7f, 0x87, 0x5e, 0xc9, 0x90, 0x69, 0x96, 0x68, 0x66, 0x77, 0x8d, 0x3f, 0x59, 0xa5, 0x5e, - 0x8c, 0x88, 0xd9, 0xc0, 0x16, 0xe2, 0xb6, 0xa8, 0x74, 0x5b, 0x14, 0xca, 0x16, 0x45, 0xfa, 0x50, 0x3b, 0xd3, 0x9d, - 0x59, 0xf8, 0xac, 0xb2, 0x56, 0x4a, 0x66, 0xc6, 0x06, 0x68, 0xbb, 0x08, 0xdf, 0x40, 0x07, 0x2a, 0x84, 0xfc, 0x05, - 0x22, 0x22, 0x11, 0xb0, 0xcb, 0xa9, 0x3b, 0xb1, 0xe9, 0x90, 0xcc, 0x43, 0xcc, 0x0a, 0x35, 0xca, 0x4b, 0x9e, 0x1c, - 0x0d, 0x48, 0x45, 0xa8, 0xdb, 0xfd, 0xfe, 0xf9, 0xd2, 0x05, 0xb5, 0x5f, 0x53, 0xec, 0x18, 0xdd, 0x14, 0x70, 0x2e, - 0x78, 0x94, 0xf7, 0xdc, 0x3b, 0x07, 0x34, 0xc7, 0xf6, 0x14, 0x59, 0x03, 0x4e, 0x6f, 0xbb, 0x10, 0x60, 0xfb, 0xac, - 0xd9, 0xda, 0x9f, 0xac, 0xae, 0xa2, 0xa9, 0x57, 0xf2, 0x99, 0xee, 0xa2, 0xc4, 0xed, 0xa2, 0x58, 0x76, 0xd1, 0xa6, - 0x81, 0x60, 0xc7, 0x95, 0x1f, 0x00, 0x6f, 0x68, 0xd4, 0xef, 0x97, 0xad, 0x9e, 0x3d, 0xf9, 0xda, 0x71, 0xcf, 0x66, - 0x3e, 0x2b, 0x4d, 0xcf, 0xfe, 0x23, 0x75, 0x7b, 0x56, 0x4e, 0xf6, 0xa2, 0x73, 0xb2, 0x4f, 0x67, 0xf3, 0x40, 0x70, - 0xb9, 0x73, 0x9f, 0xe7, 0x53, 0x3d, 0xed, 0x2a, 0x3f, 0x68, 0x0d, 0x91, 0x35, 0x76, 0x55, 0xf7, 0xba, 0x82, 0x05, - 0x2c, 0xc1, 0xdd, 0x7a, 0x69, 0xfe, 0x1b, 0x76, 0x7f, 0x2f, 0xe8, 0xa5, 0xf9, 0xef, 0xf4, 0x27, 0x05, 0x70, 0x00, - 0x1a, 0x53, 0xbb, 0x05, 0x1e, 0x62, 0xa8, 0xa0, 0x70, 0x37, 0x2b, 0xe7, 0x5e, 0x0d, 0x70, 0x98, 0xa4, 0x6f, 0x68, - 0xf5, 0x4a, 0x8b, 0x5d, 0x2f, 0x93, 0xbd, 0x02, 0x3c, 0x54, 0x21, 0x0f, 0x0f, 0x87, 0xa8, 0x63, 0xd8, 0x41, 0x1d, - 0x01, 0xc3, 0x1e, 0x42, 0x63, 0x0b, 0x3c, 0x1f, 0x3f, 0x64, 0x7c, 0x2f, 0x40, 0x6d, 0x84, 0xf0, 0x78, 0xb5, 0x28, - 0x43, 0x6c, 0xd9, 0x2b, 0xa4, 0x92, 0x7a, 0x2d, 0x10, 0x65, 0xb4, 0x0a, 0x68, 0xab, 0x3d, 0x66, 0x69, 0xfc, 0x08, - 0xa1, 0x62, 0xa9, 0x8f, 0x21, 0x34, 0x70, 0xf8, 0x1d, 0x0e, 0x20, 0xc1, 0x97, 0x5c, 0x93, 0xcd, 0xbd, 0xca, 0xef, - 0x68, 0x9f, 0x3f, 0x1c, 0xce, 0x2f, 0x11, 0x94, 0x2e, 0x85, 0x8f, 0x54, 0x22, 0xaa, 0xa7, 0xb8, 0x29, 0x21, 0x9b, - 0x25, 0x2b, 0xfd, 0xe0, 0x1f, 0xea, 0x17, 0x00, 0xc8, 0x42, 0xa0, 0x4d, 0x64, 0xf6, 0xa7, 0x33, 0x15, 0x5d, 0x00, - 0x1c, 0xe2, 0x0f, 0x9f, 0x20, 0xfa, 0x86, 0x96, 0x69, 0xf9, 0x38, 0xe1, 0x21, 0x68, 0x6d, 0x49, 0x27, 0x11, 0x2b, - 0x05, 0x36, 0x44, 0xc2, 0xf7, 0xfb, 0xe7, 0xb1, 0xa4, 0x03, 0x8d, 0x5a, 0xdd, 0x1b, 0xb7, 0xba, 0x57, 0xbe, 0xae, - 0x3b, 0xb9, 0xf1, 0x41, 0xd1, 0x3e, 0x9b, 0x37, 0x2a, 0xdf, 0xf7, 0x75, 0xce, 0xee, 0x74, 0xef, 0xc8, 0x39, 0xf1, - 0xfd, 0x3d, 0x84, 0xa2, 0x87, 0xa6, 0xc8, 0xb2, 0x24, 0x0c, 0x68, 0xad, 0x5d, 0x7b, 0x96, 0xd1, 0xc1, 0x6b, 0xdf, - 0x10, 0x22, 0xf2, 0x14, 0x9f, 0x84, 0xdc, 0xe2, 0xf8, 0xa0, 0x40, 0xff, 0xcc, 0xf8, 0x33, 0x27, 0x7e, 0xd8, 0xea, - 0x17, 0xc0, 0xb9, 0xe9, 0xde, 0xbb, 0x13, 0xb3, 0x1e, 0x43, 0x29, 0x1b, 0xff, 0xf7, 0xfb, 0x44, 0x16, 0xe8, 0x74, - 0x44, 0xc3, 0x40, 0x70, 0x17, 0xd5, 0xff, 0xbd, 0xe2, 0x75, 0xcf, 0x5a, 0x9d, 0x2f, 0x3f, 0x75, 0x7a, 0xd2, 0xeb, - 0xa5, 0x5b, 0xe1, 0xcb, 0x30, 0xf1, 0x9d, 0xd7, 0xfd, 0x86, 0xed, 0xbe, 0xfb, 0xe5, 0xdd, 0xd1, 0xcb, 0xc0, 0x26, - 0x85, 0xef, 0x6c, 0x4a, 0x3e, 0xeb, 0x81, 0xc2, 0xaf, 0xc7, 0x7a, 0x75, 0xb1, 0xee, 0xb1, 0x1e, 0x6a, 0x01, 0xd1, - 0xc3, 0x02, 0xd4, 0x7f, 0x3d, 0xfb, 0x34, 0x14, 0x0e, 0xb2, 0x71, 0xaa, 0x40, 0x91, 0x05, 0x7f, 0x2a, 0x46, 0xeb, - 0x82, 0x00, 0x91, 0xcd, 0xf6, 0xf5, 0xa1, 0x3a, 0x99, 0x7d, 0x53, 0x6a, 0x49, 0x06, 0xdf, 0x04, 0x64, 0x76, 0x60, - 0xe5, 0x04, 0xa5, 0xe3, 0xd6, 0x80, 0x2b, 0x5b, 0xec, 0xed, 0xed, 0x4f, 0x83, 0xec, 0xac, 0x39, 0x69, 0xb4, 0x0f, - 0xfb, 0x34, 0x0f, 0x10, 0x88, 0x64, 0x2a, 0x82, 0x5c, 0x73, 0x6f, 0x49, 0x1f, 0x1d, 0xce, 0x79, 0x21, 0xff, 0x9c, - 0x4a, 0x1d, 0xe2, 0x50, 0x62, 0x0d, 0x04, 0x2a, 0xcf, 0x50, 0xe5, 0xb0, 0x41, 0x8e, 0x5f, 0x3a, 0x92, 0x99, 0xc4, - 0x64, 0x91, 0xbb, 0x35, 0x53, 0xe1, 0x07, 0x82, 0x8f, 0x59, 0xce, 0x81, 0x0b, 0x6c, 0x36, 0xf7, 0xd5, 0x14, 0x17, - 0x57, 0xe0, 0x8f, 0x29, 0xfc, 0x8a, 0xa7, 0xb0, 0xd3, 0xee, 0xd7, 0x45, 0x95, 0xa2, 0x6e, 0xa3, 0xb0, 0xa8, 0x64, - 0xc1, 0xb4, 0x86, 0x34, 0xd1, 0x61, 0xf4, 0x27, 0x39, 0x03, 0x05, 0x21, 0xbf, 0x6c, 0x1a, 0x60, 0xa4, 0x92, 0xcb, - 0x83, 0x2a, 0x09, 0xbc, 0x00, 0xdb, 0xa0, 0x62, 0xeb, 0x02, 0x82, 0x6c, 0x93, 0xa2, 0x4c, 0xbf, 0x16, 0x79, 0x1d, - 0x66, 0x41, 0x35, 0x4a, 0xab, 0x9f, 0xf5, 0x4f, 0x60, 0xde, 0xa6, 0x62, 0x54, 0xab, 0x98, 0xfc, 0x46, 0xbf, 0x5f, - 0x0c, 0x5a, 0x1f, 0x32, 0xf8, 0xe8, 0xb5, 0x69, 0xf0, 0x5b, 0xa7, 0xc1, 0x0e, 0x13, 0x8d, 0x00, 0x48, 0xe6, 0xd4, - 0x92, 0x87, 0xa2, 0x3f, 0x83, 0x1c, 0x6b, 0x54, 0x39, 0x05, 0x83, 0xf5, 0x1f, 0x8f, 0x76, 0x60, 0xea, 0xc5, 0xd1, - 0x96, 0xec, 0xa0, 0x95, 0x6f, 0x80, 0xfb, 0x35, 0xb2, 0xc5, 0x2c, 0x07, 0x68, 0xf6, 0x1a, 0x91, 0xf1, 0xc9, 0x0b, - 0x60, 0xcc, 0xd6, 0x59, 0x18, 0x89, 0x38, 0x18, 0xab, 0xc6, 0x8c, 0x19, 0x18, 0xb8, 0x40, 0xd7, 0x32, 0x29, 0x49, - 0x43, 0x3a, 0x18, 0xb0, 0x52, 0xb6, 0x70, 0xc0, 0x8b, 0xe6, 0xb8, 0x1d, 0x5f, 0x5b, 0x34, 0x1e, 0xd8, 0x2e, 0xb6, - 0xbf, 0x7b, 0x5e, 0x6c, 0xdf, 0x84, 0x5b, 0xd2, 0x2b, 0xe4, 0x2c, 0xa1, 0x9f, 0x3f, 0xcb, 0x3e, 0x6b, 0x38, 0x39, - 0x15, 0x9a, 0xa1, 0xa5, 0x48, 0x28, 0xc5, 0x3b, 0x3d, 0x29, 0x30, 0x96, 0xb1, 0xf0, 0xf7, 0xc0, 0x39, 0x5d, 0x28, - 0x22, 0x77, 0xe0, 0x38, 0xfe, 0x08, 0x15, 0x8c, 0x1a, 0x0e, 0x5e, 0xc6, 0xb0, 0x2d, 0x8a, 0x59, 0x48, 0x38, 0x85, - 0x70, 0xb1, 0xca, 0xfa, 0x7d, 0xf9, 0x8b, 0xba, 0xe8, 0x22, 0x93, 0x75, 0x9f, 0x84, 0x23, 0x33, 0x96, 0x53, 0x2f, - 0x24, 0xcf, 0x7b, 0x9e, 0x4c, 0x93, 0xc7, 0x79, 0x10, 0x01, 0xe4, 0x73, 0x78, 0x17, 0xa6, 0x19, 0x58, 0xa5, 0x49, - 0xf9, 0x11, 0x4a, 0x5f, 0x7c, 0x5e, 0xf9, 0x81, 0xce, 0x9e, 0x9b, 0x64, 0x78, 0xb3, 0x6a, 0xbd, 0x49, 0xad, 0xeb, - 0xe2, 0x01, 0xff, 0xec, 0x0c, 0x36, 0xce, 0x75, 0x26, 0x38, 0xf0, 0x22, 0xa9, 0xf5, 0x9a, 0xf1, 0xa7, 0x19, 0xae, - 0x4b, 0xd5, 0x46, 0x1f, 0x85, 0xe8, 0x1c, 0x32, 0x15, 0xa0, 0x50, 0xa4, 0xfd, 0x83, 0x52, 0x2b, 0x93, 0x4a, 0x1b, - 0x09, 0xa0, 0x7b, 0x98, 0x34, 0xd8, 0x62, 0x28, 0x63, 0x69, 0x12, 0xe5, 0x4e, 0x83, 0xb8, 0xb2, 0x1f, 0x2a, 0x89, - 0x43, 0xcb, 0x22, 0xf9, 0xf7, 0xae, 0xa7, 0xaf, 0x90, 0xba, 0x93, 0x05, 0x32, 0x63, 0x3c, 0xcb, 0xe3, 0x4f, 0x40, - 0x98, 0x0d, 0xda, 0xa8, 0x28, 0x84, 0x90, 0x0d, 0x62, 0xd0, 0x78, 0x96, 0xc7, 0xcf, 0x15, 0x8d, 0x87, 0x7c, 0x14, - 0xf9, 0xea, 0xaf, 0x52, 0xff, 0x15, 0xfa, 0xcc, 0x04, 0x8f, 0x50, 0x4d, 0xf4, 0xef, 0x9e, 0xcf, 0xee, 0x40, 0x6d, - 0x18, 0x85, 0x99, 0x29, 0xbf, 0xf2, 0x4d, 0x71, 0xf6, 0xfa, 0x2b, 0xba, 0xca, 0xb6, 0xee, 0x47, 0x2f, 0x8f, 0x08, - 0xac, 0x8d, 0xd1, 0x15, 0x37, 0x06, 0x90, 0xc3, 0xe4, 0xfd, 0x8a, 0xd2, 0x72, 0x48, 0x83, 0xd0, 0x41, 0x43, 0x18, - 0x2d, 0x89, 0x3e, 0x90, 0x58, 0xc4, 0x18, 0x5e, 0x88, 0x67, 0xa4, 0x26, 0x13, 0x0d, 0xf1, 0x8a, 0xd8, 0x0f, 0xd1, - 0x92, 0x53, 0x13, 0xdd, 0x08, 0x53, 0x0c, 0x24, 0x76, 0x06, 0xc9, 0x49, 0x52, 0x2b, 0xbf, 0x78, 0x26, 0x09, 0x4b, - 0xec, 0x3c, 0xc4, 0x60, 0x52, 0x4b, 0x77, 0x7a, 0x53, 0xa5, 0xe7, 0x47, 0x5a, 0x0e, 0xda, 0x07, 0x60, 0x97, 0x92, - 0xde, 0x3f, 0x29, 0x14, 0xf1, 0x3e, 0x8c, 0x63, 0x08, 0xdf, 0x22, 0xaa, 0x2b, 0x70, 0xae, 0x15, 0x68, 0xac, 0x06, - 0x1e, 0x9a, 0x59, 0x35, 0x1f, 0x72, 0xfa, 0xa9, 0xb4, 0xfc, 0x31, 0xa2, 0xb1, 0xd1, 0xba, 0x39, 0x1c, 0xf6, 0xb4, - 0xea, 0xa5, 0x73, 0xd0, 0x65, 0x33, 0x89, 0x89, 0x1b, 0x48, 0xd7, 0x8f, 0x7e, 0x33, 0x61, 0x2f, 0xa2, 0x42, 0x2e, - 0x85, 0xa0, 0xa0, 0xd5, 0x81, 0xc0, 0xa1, 0xf0, 0x16, 0x65, 0xbe, 0x88, 0x69, 0x03, 0x61, 0xf0, 0xf9, 0x81, 0xfc, - 0x7c, 0x53, 0x90, 0x8a, 0x1d, 0xeb, 0xda, 0xef, 0x2f, 0x4b, 0x0f, 0xf0, 0xe4, 0x4c, 0x92, 0xa7, 0xcd, 0x10, 0x56, - 0x04, 0xd0, 0x98, 0xd5, 0x64, 0x71, 0xc2, 0x95, 0x39, 0x7c, 0x59, 0x79, 0x25, 0x4b, 0x99, 0x3a, 0x4f, 0xf5, 0x02, - 0x88, 0x3a, 0xde, 0xa0, 0x15, 0xa9, 0x5f, 0xa1, 0xb3, 0xd7, 0xac, 0x84, 0x8c, 0x87, 0xe7, 0x9c, 0xa7, 0xa3, 0x7b, - 0x96, 0xf0, 0x08, 0xff, 0x4a, 0x26, 0xfa, 0xf0, 0xbb, 0xe7, 0x70, 0x33, 0x4e, 0x78, 0xe4, 0x36, 0x7b, 0x5f, 0x85, - 0x2b, 0xb8, 0x99, 0x16, 0x80, 0xe4, 0x16, 0x24, 0x4d, 0x40, 0x09, 0x89, 0x4c, 0xc8, 0xac, 0x29, 0xf9, 0x6b, 0x4b, - 0xdb, 0x60, 0x0d, 0x93, 0xce, 0x03, 0x5e, 0xb4, 0xfa, 0x68, 0x35, 0xd1, 0x2e, 0xb3, 0x7c, 0x3e, 0xc4, 0x19, 0xaa, - 0x39, 0xee, 0xce, 0xe0, 0xe7, 0x80, 0x57, 0xac, 0x6a, 0xd2, 0xd1, 0x6e, 0xc0, 0x85, 0x27, 0xd7, 0x79, 0x3a, 0xda, - 0xe2, 0x2f, 0xb9, 0x3f, 0x00, 0x74, 0x30, 0x75, 0x09, 0xfc, 0xa9, 0xda, 0x6a, 0x2a, 0xf5, 0x73, 0x6b, 0xbf, 0xae, - 0x3b, 0xab, 0x95, 0x7b, 0xd6, 0x65, 0x68, 0x8f, 0x0c, 0x39, 0x63, 0x06, 0xfc, 0x39, 0x63, 0xc9, 0x9f, 0x33, 0x56, - 0xfc, 0x39, 0xe3, 0xc6, 0xc8, 0x00, 0x4a, 0x70, 0x2f, 0xf9, 0xd3, 0x3d, 0x62, 0x86, 0x58, 0x0d, 0x2a, 0x81, 0x95, - 0xa5, 0x9c, 0xfb, 0xc8, 0x29, 0xa6, 0x9c, 0x32, 0xbc, 0x74, 0x3a, 0x73, 0x07, 0x72, 0x1e, 0xcc, 0xdc, 0x61, 0xb2, - 0xd7, 0xe7, 0x46, 0x1c, 0x4b, 0x63, 0x52, 0x54, 0x90, 0xce, 0xe9, 0x70, 0xf3, 0xea, 0x38, 0x4f, 0x58, 0xc6, 0xc7, - 0xed, 0x33, 0x05, 0x42, 0x6c, 0xf1, 0x0c, 0x89, 0x94, 0xaa, 0x59, 0x6e, 0xf3, 0x87, 0x43, 0x3d, 0xba, 0xd7, 0x3b, - 0x3d, 0xfc, 0x4a, 0xd8, 0xcf, 0x99, 0x67, 0x9f, 0x20, 0x80, 0x49, 0x22, 0xcf, 0x24, 0x1c, 0xfd, 0x58, 0x8e, 0xfe, - 0xa6, 0xe1, 0xcf, 0x33, 0x54, 0x77, 0x87, 0xc0, 0xc4, 0x96, 0x1d, 0x38, 0x04, 0xa7, 0xab, 0x4a, 0x24, 0xe0, 0x60, - 0xb3, 0x61, 0x91, 0xde, 0xe3, 0x21, 0xce, 0x07, 0x85, 0x8f, 0xd0, 0x30, 0xa3, 0xf7, 0xfb, 0x1b, 0xe1, 0x55, 0xb2, - 0x95, 0x87, 0x43, 0x62, 0x69, 0x80, 0x1c, 0x7d, 0x1c, 0xed, 0x51, 0x42, 0xed, 0x47, 0xb5, 0xde, 0x54, 0xea, 0x41, - 0x6e, 0x76, 0x21, 0x31, 0xa8, 0x58, 0xaa, 0x4f, 0xaf, 0x54, 0x1f, 0x6a, 0x96, 0x1c, 0x52, 0x1d, 0xf7, 0xa9, 0x18, - 0xad, 0xe5, 0x84, 0x00, 0xd7, 0x41, 0xa2, 0xd1, 0x01, 0x30, 0xce, 0x36, 0x5b, 0x5e, 0x6a, 0xeb, 0x44, 0xe9, 0x38, - 0xce, 0xf5, 0x71, 0x7c, 0x38, 0x48, 0x31, 0xe3, 0xf2, 0x48, 0xcc, 0xb8, 0x6c, 0x00, 0xde, 0xac, 0xf3, 0xa0, 0x3e, - 0x1c, 0x2e, 0xe9, 0x52, 0x64, 0x3a, 0xdb, 0x28, 0x3f, 0xeb, 0xd1, 0xfd, 0xe3, 0x04, 0xcd, 0xbd, 0x15, 0xf6, 0x5e, - 0x24, 0xdb, 0x33, 0x59, 0xa7, 0x5e, 0x46, 0x3e, 0xbd, 0x70, 0xcf, 0x2e, 0xb9, 0xfa, 0x61, 0xf5, 0xf5, 0xf4, 0x37, - 0xe1, 0x45, 0xac, 0xa2, 0xdd, 0xba, 0x64, 0xc2, 0xde, 0x52, 0x2a, 0x69, 0x95, 0x97, 0x4f, 0x37, 0x7e, 0x80, 0x99, - 0x69, 0x4f, 0x1f, 0x64, 0x23, 0xaa, 0x3f, 0x2b, 0x51, 0x2b, 0xc3, 0x64, 0xe1, 0xbc, 0x64, 0xea, 0xc9, 0x80, 0xc7, - 0xac, 0xe4, 0x91, 0xec, 0xf4, 0xc6, 0x20, 0x08, 0x60, 0x9d, 0x93, 0x56, 0x9d, 0x71, 0x34, 0x5a, 0x55, 0x2e, 0x4e, - 0x57, 0xb9, 0xc0, 0x70, 0xbb, 0x35, 0xdb, 0xa8, 0x3a, 0xcb, 0x4d, 0xad, 0x52, 0xbe, 0x03, 0xf8, 0x58, 0x56, 0xb9, - 0xa0, 0x63, 0xca, 0xd4, 0x79, 0x03, 0xc1, 0xd8, 0xaa, 0xc6, 0x85, 0x53, 0xe3, 0x82, 0x47, 0xd4, 0xee, 0xa6, 0xa9, - 0x47, 0x5b, 0x60, 0x29, 0x1d, 0xed, 0x78, 0x89, 0x2a, 0x85, 0x7f, 0x08, 0xbe, 0x0f, 0xe3, 0xf8, 0x79, 0xb1, 0x55, - 0x07, 0xe2, 0x4d, 0xb1, 0x45, 0xda, 0x17, 0xf9, 0x17, 0xe2, 0x80, 0xd7, 0xba, 0xa6, 0xbc, 0xb6, 0xe6, 0x34, 0xb0, - 0x35, 0x8c, 0x94, 0x14, 0xce, 0xcd, 0x9f, 0x87, 0x03, 0xad, 0xec, 0x5a, 0xdd, 0x15, 0x6a, 0x3d, 0xe6, 0xb0, 0x61, - 0x2f, 0xb2, 0x70, 0x27, 0x4a, 0x70, 0xe4, 0x92, 0x7f, 0x1d, 0x0e, 0x5a, 0x65, 0xa9, 0x8e, 0xf4, 0xd9, 0xfe, 0x6b, - 0x30, 0x66, 0xe8, 0xd2, 0x04, 0x2c, 0x1b, 0x23, 0xf9, 0x57, 0xd3, 0xcc, 0x1b, 0x26, 0x6b, 0xa6, 0x70, 0x1c, 0x1a, - 0x46, 0x48, 0x03, 0xba, 0x0d, 0x6a, 0xc3, 0x93, 0xf9, 0xa6, 0x2a, 0xbf, 0xba, 0x23, 0xd5, 0x7e, 0x30, 0xbc, 0x9c, - 0x88, 0x73, 0xba, 0x24, 0xa9, 0xa7, 0x12, 0x4a, 0x42, 0xb0, 0x4b, 0x1f, 0xc8, 0x89, 0x15, 0x90, 0xb5, 0x8c, 0xe5, - 0xb7, 0x7a, 0x40, 0xe8, 0x3f, 0xed, 0xd6, 0x0b, 0xfd, 0xa7, 0x69, 0xb6, 0x50, 0xd7, 0x1f, 0x26, 0xf7, 0x1d, 0xbd, - 0xfe, 0xe0, 0xf0, 0x4e, 0x5d, 0x55, 0x5c, 0xc5, 0xa3, 0xda, 0x30, 0xc9, 0x8d, 0xb2, 0x70, 0x57, 0x6c, 0x6a, 0xb5, - 0x3c, 0x1d, 0x87, 0x11, 0x98, 0x11, 0x14, 0x20, 0xeb, 0xba, 0x8d, 0x88, 0x61, 0x25, 0x97, 0x09, 0xf9, 0x84, 0x80, - 0x2c, 0x4a, 0x8d, 0xf3, 0x71, 0x0b, 0x54, 0x22, 0x18, 0x9c, 0x86, 0xd6, 0xaa, 0x9b, 0xfc, 0xac, 0xb2, 0xb1, 0x5b, - 0x20, 0x87, 0x24, 0x93, 0xc5, 0xed, 0xe8, 0x46, 0x2c, 0x8b, 0x52, 0xbc, 0xc6, 0x7a, 0xb8, 0x66, 0x0b, 0xf7, 0x19, - 0x10, 0xda, 0x4f, 0x94, 0xf6, 0x26, 0xd2, 0x04, 0xdd, 0xb7, 0x6c, 0x05, 0x20, 0x03, 0x28, 0xea, 0x6a, 0xb7, 0x3e, - 0xe7, 0xe7, 0x48, 0x9a, 0xe1, 0x30, 0xba, 0x7d, 0x7a, 0x1b, 0xdc, 0x0e, 0x2e, 0x51, 0x2b, 0x7d, 0xc9, 0xe2, 0x16, - 0x06, 0xd5, 0xde, 0x2c, 0xe1, 0xa0, 0x66, 0xd6, 0xda, 0x08, 0x04, 0x93, 0x3d, 0x14, 0x54, 0xcc, 0x15, 0xec, 0x83, - 0x82, 0xb5, 0xe4, 0x75, 0x70, 0xb8, 0xb5, 0x2f, 0x2b, 0xc5, 0xc5, 0x93, 0x8b, 0xa4, 0x75, 0x61, 0x29, 0x2f, 0x9e, - 0x34, 0x60, 0x70, 0x39, 0xc2, 0xa6, 0x02, 0x93, 0x04, 0x80, 0x6e, 0x45, 0x14, 0xf1, 0xa2, 0x14, 0xb6, 0xad, 0x7c, - 0xe6, 0x84, 0x0d, 0x36, 0xec, 0x1e, 0xee, 0x95, 0x41, 0xc9, 0xe0, 0x42, 0x8c, 0xdb, 0xcd, 0x2e, 0xc0, 0x15, 0x0c, - 0x85, 0xb1, 0x35, 0xff, 0x9a, 0x79, 0x91, 0x12, 0x70, 0x33, 0x44, 0xf9, 0xda, 0xc0, 0xc9, 0xa4, 0x27, 0xd7, 0x92, - 0xc5, 0x80, 0x05, 0x0d, 0xbe, 0xa3, 0xd6, 0xdf, 0x99, 0xfc, 0x1b, 0x4f, 0x0f, 0xfd, 0xe0, 0xd7, 0xcc, 0x5b, 0xfa, - 0xec, 0x6d, 0x25, 0xa3, 0x35, 0x49, 0x94, 0x57, 0x0f, 0x97, 0x20, 0x37, 0x2c, 0x47, 0xf7, 0x6c, 0x09, 0xe2, 0xc4, - 0x72, 0x94, 0x50, 0x46, 0x57, 0xb8, 0x57, 0x99, 0x2d, 0x13, 0x81, 0x14, 0x07, 0x96, 0x52, 0xee, 0x2d, 0xd6, 0xc1, - 0x12, 0xf7, 0x27, 0x92, 0x0b, 0x28, 0x79, 0x00, 0xe5, 0x4a, 0x01, 0x01, 0x9f, 0x0e, 0xa0, 0x7c, 0x29, 0x2f, 0xc2, - 0x9f, 0x38, 0x51, 0x83, 0xe5, 0xe8, 0xbe, 0x61, 0x3f, 0x7b, 0xa1, 0x65, 0x7f, 0xb8, 0xd5, 0x9a, 0x86, 0x15, 0xbf, - 0x85, 0x69, 0x31, 0x71, 0xfb, 0x72, 0x65, 0x57, 0xc5, 0x67, 0x2b, 0x75, 0x76, 0x53, 0x43, 0x12, 0xf6, 0x0d, 0x59, - 0x05, 0x38, 0x58, 0x15, 0x71, 0xcf, 0xba, 0xdc, 0x87, 0xd1, 0x97, 0x4d, 0x5a, 0x0a, 0x0b, 0x55, 0xd2, 0xdf, 0x37, - 0xa5, 0x40, 0x2a, 0x13, 0x9d, 0x68, 0x21, 0xb8, 0x02, 0x83, 0xc0, 0x9d, 0xc8, 0x6b, 0x00, 0x8c, 0x01, 0x97, 0x02, - 0x65, 0xd9, 0x96, 0x10, 0x52, 0xdd, 0xcf, 0x40, 0x6d, 0x27, 0xee, 0xd2, 0x88, 0xac, 0x85, 0xe8, 0xab, 0x60, 0xcc, - 0x9c, 0x97, 0xd2, 0x2d, 0x36, 0x5d, 0x6d, 0x56, 0x1f, 0xd1, 0xb9, 0xb4, 0xe5, 0xe6, 0x27, 0x6c, 0xb1, 0x56, 0xa0, - 0x6c, 0x42, 0xd2, 0x76, 0xce, 0x73, 0x94, 0x4d, 0x68, 0x69, 0xef, 0xa9, 0x47, 0x85, 0xea, 0x64, 0xeb, 0xa5, 0x6a, - 0x6a, 0x11, 0x56, 0x8b, 0x8b, 0xca, 0x0f, 0x40, 0x37, 0x95, 0x56, 0xcf, 0xea, 0x1a, 0x4d, 0xa1, 0x56, 0x0b, 0xc7, - 0x8d, 0x76, 0x36, 0x5d, 0xa6, 0xb7, 0x88, 0xb3, 0x2a, 0xed, 0xd0, 0xbf, 0x64, 0xda, 0xf5, 0xb2, 0xa3, 0xdf, 0x8c, - 0xab, 0x0b, 0x5c, 0x88, 0x0d, 0xf8, 0x9c, 0xfb, 0xcb, 0xeb, 0x3d, 0x89, 0x7b, 0xfe, 0xe1, 0x80, 0xec, 0x49, 0xed, - 0x0f, 0xd5, 0xc7, 0xae, 0x60, 0xc8, 0xc2, 0x28, 0xf5, 0x17, 0x29, 0xef, 0x3d, 0xc2, 0x71, 0xff, 0x5c, 0xf5, 0xd8, - 0xbf, 0x32, 0xbe, 0xaf, 0x8b, 0x4d, 0x94, 0x50, 0x54, 0x43, 0x6f, 0x55, 0x6c, 0x2a, 0x11, 0x17, 0xf7, 0x79, 0x8f, - 0x61, 0x32, 0x8c, 0x85, 0x4c, 0x85, 0x3f, 0x65, 0x2a, 0x78, 0x84, 0x50, 0xe2, 0x66, 0xdd, 0x23, 0xed, 0x26, 0xc4, - 0x29, 0xd5, 0xa2, 0x94, 0xc9, 0xf8, 0xb7, 0x7e, 0x02, 0xe5, 0x39, 0x45, 0xcb, 0xf4, 0xa3, 0xc2, 0x65, 0xfa, 0x66, - 0x7d, 0x5c, 0x7a, 0x26, 0x42, 0x9d, 0xb9, 0xd8, 0xd4, 0x3a, 0x1d, 0x63, 0xa7, 0x74, 0x6a, 0xc3, 0xbe, 0x56, 0x8a, - 0xcb, 0x8a, 0xc2, 0xbf, 0x91, 0xc8, 0xaa, 0x67, 0xc4, 0xf1, 0xdf, 0xb3, 0xf6, 0x19, 0x56, 0x81, 0x5f, 0x06, 0xf2, - 0x7e, 0x01, 0xf0, 0x71, 0x5d, 0x97, 0xe9, 0xcd, 0x06, 0x68, 0x43, 0x68, 0xf8, 0x7b, 0x3e, 0x32, 0x60, 0xba, 0x8f, - 0x70, 0x86, 0xf4, 0x50, 0xe7, 0x9c, 0xce, 0xca, 0x74, 0xce, 0x55, 0x58, 0x4b, 0xb0, 0x97, 0x93, 0x26, 0x97, 0xeb, - 0x12, 0xd4, 0x4c, 0xe0, 0xf6, 0xa1, 0x3d, 0x22, 0x84, 0xda, 0x94, 0xd5, 0xf4, 0x12, 0x6a, 0xde, 0xc9, 0x69, 0x47, - 0x93, 0x12, 0x5c, 0x35, 0x74, 0x56, 0xae, 0xff, 0x3a, 0x1c, 0x7a, 0x37, 0x59, 0x11, 0xfd, 0xd9, 0x43, 0x7f, 0xc7, - 0xed, 0xc7, 0xf4, 0x2b, 0x44, 0xcb, 0x58, 0x7f, 0x43, 0x06, 0x74, 0x3c, 0x19, 0xde, 0x14, 0xdb, 0x1e, 0xfb, 0x8a, - 0x1a, 0x2c, 0x7d, 0xfd, 0xf8, 0x08, 0x12, 0xaa, 0xae, 0x7d, 0x61, 0xf1, 0x84, 0x79, 0x4a, 0xb4, 0x2d, 0x7c, 0x08, - 0x0b, 0xfd, 0x0a, 0x91, 0x91, 0x10, 0x6e, 0x2a, 0xbb, 0x47, 0x49, 0xbb, 0xd0, 0x97, 0xbe, 0x96, 0x7d, 0xe5, 0x3b, - 0x17, 0x00, 0x2b, 0xfb, 0xc4, 0x86, 0x7b, 0xd2, 0x9f, 0x52, 0x7d, 0xd8, 0xfe, 0x96, 0x2c, 0xa0, 0xd0, 0xc2, 0x7a, - 0x2a, 0x67, 0xe7, 0x6d, 0xc9, 0xab, 0x6c, 0xba, 0x5f, 0xc3, 0x1e, 0x75, 0x87, 0x5e, 0x53, 0xc1, 0xf9, 0xa5, 0x19, - 0xbd, 0x2f, 0x86, 0x42, 0x75, 0xd4, 0xb9, 0x83, 0xdc, 0x96, 0xd6, 0x25, 0xe7, 0x37, 0x2b, 0x77, 0x14, 0xe6, 0x77, - 0x21, 0x78, 0x86, 0x75, 0xef, 0x2e, 0xce, 0x7b, 0xff, 0x68, 0xcd, 0x91, 0x7f, 0x65, 0xb3, 0x14, 0xb1, 0x48, 0xe6, - 0x60, 0xf5, 0x43, 0x3f, 0x8f, 0xfd, 0x36, 0xc8, 0xe1, 0xb8, 0x69, 0x40, 0x87, 0x0d, 0x99, 0xb5, 0x2f, 0x11, 0x38, - 0xd5, 0x08, 0xd2, 0xd4, 0x04, 0x35, 0xcb, 0x43, 0x24, 0xb6, 0x4b, 0xd9, 0x36, 0xc8, 0x75, 0x17, 0x4c, 0x73, 0xa4, - 0x3d, 0x83, 0xf7, 0x4d, 0x9a, 0xa4, 0x42, 0xb3, 0x68, 0x74, 0x25, 0xe3, 0xdf, 0x91, 0x36, 0x53, 0xb2, 0xc7, 0xd6, - 0xc0, 0x7b, 0x09, 0xca, 0xc9, 0x30, 0xc5, 0xf0, 0x1d, 0x5f, 0xef, 0x3c, 0xba, 0x88, 0xbf, 0x1d, 0xb3, 0x4d, 0xca, - 0x8e, 0x60, 0x92, 0x6c, 0x7c, 0x43, 0xf1, 0x86, 0xef, 0x6e, 0x2a, 0x51, 0x02, 0xe8, 0x65, 0xc1, 0x9f, 0x4a, 0x9b, - 0x2b, 0x74, 0xbb, 0x7b, 0x47, 0x29, 0xfc, 0x92, 0x97, 0x87, 0xc3, 0x36, 0xf5, 0x42, 0xe8, 0x7c, 0x11, 0xbf, 0x05, - 0x73, 0x18, 0x43, 0x6c, 0x46, 0x80, 0x30, 0xc7, 0x07, 0xd4, 0xc1, 0xfa, 0x11, 0x80, 0xc6, 0x09, 0x14, 0x60, 0xf4, - 0xd5, 0xb6, 0xa0, 0x6f, 0x79, 0x71, 0x11, 0x21, 0x6a, 0x14, 0x60, 0xa2, 0xa4, 0x59, 0x0c, 0xc3, 0x81, 0xce, 0xef, - 0x9b, 0x9b, 0xba, 0x14, 0x38, 0xf4, 0x8e, 0x65, 0xf8, 0x9f, 0xff, 0x63, 0x6d, 0x69, 0x55, 0xd9, 0x6e, 0x8d, 0xd3, - 0xcc, 0xff, 0x76, 0x5b, 0xa4, 0x5b, 0xa8, 0x50, 0x3c, 0xef, 0x78, 0xdd, 0xfe, 0x0c, 0xd1, 0xfb, 0xba, 0x95, 0xab, - 0x52, 0xbb, 0x61, 0xa6, 0xfc, 0x3e, 0xcd, 0xe3, 0xe2, 0x7e, 0x14, 0xb7, 0x8e, 0xbc, 0x49, 0x7a, 0xce, 0xf9, 0xe7, - 0xaa, 0xdf, 0xf7, 0x3e, 0x03, 0x19, 0xef, 0xb5, 0x30, 0x8e, 0x98, 0xc4, 0xc1, 0xb7, 0x17, 0xa3, 0x68, 0x53, 0xc2, - 0x86, 0xdc, 0x3e, 0x2d, 0x41, 0x33, 0xd3, 0xef, 0xa3, 0x44, 0x69, 0xcd, 0xf7, 0x7f, 0xcb, 0xf9, 0x7e, 0x2d, 0xe4, - 0xcd, 0x4a, 0x7e, 0xf8, 0x68, 0x85, 0x81, 0xef, 0x71, 0xfa, 0x55, 0xf4, 0xd8, 0xaa, 0xf4, 0xe1, 0xbb, 0xd2, 0xd2, - 0x67, 0x15, 0xf5, 0x77, 0x54, 0xd4, 0x5c, 0x8b, 0x11, 0x11, 0x0f, 0x82, 0x76, 0xb6, 0x5d, 0x6a, 0xd7, 0x12, 0xb4, - 0x0b, 0x36, 0x85, 0xd5, 0xc9, 0x43, 0x43, 0xde, 0xef, 0xbf, 0xcc, 0xbd, 0x16, 0xaf, 0xbb, 0x81, 0xbb, 0x2c, 0x3d, - 0x84, 0x00, 0xd6, 0x32, 0x50, 0xc6, 0x11, 0x26, 0x5d, 0xe4, 0x35, 0xca, 0xa6, 0x13, 0x81, 0x8f, 0x59, 0x76, 0xe5, - 0x24, 0xd3, 0x00, 0x33, 0xaa, 0x29, 0xcc, 0x04, 0x18, 0xa9, 0x0f, 0x58, 0x37, 0x3d, 0xad, 0x42, 0xcb, 0xd7, 0x10, - 0xac, 0x8b, 0x2c, 0xe3, 0x28, 0x66, 0x02, 0x80, 0xcd, 0x07, 0x90, 0xaf, 0xe8, 0xea, 0x90, 0xb4, 0x52, 0xe5, 0xfd, - 0x3a, 0x23, 0x32, 0x9a, 0x84, 0x68, 0x7e, 0x0b, 0x0f, 0xec, 0xdb, 0x66, 0x46, 0x95, 0x7a, 0x46, 0x55, 0x3e, 0xc3, - 0x61, 0x29, 0x1c, 0x23, 0xfe, 0xdf, 0x52, 0xd5, 0x23, 0x02, 0xbd, 0x2a, 0xd3, 0x2a, 0x2a, 0xf2, 0x5c, 0x44, 0x88, - 0x50, 0x2d, 0x9d, 0xc3, 0xa1, 0x1f, 0xfb, 0x7d, 0x1c, 0x08, 0xf3, 0xa2, 0x78, 0xa8, 0x2b, 0x6b, 0x5a, 0x2b, 0x29, - 0x70, 0x2a, 0x6a, 0x84, 0x08, 0xe1, 0xfd, 0x03, 0x78, 0x56, 0x53, 0xdf, 0x6f, 0x2c, 0x13, 0xdd, 0x97, 0x0c, 0x28, - 0x7f, 0x40, 0xbe, 0xae, 0xa4, 0x38, 0x93, 0x26, 0x0f, 0x89, 0x33, 0x0e, 0x40, 0xcc, 0xb7, 0x25, 0x1a, 0x8d, 0xfd, - 0x0f, 0x48, 0x30, 0x54, 0x3f, 0xd8, 0xe9, 0xa6, 0xde, 0xef, 0x99, 0xc4, 0x51, 0xf4, 0x69, 0x9b, 0x3c, 0x96, 0x2c, - 0x8d, 0x16, 0x8e, 0xde, 0x23, 0x86, 0x71, 0x38, 0x9d, 0x8f, 0x49, 0xb6, 0x31, 0x59, 0x05, 0x90, 0x4e, 0x66, 0xea, - 0x98, 0x52, 0x47, 0xe3, 0x5c, 0x2f, 0xa8, 0x42, 0x8f, 0x75, 0xc9, 0x73, 0xb0, 0x9e, 0xbc, 0xf2, 0x4a, 0x7f, 0x2a, - 0xe4, 0x1c, 0x36, 0x12, 0x41, 0xe1, 0x07, 0xb8, 0x1a, 0xac, 0x14, 0x30, 0x98, 0xfa, 0x16, 0xbe, 0x26, 0x9e, 0xa3, - 0xe0, 0x51, 0xd8, 0xc5, 0xd8, 0x5a, 0xf9, 0xce, 0x27, 0x05, 0xe5, 0x9e, 0x15, 0x73, 0x5e, 0x01, 0xe7, 0x32, 0x28, - 0x84, 0xe9, 0x78, 0x96, 0xff, 0x33, 0xc9, 0xeb, 0x89, 0x0d, 0x01, 0x32, 0xf8, 0x53, 0xe2, 0xb4, 0x74, 0x87, 0xee, - 0x3c, 0xf4, 0x2c, 0xe2, 0xb0, 0xd1, 0xa3, 0x75, 0x59, 0x6c, 0x53, 0xd4, 0x4b, 0x98, 0x1f, 0xc8, 0xcf, 0x5b, 0xf2, - 0x7d, 0x88, 0xe2, 0x6d, 0xf0, 0xb7, 0x8c, 0xc5, 0x02, 0xff, 0xfa, 0x67, 0xc6, 0x68, 0xa2, 0x05, 0x75, 0xd2, 0x20, - 0x51, 0xb1, 0x48, 0x26, 0x00, 0xeb, 0xc8, 0xd5, 0x87, 0x4f, 0x89, 0xf1, 0xd6, 0x6c, 0x78, 0xe0, 0x9b, 0x15, 0xe8, - 0xd4, 0xe7, 0xee, 0xca, 0xf6, 0x74, 0x35, 0x52, 0x55, 0x8d, 0xbf, 0xa5, 0xaa, 0x1a, 0x7f, 0x4b, 0xa9, 0x1a, 0xbf, - 0x65, 0x14, 0xbf, 0x53, 0xf9, 0x0c, 0x99, 0x93, 0x4d, 0x4c, 0xd2, 0xe9, 0x7b, 0xc3, 0x89, 0x5d, 0xf6, 0x5b, 0xb7, - 0x89, 0x3c, 0x33, 0x91, 0x42, 0xee, 0x0d, 0x40, 0xcd, 0xc4, 0x97, 0xb9, 0xe1, 0x94, 0x38, 0x3f, 0xf7, 0x70, 0xc5, - 0xa6, 0xd5, 0x35, 0x2d, 0x58, 0x60, 0xf3, 0x32, 0xcb, 0x33, 0x4f, 0x60, 0xdb, 0x94, 0x59, 0x3f, 0xe4, 0x1e, 0x40, - 0x30, 0x93, 0x9a, 0x00, 0x90, 0x16, 0xa2, 0x52, 0x88, 0xfc, 0x1a, 0x67, 0xf5, 0x39, 0xef, 0x6d, 0xf2, 0x98, 0x48, - 0xab, 0x7b, 0xfd, 0x7e, 0x7a, 0x96, 0xe6, 0x14, 0xd4, 0x70, 0x9c, 0x75, 0xfa, 0x4b, 0x16, 0xa4, 0x89, 0x5c, 0xa5, - 0xff, 0x74, 0x83, 0xbc, 0x8c, 0xef, 0xeb, 0xb6, 0xe7, 0x4f, 0xd4, 0xdf, 0x3b, 0xeb, 0x6f, 0x0b, 0x04, 0x77, 0x72, - 0xec, 0x27, 0xab, 0x52, 0x1e, 0x19, 0x97, 0xf6, 0x9e, 0xdf, 0xd4, 0x45, 0x91, 0xd5, 0xe9, 0xfa, 0xbd, 0xd4, 0xd3, - 0xe8, 0xbe, 0xd8, 0x83, 0x31, 0x78, 0x07, 0x80, 0x67, 0x3a, 0x34, 0x40, 0xfa, 0x9e, 0x91, 0x87, 0xfb, 0xdc, 0x92, - 0x9f, 0x54, 0xd6, 0x26, 0x09, 0x2b, 0x8a, 0xcd, 0x30, 0x46, 0x28, 0x19, 0xa7, 0xb1, 0xf5, 0xfb, 0x7d, 0xf5, 0xf7, - 0x0e, 0xa3, 0xa8, 0xa8, 0xb8, 0x63, 0x34, 0x2a, 0xab, 0x7a, 0xb4, 0x1d, 0x1c, 0x0e, 0xe7, 0xb9, 0x8d, 0xa3, 0xad, - 0x57, 0xc0, 0xde, 0x0a, 0x95, 0xb2, 0x57, 0x22, 0x2c, 0x3f, 0x5c, 0xf9, 0xfd, 0x3e, 0xfc, 0x2b, 0x23, 0x2d, 0x3c, - 0x7f, 0x8a, 0xbf, 0x16, 0x75, 0x81, 0xe1, 0x19, 0xb4, 0x46, 0x2b, 0x08, 0x26, 0xf8, 0x67, 0x07, 0xea, 0xa5, 0x95, - 0xf6, 0x01, 0x74, 0x2b, 0xd0, 0x83, 0x86, 0x93, 0x38, 0x69, 0x5f, 0x48, 0xd4, 0xed, 0xad, 0x4e, 0xa3, 0x3f, 0x2b, - 0x96, 0xf3, 0x02, 0x26, 0x87, 0x1b, 0xfa, 0xb4, 0x0a, 0xb7, 0x9f, 0xe0, 0xe9, 0x6b, 0xa0, 0xdc, 0x3a, 0x1c, 0x72, - 0x10, 0x5b, 0xc0, 0xcd, 0x63, 0x15, 0x7e, 0x2e, 0x4a, 0x19, 0x51, 0x1f, 0x4f, 0x43, 0xd0, 0xde, 0x05, 0xe8, 0x80, - 0xa5, 0x41, 0xbc, 0x42, 0xf2, 0x9c, 0x8d, 0x00, 0x96, 0x1d, 0x58, 0xce, 0x32, 0x4e, 0x61, 0x9e, 0xe5, 0x53, 0xb5, - 0xd2, 0xce, 0xa2, 0xc4, 0xab, 0x59, 0x06, 0xce, 0x02, 0x17, 0x95, 0xcf, 0x32, 0xad, 0x7a, 0x2a, 0x13, 0xf4, 0x79, - 0x25, 0x27, 0xb8, 0x12, 0x9c, 0x6c, 0x40, 0x7e, 0x01, 0x92, 0x34, 0xa5, 0xac, 0x29, 0x9f, 0x5e, 0xd2, 0x0d, 0x19, - 0x3d, 0xe7, 0x3d, 0x2f, 0x1a, 0x86, 0xfe, 0x85, 0x57, 0x42, 0xf8, 0x26, 0x6e, 0xdb, 0x28, 0x85, 0xfd, 0x4d, 0x60, - 0xf1, 0x09, 0x7b, 0xe5, 0x2d, 0xfd, 0xe9, 0x38, 0x08, 0x87, 0xc8, 0x0d, 0x15, 0x73, 0x60, 0x4f, 0x03, 0x16, 0x9b, - 0xf8, 0x6a, 0x33, 0x89, 0x07, 0x03, 0x5f, 0x67, 0x2c, 0x66, 0x31, 0xd0, 0x20, 0xc7, 0x83, 0xcb, 0xb9, 0x3e, 0x21, - 0xf4, 0xc3, 0x88, 0xca, 0x51, 0x81, 0xce, 0x41, 0x34, 0x58, 0x02, 0x9e, 0x7a, 0x2b, 0x1b, 0x24, 0x19, 0xc7, 0x90, - 0xc4, 0xb5, 0x26, 0xa9, 0x0e, 0x27, 0xb4, 0x0e, 0x74, 0x5c, 0x5d, 0x40, 0xe7, 0xe3, 0xba, 0xf7, 0xf1, 0x6a, 0xb8, - 0xa0, 0xd2, 0x2f, 0xc4, 0xc0, 0xab, 0xa7, 0xe3, 0xe0, 0x92, 0x6e, 0x85, 0x8b, 0x55, 0xb8, 0x7d, 0x2d, 0x1f, 0x38, - 0xee, 0xa8, 0xa4, 0x21, 0x30, 0x78, 0x7b, 0xe8, 0x6e, 0x66, 0xbc, 0x43, 0x8e, 0x0e, 0xe3, 0x4c, 0x0e, 0xb1, 0x6a, - 0xc5, 0x85, 0xf4, 0x46, 0xf0, 0xed, 0x42, 0x31, 0x96, 0x8d, 0x5d, 0x1a, 0x8a, 0xc2, 0xbf, 0x01, 0xd8, 0xa1, 0xf6, - 0x57, 0x2a, 0xf9, 0x18, 0x19, 0xd5, 0x34, 0xd0, 0x31, 0x00, 0x4b, 0x96, 0x26, 0x92, 0x2a, 0xd2, 0x48, 0xfc, 0x91, - 0x35, 0xd6, 0x4d, 0xd7, 0x17, 0x4c, 0x55, 0xc3, 0xa4, 0xdb, 0x99, 0xc4, 0x72, 0x22, 0x49, 0x6d, 0xf7, 0x11, 0x31, - 0x18, 0xf8, 0x60, 0x23, 0xa6, 0x99, 0x08, 0x47, 0x3c, 0x2a, 0x91, 0x45, 0x97, 0xdf, 0x46, 0x94, 0xb4, 0x7d, 0x59, - 0x91, 0x2d, 0x08, 0xa6, 0x27, 0xd1, 0x07, 0x49, 0xca, 0xa9, 0x48, 0xa4, 0x19, 0x21, 0xc0, 0x8f, 0x27, 0xe5, 0x95, - 0xfe, 0x1c, 0x34, 0xad, 0x04, 0x2f, 0x19, 0x24, 0x8f, 0xc4, 0xcf, 0xa4, 0x60, 0x16, 0x63, 0xd5, 0x60, 0x80, 0xe5, - 0x54, 0x8f, 0x1d, 0x93, 0xf4, 0xdf, 0x3a, 0x9d, 0xb0, 0x9f, 0x79, 0xb9, 0xad, 0xe5, 0x4d, 0x73, 0xef, 0x99, 0x57, - 0xb1, 0x54, 0xc3, 0x32, 0xe8, 0xbf, 0x26, 0xda, 0x05, 0x5b, 0x5b, 0xc6, 0x84, 0x55, 0x3f, 0x80, 0xb4, 0x47, 0xba, - 0xbc, 0x6a, 0x98, 0x33, 0xc1, 0xa3, 0x0b, 0x6b, 0x1e, 0x44, 0x17, 0xc2, 0x47, 0x2e, 0xbb, 0x49, 0x72, 0x35, 0x9e, - 0xf8, 0xe1, 0x60, 0xa0, 0x00, 0x68, 0x69, 0x9d, 0x14, 0x83, 0xf0, 0xb1, 0x90, 0x03, 0x69, 0x74, 0x54, 0x05, 0x58, - 0x2c, 0xb3, 0xab, 0x72, 0x92, 0x0d, 0x06, 0x3e, 0x88, 0x8d, 0x89, 0xdd, 0xd0, 0x6c, 0xee, 0xb3, 0x13, 0x05, 0x59, - 0x6d, 0xce, 0x5a, 0x33, 0xdd, 0x02, 0x03, 0x80, 0x41, 0x44, 0xb0, 0xdc, 0x27, 0x46, 0x3e, 0xa2, 0x4e, 0x4f, 0x61, - 0x04, 0x04, 0xbf, 0x9c, 0x08, 0x44, 0x2e, 0x12, 0xa8, 0x07, 0x98, 0x09, 0x30, 0xa3, 0x8a, 0xe1, 0x25, 0xb0, 0x8b, - 0xe7, 0xe6, 0x15, 0x83, 0xfe, 0x45, 0xbb, 0x44, 0xa2, 0xa9, 0xc4, 0xd1, 0x18, 0x39, 0x95, 0xc6, 0xc8, 0x80, 0xd8, - 0xc5, 0xf1, 0xef, 0x29, 0x3d, 0x0a, 0x52, 0xf6, 0xbc, 0x32, 0xc4, 0xe1, 0x28, 0xbe, 0x82, 0x55, 0xe3, 0x70, 0xa8, - 0xcd, 0xeb, 0xe9, 0xac, 0x9e, 0x0f, 0x44, 0x00, 0xff, 0x0d, 0x05, 0xfb, 0x55, 0x53, 0x91, 0x1b, 0xa4, 0xce, 0xc3, - 0x21, 0x05, 0xf9, 0xd4, 0x58, 0x65, 0x2b, 0x77, 0x3f, 0x9d, 0xcd, 0xad, 0x39, 0x7a, 0x51, 0xe3, 0xba, 0xb5, 0xba, - 0xa1, 0x90, 0x68, 0x4d, 0x93, 0xe2, 0xaa, 0x9a, 0x14, 0x03, 0x9e, 0xfb, 0x42, 0x75, 0xb1, 0x35, 0x82, 0x85, 0x3f, - 0xb7, 0x40, 0x98, 0xf4, 0xb7, 0xe2, 0x0e, 0xa9, 0x1a, 0x77, 0x6d, 0xb5, 0xdb, 0x56, 0x36, 0xa4, 0x68, 0x3e, 0xbc, - 0x84, 0x5d, 0x3a, 0x45, 0xb4, 0xed, 0x92, 0xe0, 0x0b, 0xd0, 0xb2, 0xba, 0x10, 0x79, 0x4c, 0xbf, 0x42, 0x7e, 0x29, - 0x86, 0x7f, 0x95, 0xee, 0xcd, 0xa9, 0x0d, 0x72, 0x00, 0xdb, 0xbd, 0x87, 0xdb, 0x31, 0x7a, 0x20, 0x83, 0x37, 0x42, - 0xce, 0x39, 0xbf, 0x9c, 0x5a, 0x33, 0x26, 0x1a, 0x16, 0xac, 0x1c, 0x46, 0x7e, 0x80, 0x8c, 0x97, 0x53, 0x60, 0x65, - 0x3f, 0x2a, 0xe2, 0xd2, 0x1f, 0x46, 0xfe, 0xc5, 0x93, 0x20, 0xe3, 0x5e, 0x34, 0xec, 0xf8, 0x02, 0xec, 0xd5, 0x17, - 0x4f, 0x58, 0x34, 0xe0, 0xd5, 0x55, 0x3d, 0xcd, 0x82, 0x61, 0xc6, 0xa2, 0xab, 0x62, 0x08, 0x3e, 0xb4, 0x4f, 0xcb, - 0x41, 0xe8, 0xfb, 0x66, 0xe7, 0x30, 0xc6, 0x64, 0x79, 0x84, 0xfd, 0x0c, 0x6e, 0xbb, 0x5a, 0x62, 0x06, 0x93, 0xcd, - 0x6d, 0xc4, 0x0c, 0xb6, 0xfc, 0xc5, 0x13, 0xc3, 0x25, 0x54, 0x3d, 0x95, 0x9a, 0x8d, 0x02, 0xcd, 0xc9, 0x15, 0x9a, - 0x93, 0x95, 0x50, 0x4b, 0x3e, 0xa9, 0x70, 0xc2, 0xce, 0x27, 0xb9, 0xb2, 0x1b, 0x8d, 0x31, 0x70, 0xd1, 0xde, 0x9a, - 0x84, 0x91, 0x99, 0xce, 0x52, 0x34, 0x60, 0xe1, 0x99, 0x38, 0xa5, 0x31, 0xa0, 0x7d, 0x39, 0xb0, 0xb4, 0x21, 0xbf, - 0xc8, 0x99, 0x81, 0xb6, 0x21, 0xa5, 0x51, 0x33, 0xf0, 0x67, 0x6a, 0xc2, 0xfc, 0x06, 0x56, 0x22, 0x88, 0xea, 0x02, - 0x4c, 0x92, 0x9c, 0x8c, 0x46, 0xca, 0x4a, 0x24, 0xe7, 0x80, 0xf7, 0x01, 0x3c, 0x59, 0xc4, 0xb6, 0xf6, 0xa7, 0xf4, - 0xbf, 0x3a, 0x7c, 0x2e, 0xfd, 0xc7, 0x02, 0x58, 0xc8, 0xa5, 0x41, 0x64, 0xa0, 0x70, 0x48, 0x2d, 0xc7, 0x98, 0xc4, - 0xf1, 0x0c, 0x7c, 0x09, 0x17, 0x68, 0x0a, 0xe8, 0x0f, 0x6a, 0x46, 0x11, 0x59, 0xf8, 0xab, 0x67, 0x37, 0x75, 0xad, - 0xe7, 0x99, 0xf3, 0x1a, 0x34, 0x33, 0x10, 0xd2, 0xe3, 0x54, 0xbd, 0x0d, 0x89, 0xce, 0xcb, 0xb7, 0xfa, 0x65, 0x42, - 0x24, 0x0b, 0x23, 0x4f, 0xdf, 0xe7, 0x60, 0x1e, 0x51, 0x84, 0x0e, 0xae, 0xcc, 0xc3, 0xe1, 0x5c, 0x50, 0xf8, 0x8e, - 0xf2, 0x7c, 0xc0, 0x69, 0x96, 0x24, 0xa0, 0x0d, 0x64, 0xb9, 0x29, 0x73, 0x95, 0xb4, 0x4c, 0xdd, 0x7b, 0xb0, 0x12, - 0x54, 0xe8, 0xe6, 0x14, 0x14, 0xca, 0x48, 0x50, 0x4a, 0xab, 0x41, 0x28, 0xd5, 0x61, 0x11, 0x44, 0x0e, 0x59, 0x08, - 0xb8, 0x99, 0x8a, 0x46, 0x4b, 0x1a, 0x1e, 0xe1, 0xdc, 0x40, 0x21, 0x00, 0x89, 0x3d, 0x55, 0x94, 0x71, 0x39, 0x04, - 0x7c, 0x94, 0x70, 0x88, 0xb3, 0x26, 0x6d, 0x79, 0x0e, 0xe2, 0x58, 0x2e, 0xf9, 0x6d, 0x85, 0x60, 0x10, 0xa1, 0xcf, - 0x90, 0x3f, 0x59, 0xce, 0xbf, 0x1b, 0x87, 0x69, 0x47, 0xf8, 0xb0, 0xab, 0x2d, 0xb8, 0x98, 0xdd, 0xcc, 0x27, 0x10, - 0xdf, 0x72, 0x33, 0x3f, 0xc6, 0x10, 0x59, 0xf8, 0x83, 0xdb, 0xa1, 0xe4, 0x8a, 0x42, 0x97, 0xf5, 0x88, 0x14, 0xd9, - 0xd3, 0x35, 0x47, 0x10, 0x1c, 0x68, 0xd5, 0x20, 0x43, 0x23, 0xf1, 0xc5, 0x13, 0xc8, 0x1a, 0xac, 0xf9, 0xf3, 0x8a, - 0x9c, 0xd5, 0xfd, 0xc9, 0x06, 0xaa, 0x49, 0x26, 0x6b, 0x45, 0xe5, 0xfc, 0xed, 0xaa, 0x2c, 0x4f, 0x56, 0x65, 0xb8, - 0x1a, 0x74, 0x55, 0x65, 0xc9, 0x91, 0xda, 0x00, 0xad, 0xe9, 0x0a, 0x31, 0x14, 0xb2, 0x06, 0x4b, 0xab, 0x2a, 0x6b, - 0xea, 0x13, 0x08, 0xf4, 0x01, 0x96, 0x51, 0xb3, 0x9f, 0x0e, 0x7f, 0x09, 0x7e, 0x51, 0x21, 0x4b, 0x75, 0x5a, 0x67, - 0xe2, 0xb7, 0x60, 0xc9, 0xf0, 0x8f, 0xdf, 0x83, 0x35, 0x60, 0x09, 0x90, 0xe5, 0x6e, 0x63, 0xa3, 0xf5, 0xaa, 0xf8, - 0xb9, 0x5a, 0x5f, 0xf4, 0x5b, 0xb7, 0x89, 0x5a, 0x01, 0x46, 0x28, 0xb4, 0x08, 0xb0, 0xd5, 0x03, 0xf7, 0x14, 0xfc, - 0x40, 0x0c, 0xe7, 0x9a, 0xb4, 0xa6, 0x4e, 0x78, 0x9d, 0x8d, 0x23, 0x11, 0xd5, 0x5b, 0xb8, 0xb8, 0xd7, 0x5b, 0x8b, - 0xbf, 0x51, 0x81, 0x00, 0xc8, 0x62, 0x8a, 0xb5, 0xf3, 0x86, 0xf4, 0xca, 0xb0, 0x93, 0xd0, 0x7b, 0xc3, 0x4e, 0x20, - 0x2f, 0x0e, 0x3b, 0x85, 0x2e, 0xd1, 0x76, 0x8a, 0xd4, 0x44, 0xdb, 0x49, 0x8b, 0x55, 0x58, 0x42, 0xf0, 0xab, 0xf6, - 0xd6, 0x51, 0xb6, 0x2f, 0xb2, 0x84, 0x69, 0x0b, 0x18, 0xe5, 0x56, 0x7d, 0xe6, 0x14, 0xb1, 0x52, 0xf6, 0x4e, 0x27, - 0x55, 0xee, 0x22, 0x9f, 0x5a, 0x4d, 0x91, 0xc9, 0xcf, 0x8f, 0x5b, 0x24, 0x9f, 0xbc, 0x6e, 0x37, 0x4c, 0xa6, 0x7f, - 0x38, 0xfa, 0x02, 0xba, 0x22, 0x3b, 0x7d, 0x02, 0x01, 0x99, 0x0a, 0xaa, 0xd5, 0xad, 0x62, 0x9a, 0xb7, 0xab, 0xec, - 0xf6, 0x42, 0x89, 0xe1, 0x74, 0x76, 0x12, 0x1e, 0x6d, 0x86, 0x0c, 0x1c, 0x82, 0x40, 0x21, 0x54, 0x14, 0xc3, 0x23, - 0x50, 0x6b, 0x24, 0x1f, 0xe0, 0x47, 0xbb, 0x53, 0x41, 0xa4, 0x76, 0x53, 0x71, 0xe3, 0xe4, 0xa6, 0xeb, 0xa5, 0x40, - 0xad, 0x53, 0xb2, 0x02, 0x28, 0x21, 0xea, 0x4f, 0x62, 0x5b, 0x5f, 0xc3, 0x15, 0x9b, 0xef, 0x1b, 0x45, 0x4f, 0xae, - 0x4f, 0x51, 0xb7, 0xe2, 0xea, 0x34, 0x6d, 0x35, 0xc7, 0x8e, 0x33, 0xe4, 0xe0, 0x59, 0x41, 0xb0, 0x1d, 0x95, 0x28, - 0xdf, 0xb4, 0x9b, 0x8e, 0x89, 0xad, 0xfe, 0x59, 0x54, 0x9b, 0x5b, 0xa8, 0x88, 0x88, 0x8f, 0xb2, 0x9b, 0x27, 0xed, - 0x77, 0xb0, 0xc7, 0x5a, 0x0d, 0x22, 0xfb, 0x0c, 0xae, 0x72, 0x9d, 0x16, 0xb9, 0x2d, 0x83, 0xf3, 0x0f, 0xaf, 0x76, - 0x15, 0x36, 0x39, 0xd6, 0xd5, 0xd5, 0x4c, 0x75, 0x52, 0xb1, 0x81, 0xb1, 0xa6, 0xb5, 0x54, 0xf3, 0x18, 0x92, 0xee, - 0xca, 0xe2, 0xac, 0x4a, 0xba, 0xe9, 0xb9, 0x71, 0xa6, 0x10, 0x03, 0x67, 0xab, 0xd1, 0x72, 0x86, 0x21, 0xba, 0x3e, - 0xcc, 0x12, 0xbf, 0xd5, 0x53, 0xee, 0xf3, 0x70, 0xeb, 0x77, 0xf5, 0x82, 0x93, 0xc9, 0x7e, 0x72, 0x9c, 0xbb, 0x5d, - 0xa4, 0xfd, 0xc4, 0xb7, 0x61, 0xfe, 0xf5, 0x0d, 0xe2, 0x56, 0xd4, 0xbf, 0x54, 0x00, 0x34, 0xb8, 0xc9, 0x63, 0x89, - 0x52, 0xbf, 0x57, 0xd5, 0x0f, 0x6a, 0xa6, 0x6a, 0x1a, 0x08, 0xe6, 0x54, 0x0a, 0xf8, 0xc3, 0xed, 0xc2, 0x15, 0x8f, - 0xb8, 0x61, 0x61, 0xfc, 0xe2, 0xd5, 0xec, 0x54, 0x50, 0x19, 0xb8, 0x19, 0x7f, 0xf1, 0x04, 0x3b, 0x85, 0xb5, 0x02, - 0xb2, 0xc2, 0x17, 0x2f, 0x7f, 0xe0, 0xfd, 0x8a, 0x7f, 0xf1, 0xaa, 0x07, 0xde, 0x47, 0x9c, 0x97, 0x2f, 0x48, 0xea, - 0x84, 0xa8, 0x2e, 0x5f, 0x08, 0x53, 0x6c, 0x95, 0xe6, 0x2f, 0x48, 0xe1, 0x13, 0x7c, 0x06, 0xbe, 0xc3, 0x55, 0xb8, - 0x35, 0xbf, 0xc1, 0x63, 0xc7, 0x62, 0xdb, 0xa5, 0xbe, 0x80, 0x72, 0x04, 0x16, 0x91, 0xdb, 0x6f, 0x57, 0xf6, 0xab, - 0x85, 0x51, 0xc6, 0xd8, 0x7d, 0xc9, 0x4a, 0x94, 0xce, 0xfa, 0xfd, 0x42, 0x0a, 0x46, 0x76, 0x61, 0x8d, 0xf6, 0x28, - 0x55, 0xaf, 0xbe, 0x09, 0xeb, 0x28, 0x49, 0xf3, 0x5b, 0x19, 0x7d, 0x24, 0xc3, 0x8e, 0xf4, 0x95, 0x94, 0x68, 0xaf, - 0x55, 0x58, 0x8e, 0x66, 0xbf, 0x2e, 0x39, 0x50, 0x5e, 0xb7, 0x82, 0xf2, 0x55, 0x13, 0x40, 0xaf, 0x54, 0xfb, 0x0c, - 0xb4, 0x82, 0xc2, 0x52, 0x79, 0xb0, 0x12, 0xe7, 0xa2, 0xcf, 0x8a, 0xc3, 0x41, 0x5d, 0x0c, 0x09, 0x05, 0xaa, 0xc4, - 0x49, 0x68, 0xc4, 0x73, 0xb8, 0x10, 0x8a, 0xa7, 0x39, 0xc6, 0x56, 0xe4, 0xc0, 0x81, 0x0c, 0x3f, 0x20, 0xf0, 0x5e, - 0xf6, 0xaf, 0x60, 0x30, 0x4c, 0x70, 0x23, 0xa3, 0x4e, 0xce, 0xd9, 0x17, 0x0c, 0xcc, 0xa0, 0x9e, 0xd4, 0xee, 0xb3, - 0x7b, 0x15, 0xd8, 0x0b, 0x67, 0x40, 0x7b, 0x37, 0x46, 0x3f, 0xab, 0x62, 0xed, 0xa4, 0x7f, 0x2a, 0xd6, 0x90, 0x4c, - 0x87, 0xc5, 0xd1, 0x36, 0x0d, 0x8f, 0xe4, 0xc9, 0x71, 0xbc, 0xe9, 0x1f, 0x0e, 0x63, 0xfc, 0x38, 0xca, 0xaf, 0x2d, - 0xe0, 0x55, 0xdc, 0x42, 0x1a, 0x8b, 0x14, 0xbd, 0x03, 0x31, 0x87, 0xa2, 0x97, 0xec, 0xb7, 0x8c, 0x97, 0x13, 0x41, - 0x29, 0x49, 0x6c, 0x78, 0x47, 0x7a, 0x9a, 0xd6, 0xa3, 0xad, 0x0c, 0xd8, 0xaf, 0x47, 0x3b, 0xfa, 0x0b, 0x14, 0x8f, - 0x16, 0xfe, 0x92, 0xfe, 0x2e, 0xee, 0xe6, 0x9e, 0xf3, 0x4d, 0xe3, 0x3b, 0xe2, 0x02, 0xc5, 0x9a, 0xdd, 0x5f, 0xd3, - 0xd2, 0x59, 0x07, 0x82, 0x03, 0xde, 0x62, 0x17, 0xed, 0xfb, 0x8d, 0xeb, 0xf4, 0xb4, 0xff, 0xde, 0xad, 0x51, 0xbe, - 0xf7, 0x8b, 0x44, 0x39, 0xd8, 0xbf, 0x70, 0xd1, 0xfc, 0xed, 0xa7, 0x0c, 0x49, 0x85, 0xe6, 0x06, 0xdb, 0xc9, 0x16, - 0x61, 0x6d, 0x8c, 0x83, 0x8a, 0xdd, 0x96, 0x61, 0x04, 0x0c, 0xea, 0xd8, 0xff, 0xe8, 0xb3, 0x69, 0x43, 0xf6, 0x01, - 0xa0, 0x72, 0x15, 0x02, 0xf6, 0x00, 0x9c, 0x68, 0x84, 0x1b, 0xe0, 0x56, 0xa3, 0x25, 0x1d, 0xd4, 0x6d, 0xc1, 0x40, - 0xb4, 0x84, 0x8d, 0xbc, 0xed, 0xea, 0xf4, 0x0d, 0xe1, 0x43, 0xed, 0xa4, 0x74, 0x28, 0x7f, 0xf3, 0x9c, 0xfd, 0xcf, - 0x0e, 0x6b, 0x6a, 0xca, 0x47, 0xc0, 0xcc, 0x59, 0x89, 0xbc, 0x42, 0xe8, 0x14, 0xf9, 0xbd, 0xaa, 0x2b, 0x31, 0x5c, - 0xd6, 0xa2, 0xec, 0xcc, 0x6e, 0x9d, 0xe8, 0x9d, 0x53, 0x50, 0x4b, 0x65, 0x83, 0x9c, 0xa4, 0xda, 0x7c, 0x64, 0xad, - 0xa0, 0x44, 0x5d, 0xa3, 0xc0, 0xf1, 0x29, 0xd7, 0xee, 0xff, 0x9d, 0x33, 0x41, 0xcd, 0x36, 0xaa, 0xfb, 0x0b, 0xfd, - 0x54, 0xd5, 0x24, 0x16, 0xe0, 0x72, 0x92, 0xe6, 0x1d, 0x8f, 0xb0, 0xfa, 0xc7, 0xc9, 0x52, 0x04, 0xfa, 0x14, 0xd1, - 0xae, 0x04, 0x24, 0x68, 0x27, 0x67, 0xa1, 0x22, 0x50, 0xa0, 0xaf, 0x3f, 0xdf, 0xa4, 0x59, 0x2c, 0x57, 0xb3, 0x3d, - 0x4c, 0x94, 0xc5, 0x7a, 0x88, 0x20, 0x67, 0xa6, 0x0e, 0xf6, 0x7b, 0x9a, 0xd1, 0x2c, 0xbc, 0x32, 0x25, 0xb8, 0x14, - 0x57, 0x51, 0x91, 0x83, 0xcf, 0x21, 0xbe, 0xf0, 0xa9, 0x90, 0x1b, 0x44, 0x34, 0xfd, 0x59, 0xa2, 0xda, 0x91, 0x02, - 0x39, 0x94, 0xfc, 0x84, 0xf8, 0x4b, 0xd6, 0xc6, 0xb8, 0x5f, 0x3a, 0xd5, 0xbe, 0x56, 0x08, 0xee, 0xaf, 0x6d, 0xb1, - 0x51, 0xe5, 0x89, 0x1e, 0x7c, 0x8a, 0xf5, 0x3f, 0x59, 0x40, 0xa9, 0xee, 0xdb, 0xe0, 0x54, 0x3c, 0x0a, 0x37, 0x75, - 0xf1, 0x11, 0xa1, 0x05, 0xca, 0x51, 0x55, 0x6c, 0xca, 0x88, 0x38, 0x61, 0x37, 0x75, 0xd1, 0xd3, 0x1c, 0xe8, 0xd4, - 0x61, 0xe0, 0x80, 0x9a, 0x28, 0x11, 0xc5, 0x6e, 0x41, 0xf7, 0x34, 0xc7, 0x4a, 0x3c, 0x93, 0xa5, 0x83, 0xac, 0x13, - 0x69, 0x42, 0xe5, 0xae, 0xae, 0x3a, 0x2a, 0x95, 0xba, 0xe1, 0x65, 0xaa, 0x19, 0x7f, 0x97, 0xe6, 0x4f, 0x2c, 0xfb, - 0x65, 0xeb, 0xb7, 0x5a, 0xed, 0x8d, 0xd5, 0xa3, 0x92, 0x35, 0xc7, 0xd9, 0x84, 0xa4, 0xf4, 0x09, 0xdb, 0xcd, 0xa4, - 0x6b, 0x1d, 0x78, 0x12, 0x5c, 0x0e, 0x3d, 0x01, 0x15, 0x83, 0x26, 0xde, 0xee, 0x02, 0xf5, 0x08, 0x3c, 0x03, 0xe5, - 0x13, 0xb5, 0x0e, 0xf8, 0x79, 0xad, 0xe5, 0x29, 0x23, 0x0c, 0xab, 0x9d, 0x45, 0xcb, 0xc1, 0x79, 0xa7, 0x08, 0x5c, - 0xbb, 0x12, 0x78, 0x3e, 0x54, 0xef, 0x85, 0x80, 0xe1, 0xfe, 0xa9, 0x50, 0xd9, 0xec, 0x66, 0x38, 0x8f, 0x1a, 0xa7, - 0x07, 0xda, 0xdb, 0xae, 0xf5, 0x50, 0xef, 0xba, 0x9d, 0xdb, 0x4a, 0xf7, 0x7e, 0xed, 0x64, 0xd2, 0x05, 0xb4, 0x36, - 0x9f, 0x7d, 0x67, 0x57, 0x5a, 0x37, 0x3d, 0x67, 0x0f, 0xb6, 0x6e, 0x89, 0xce, 0x05, 0xd1, 0xe4, 0xf7, 0x03, 0xcf, - 0xda, 0x76, 0xf4, 0xdb, 0xb4, 0x63, 0x9b, 0x7b, 0xa8, 0x7b, 0x05, 0xb5, 0xde, 0xd0, 0xbc, 0x7f, 0xe6, 0xda, 0x76, - 0x7c, 0xf5, 0xeb, 0xba, 0xc3, 0x75, 0xde, 0x04, 0xc7, 0x4d, 0xd7, 0xb6, 0xda, 0xd9, 0xcf, 0xdd, 0xbd, 0xb5, 0x88, - 0xc2, 0x2c, 0xfb, 0xb9, 0x28, 0xfe, 0xac, 0xf4, 0x1d, 0x81, 0x8e, 0xee, 0xbc, 0xa8, 0xd3, 0xe5, 0xee, 0x3d, 0x61, - 0x3c, 0x79, 0xf5, 0x11, 0xd1, 0xad, 0xef, 0x33, 0xf7, 0x2b, 0xc0, 0x8d, 0xe0, 0x0e, 0xa2, 0xbd, 0x5b, 0xea, 0x93, - 0x5a, 0x7d, 0xad, 0xd7, 0xce, 0xd3, 0xf3, 0x9b, 0xce, 0xed, 0x77, 0xdf, 0x1c, 0x6d, 0xbd, 0xc7, 0x85, 0xb5, 0xb2, - 0xf4, 0x54, 0x15, 0xec, 0xcd, 0xf2, 0x54, 0x15, 0x4c, 0x1e, 0x78, 0xcd, 0x7e, 0x41, 0x83, 0x2b, 0x1d, 0x6d, 0xbc, - 0x27, 0x6a, 0xe0, 0x16, 0x85, 0xa5, 0xc3, 0x2f, 0xb9, 0x99, 0x5c, 0xe3, 0xfe, 0x52, 0x91, 0x8b, 0x7d, 0xe7, 0x8c, - 0xee, 0xcc, 0xac, 0x7b, 0x55, 0xe1, 0x6a, 0x41, 0xae, 0x0e, 0x6c, 0x2d, 0xbb, 0x38, 0xdc, 0xb0, 0x88, 0x02, 0x04, - 0x62, 0x7a, 0xa5, 0xd6, 0xfe, 0x88, 0x06, 0x21, 0x1f, 0x0c, 0xfc, 0x02, 0x83, 0x55, 0x81, 0xc2, 0x07, 0x8a, 0xe4, - 0x2f, 0x3c, 0x01, 0xbb, 0x78, 0x06, 0xe8, 0x56, 0x6c, 0x56, 0x8c, 0x10, 0x21, 0x93, 0xe5, 0xac, 0xa6, 0x33, 0xc8, - 0xa7, 0xbe, 0xf8, 0xce, 0x56, 0x9d, 0xce, 0xdb, 0x9a, 0x2a, 0xa7, 0x0e, 0x85, 0xee, 0x6e, 0xea, 0xce, 0xad, 0x8b, - 0x3c, 0x75, 0x08, 0xb9, 0x52, 0xb1, 0x12, 0xd3, 0x50, 0xf3, 0x24, 0xcd, 0xa8, 0xbf, 0xda, 0xfb, 0xbd, 0x46, 0xe1, - 0x94, 0x3f, 0x1d, 0x83, 0x2a, 0x5c, 0xd5, 0x10, 0xc7, 0x52, 0x15, 0x8f, 0x6c, 0x10, 0x68, 0x5e, 0xdd, 0xaa, 0xa4, - 0x09, 0x99, 0xdc, 0x08, 0x9f, 0x9a, 0x94, 0xf2, 0x34, 0x6d, 0xd2, 0x4a, 0x91, 0x3a, 0xf8, 0xa0, 0x4e, 0x35, 0x9e, - 0x9b, 0xd5, 0x53, 0x00, 0x33, 0xce, 0xaf, 0xf8, 0xa5, 0xe2, 0x32, 0x6a, 0x2b, 0x33, 0x69, 0x7f, 0x72, 0x34, 0x36, - 0xea, 0x72, 0xaa, 0xcc, 0x2b, 0x06, 0x7d, 0xfa, 0xb5, 0x3e, 0xff, 0x80, 0xc1, 0x9a, 0x27, 0xb0, 0x83, 0x89, 0x4a, - 0x79, 0x1f, 0x01, 0xf1, 0x75, 0x92, 0xde, 0x26, 0x90, 0x22, 0xfd, 0x4b, 0x97, 0x3c, 0x75, 0x18, 0x1b, 0x88, 0x31, - 0x2b, 0x66, 0x46, 0xff, 0x83, 0xbb, 0xa4, 0x3f, 0x09, 0x01, 0x70, 0x13, 0x4d, 0xa1, 0x53, 0xe7, 0xc9, 0x45, 0x1e, - 0x2c, 0x2f, 0x3c, 0xb4, 0x62, 0xc4, 0x83, 0xbf, 0x3e, 0x0d, 0x11, 0xc4, 0x1c, 0x53, 0x3c, 0xfd, 0xc2, 0xe8, 0x2f, - 0xc1, 0x25, 0x46, 0x10, 0xba, 0x7b, 0xe7, 0x30, 0x84, 0x9b, 0x3d, 0xc8, 0xa0, 0xfe, 0x50, 0x87, 0x44, 0x0d, 0x7f, - 0xa9, 0x3c, 0xe8, 0xff, 0x3a, 0x13, 0x96, 0xda, 0x4f, 0x4f, 0x07, 0x50, 0xc1, 0xfb, 0x8a, 0xb7, 0x11, 0xf1, 0x7d, - 0xe2, 0xc7, 0xf1, 0x60, 0xf3, 0x78, 0x03, 0xd6, 0xba, 0x67, 0xb9, 0xb1, 0xae, 0x12, 0x36, 0x10, 0xf0, 0x35, 0xa6, - 0xb5, 0xe7, 0xb5, 0xdb, 0x3d, 0xf8, 0xab, 0x7f, 0x11, 0x32, 0x60, 0xe2, 0xf4, 0x7d, 0xe6, 0x64, 0x8d, 0x2e, 0x32, - 0x99, 0x3e, 0x74, 0xd2, 0x37, 0x3a, 0xdd, 0x77, 0xc2, 0x3f, 0x2a, 0x66, 0xf1, 0xe1, 0x96, 0xbe, 0xd2, 0xa4, 0xb8, - 0x03, 0x56, 0x36, 0x0f, 0x0a, 0x42, 0x9d, 0x8b, 0xe8, 0x1b, 0x53, 0xbe, 0x25, 0xd4, 0xec, 0x1b, 0x4b, 0x4a, 0xe9, - 0x5e, 0x43, 0x2f, 0xd3, 0x5a, 0xbf, 0x8d, 0x12, 0x8c, 0x89, 0x8e, 0x27, 0x2f, 0xe3, 0xb1, 0xf2, 0x3e, 0x1e, 0x37, - 0x52, 0x21, 0x0f, 0x40, 0x04, 0x2a, 0xc6, 0x9f, 0xae, 0x3c, 0x39, 0xe9, 0x85, 0xf1, 0x2a, 0x94, 0x82, 0xc2, 0x80, - 0xae, 0x40, 0x0a, 0x78, 0xd4, 0x9e, 0xe8, 0x2c, 0xec, 0x12, 0xee, 0xd1, 0x4d, 0xc0, 0x58, 0x9f, 0x7f, 0x01, 0x34, - 0x77, 0xe1, 0x0e, 0x2f, 0x06, 0xa8, 0x4d, 0xbd, 0xba, 0xfb, 0xb8, 0x56, 0xe7, 0x70, 0x08, 0x0e, 0x56, 0x83, 0x08, - 0x4e, 0xe7, 0x53, 0x47, 0xb3, 0x2c, 0x40, 0xe5, 0x64, 0xb9, 0x91, 0x37, 0x8f, 0x16, 0xbd, 0xba, 0xef, 0x2d, 0xd3, - 0xb2, 0xaa, 0x83, 0x8c, 0x65, 0x61, 0x05, 0xb8, 0x3a, 0xb4, 0x7e, 0x10, 0x2e, 0x0b, 0xe7, 0x0f, 0x84, 0x20, 0x76, - 0xaf, 0xb6, 0x25, 0xcf, 0xd5, 0x1c, 0x7e, 0xfc, 0x84, 0xad, 0xb9, 0x44, 0x9d, 0x74, 0x26, 0x02, 0x10, 0x7b, 0x6a, - 0x56, 0xd1, 0x35, 0x90, 0xd4, 0x69, 0x56, 0xd1, 0x35, 0x35, 0xdb, 0x18, 0x07, 0xf2, 0xd1, 0x2a, 0x05, 0xec, 0xbb, - 0xe9, 0x38, 0x58, 0x3d, 0x8e, 0xe5, 0x75, 0xe8, 0xf6, 0xf1, 0x46, 0xf9, 0x0c, 0xea, 0x56, 0x1b, 0x63, 0x62, 0xbb, - 0xf9, 0x72, 0xae, 0xdf, 0x0c, 0x96, 0xbe, 0x1d, 0x34, 0xe7, 0x94, 0x7d, 0xab, 0xcb, 0x5e, 0xd9, 0x65, 0x53, 0xcf, - 0x1d, 0x15, 0xad, 0xc6, 0x80, 0xde, 0xc0, 0x82, 0xf5, 0xb9, 0x48, 0xb3, 0x55, 0xa9, 0x4a, 0xc0, 0x0b, 0x63, 0xc5, - 0x6e, 0xfd, 0x46, 0x66, 0x48, 0xc2, 0x3c, 0xce, 0xc4, 0x1b, 0xba, 0xd7, 0xc2, 0xe4, 0x38, 0x16, 0xc9, 0x94, 0xd0, - 0x29, 0xdd, 0xd9, 0x86, 0xce, 0x55, 0x18, 0x45, 0xb4, 0x56, 0x52, 0x69, 0x24, 0x30, 0x35, 0x03, 0x94, 0xcc, 0x15, - 0x38, 0xa5, 0xcb, 0xfd, 0xef, 0x48, 0x8c, 0x33, 0x5f, 0x94, 0xcc, 0x80, 0x6e, 0xf9, 0x75, 0xb1, 0x6e, 0xa5, 0xc8, - 0x08, 0xf3, 0xe6, 0xb8, 0xbd, 0xae, 0x0f, 0x81, 0x5c, 0x2d, 0x7b, 0x14, 0x8d, 0x83, 0x42, 0x87, 0x4b, 0x95, 0x00, - 0xfb, 0x22, 0xf1, 0x33, 0xc2, 0x96, 0xf6, 0x40, 0x6e, 0x8f, 0xce, 0x84, 0x39, 0xe7, 0xa4, 0x2c, 0x3b, 0x97, 0x66, - 0x70, 0x39, 0x71, 0x25, 0xb8, 0x48, 0x6f, 0xdb, 0xd3, 0xa4, 0xa5, 0xed, 0x63, 0xc3, 0x39, 0x1a, 0xda, 0x06, 0xdd, - 0xb1, 0x3f, 0x34, 0x17, 0x8b, 0xd8, 0xba, 0x58, 0x0c, 0x3b, 0xb3, 0x1f, 0x2d, 0x16, 0x20, 0x07, 0x80, 0xa3, 0x6e, - 0xc3, 0xc7, 0x6c, 0x09, 0x9c, 0x56, 0xd3, 0x6c, 0xea, 0x6d, 0x78, 0xf5, 0x58, 0xf5, 0xf4, 0x92, 0xe7, 0x8f, 0x85, - 0x19, 0x8b, 0x0d, 0xcf, 0x1f, 0x5b, 0x47, 0x4e, 0xf5, 0x58, 0x28, 0xd1, 0xba, 0x80, 0x66, 0xe0, 0x35, 0x05, 0x8c, - 0x58, 0x32, 0x99, 0x52, 0x45, 0x1e, 0xf7, 0xa6, 0x1b, 0x35, 0x78, 0x41, 0xe1, 0x10, 0x48, 0xe9, 0xf4, 0x8b, 0x27, - 0x4c, 0xbf, 0x77, 0xf1, 0xa4, 0x43, 0xd6, 0x36, 0x4c, 0x97, 0x9b, 0x61, 0x32, 0x28, 0xfd, 0xc7, 0x66, 0x62, 0x5c, - 0x58, 0x93, 0x04, 0x10, 0xff, 0xc6, 0x7e, 0x87, 0x14, 0x6e, 0xde, 0x5f, 0x0e, 0xe3, 0x07, 0xde, 0x8f, 0x91, 0x3d, - 0x49, 0x33, 0xc4, 0x9a, 0x49, 0x85, 0xdc, 0x7d, 0xb5, 0xfe, 0x31, 0xb1, 0x9b, 0xec, 0x81, 0x05, 0x20, 0xb6, 0xa6, - 0xad, 0x6e, 0x79, 0xbf, 0xef, 0x99, 0x22, 0xc0, 0x0f, 0xca, 0x3f, 0xba, 0x33, 0x24, 0x83, 0xb2, 0xeb, 0x86, 0x10, - 0x0f, 0xca, 0xa6, 0x69, 0xaf, 0xb7, 0xbd, 0x33, 0x8f, 0xd5, 0x75, 0xda, 0x59, 0x5c, 0x2d, 0x32, 0x48, 0xab, 0x0f, - 0xd9, 0x71, 0x66, 0x9f, 0x1d, 0x2d, 0x95, 0xee, 0xf7, 0x21, 0x22, 0xee, 0x28, 0x6b, 0xfb, 0xed, 0x16, 0x5c, 0xc3, - 0xd1, 0x20, 0x74, 0x65, 0x6f, 0x97, 0xd1, 0xc6, 0x85, 0x38, 0xee, 0x99, 0xce, 0x17, 0x7c, 0x79, 0x94, 0x76, 0x1e, - 0x9c, 0xea, 0x89, 0x3e, 0x37, 0xdd, 0x55, 0x26, 0xd7, 0x3a, 0xac, 0xc6, 0xa0, 0x36, 0x0b, 0x5b, 0xb8, 0x0b, 0xdb, - 0xe8, 0xa0, 0xb5, 0x2f, 0x0b, 0xfe, 0x29, 0x03, 0xf0, 0xa5, 0x67, 0xcb, 0xb6, 0xd7, 0xa4, 0xd5, 0x4b, 0x19, 0x85, - 0xd8, 0xd2, 0xf6, 0xea, 0xd3, 0x51, 0x3e, 0x6e, 0x4e, 0x28, 0x2e, 0xe4, 0x28, 0x3f, 0x78, 0x0d, 0x51, 0xd7, 0xba, - 0x8e, 0x8b, 0x45, 0x87, 0x1b, 0x57, 0xdd, 0x76, 0xe3, 0x7a, 0x85, 0x78, 0x6b, 0xb4, 0x49, 0xa1, 0x56, 0xc6, 0x8e, - 0xe0, 0x65, 0xf9, 0x70, 0xc8, 0xc4, 0x70, 0x28, 0x21, 0x53, 0x1f, 0xba, 0x37, 0x34, 0xed, 0xf3, 0xd3, 0xd6, 0x8f, - 0x58, 0x6a, 0x1c, 0xc5, 0x86, 0x77, 0xfa, 0xce, 0x63, 0x6b, 0x5c, 0xc9, 0x97, 0xc1, 0x6c, 0x57, 0x50, 0x6d, 0x8d, - 0x37, 0xec, 0xe5, 0xfc, 0xe7, 0x4a, 0x2a, 0xf9, 0xdb, 0x9f, 0xe1, 0x1a, 0xde, 0xda, 0xd2, 0x41, 0x53, 0xcd, 0x72, - 0x96, 0xeb, 0x7b, 0xc1, 0xf1, 0xc7, 0xdd, 0x2b, 0x82, 0xc1, 0xef, 0xe9, 0x28, 0xc8, 0xc5, 0x52, 0xad, 0x01, 0x05, - 0xe9, 0xc8, 0x8e, 0xa9, 0x2c, 0x30, 0x0c, 0xe0, 0x0d, 0x19, 0x20, 0x8f, 0x29, 0xdc, 0x0d, 0x15, 0x5e, 0xf8, 0x6b, - 0x45, 0x76, 0x09, 0x6c, 0x6b, 0xc6, 0xc7, 0x0c, 0x77, 0x10, 0xf2, 0x8f, 0x60, 0xb7, 0x6c, 0xc5, 0x6e, 0xd8, 0x82, - 0x21, 0xd9, 0x38, 0x0e, 0x63, 0xcc, 0xc7, 0x93, 0xf8, 0x4a, 0x4c, 0xe2, 0x01, 0x8f, 0xd0, 0x31, 0x62, 0xcd, 0xeb, - 0x59, 0x2c, 0x07, 0x90, 0xdd, 0x72, 0xa5, 0x03, 0x42, 0x68, 0x6c, 0x68, 0xc9, 0xcb, 0xc2, 0xe0, 0x62, 0xc7, 0x3e, - 0x23, 0x91, 0x8c, 0x43, 0xb0, 0x68, 0x55, 0x03, 0x0b, 0x13, 0xbb, 0xe1, 0xc5, 0x6c, 0x35, 0xc7, 0x7f, 0x0e, 0x07, - 0x04, 0xc0, 0x0e, 0xf6, 0x0d, 0xbb, 0x8d, 0x10, 0xe9, 0x6d, 0xc1, 0x6f, 0x2d, 0x4f, 0x17, 0x76, 0xc7, 0xaf, 0xf9, - 0x98, 0x9d, 0xbf, 0xf2, 0x20, 0x72, 0xf6, 0xfc, 0x03, 0xa0, 0x21, 0xde, 0xf1, 0x9b, 0xd4, 0xab, 0xd8, 0x0d, 0x51, - 0x10, 0xde, 0x80, 0x33, 0xd0, 0x1d, 0x44, 0xc0, 0x5e, 0xf3, 0x05, 0xc6, 0x8a, 0x9d, 0xa5, 0x4b, 0x0f, 0x33, 0x42, - 0xed, 0xe9, 0x7c, 0x59, 0xab, 0x49, 0xb8, 0xb9, 0x5a, 0x4e, 0x06, 0x83, 0x8d, 0xbf, 0xe3, 0x6b, 0xe0, 0x83, 0x39, - 0x7f, 0xe5, 0xed, 0xa8, 0x5c, 0xf8, 0xcf, 0xeb, 0x2c, 0x79, 0xe7, 0xb3, 0xeb, 0x01, 0x5f, 0x00, 0xde, 0x12, 0x3a, - 0x70, 0xdd, 0xf9, 0x4c, 0xe2, 0xb5, 0x5d, 0xeb, 0x6b, 0x04, 0x12, 0xf9, 0x02, 0x30, 0x62, 0x62, 0x7e, 0x5f, 0x43, - 0x04, 0xc6, 0x06, 0x7c, 0x5b, 0xb5, 0x47, 0xfc, 0x96, 0x1b, 0xc0, 0xaf, 0xcc, 0x67, 0xf7, 0x3c, 0xd4, 0x3f, 0x13, - 0x9f, 0xbd, 0xe1, 0x8f, 0xf8, 0x53, 0x4f, 0x4a, 0xd2, 0xe5, 0xec, 0xd1, 0x1c, 0xae, 0x87, 0x52, 0x9e, 0x0e, 0xe9, - 0x67, 0x63, 0x30, 0x80, 0x50, 0xc8, 0x7c, 0xe3, 0x01, 0x6b, 0x52, 0x88, 0x7f, 0x01, 0xdf, 0x8e, 0x12, 0x36, 0xdf, - 0x78, 0x5b, 0x5f, 0xcb, 0x9b, 0x6f, 0xbc, 0x7b, 0x9f, 0xa2, 0x00, 0xab, 0xa0, 0x94, 0x05, 0x56, 0x41, 0xd8, 0x68, - 0x23, 0x8c, 0x81, 0xab, 0x77, 0x8d, 0xa1, 0xae, 0xe7, 0x88, 0x6d, 0x2b, 0x7d, 0x1b, 0xbe, 0x85, 0x0c, 0xf8, 0xe0, - 0x65, 0x51, 0x12, 0x7d, 0x4e, 0x4d, 0x91, 0xb4, 0xee, 0xb9, 0xdf, 0x5a, 0x77, 0xb4, 0xa6, 0xd4, 0x47, 0xae, 0xc6, - 0x87, 0x43, 0xfd, 0x54, 0x68, 0x91, 0x60, 0x0a, 0x1a, 0xd7, 0xa0, 0x2d, 0x40, 0xd0, 0xe7, 0x01, 0xb2, 0x96, 0x14, - 0x0b, 0xbe, 0xfd, 0x15, 0x62, 0xf0, 0xca, 0xf4, 0xce, 0xe5, 0x2a, 0x23, 0x61, 0x7b, 0xe1, 0x97, 0xc3, 0xda, 0x9f, - 0x38, 0xb5, 0xb0, 0xb4, 0x9a, 0x83, 0xfa, 0xb1, 0x2d, 0xc7, 0xe9, 0xaa, 0x45, 0x5e, 0x87, 0xd2, 0x72, 0x7a, 0x67, - 0xdf, 0x74, 0x99, 0x60, 0x63, 0x3f, 0xa0, 0xea, 0xc8, 0x6a, 0xd8, 0x7d, 0xa1, 0xbe, 0xe8, 0x29, 0x99, 0xd0, 0x7c, - 0x54, 0xd1, 0x3c, 0xb7, 0xbe, 0x79, 0x5c, 0xff, 0xe9, 0xe5, 0x50, 0x04, 0x48, 0x56, 0x69, 0xb1, 0x14, 0x39, 0x1b, - 0xfb, 0xf1, 0x30, 0xc9, 0x54, 0x78, 0x41, 0x3a, 0xba, 0xfb, 0x8d, 0xfb, 0x5b, 0x6e, 0x20, 0x2b, 0xb4, 0x6a, 0x83, - 0xb1, 0x52, 0xb4, 0x0c, 0xd6, 0x57, 0xe3, 0x7e, 0x5f, 0x5c, 0x8d, 0xa7, 0x22, 0xa8, 0x81, 0xb8, 0x48, 0x3c, 0x1d, - 0x4f, 0x6b, 0x62, 0x49, 0xed, 0x0a, 0x8c, 0xd1, 0xe3, 0xaa, 0xa8, 0x7d, 0xea, 0xa7, 0x10, 0x8a, 0x54, 0x6b, 0xe6, - 0x58, 0xe3, 0xc6, 0x88, 0xb8, 0xc3, 0xca, 0xb5, 0x53, 0x7b, 0x1d, 0x80, 0xe5, 0xd5, 0xb8, 0x20, 0xac, 0x93, 0x63, - 0xe7, 0x02, 0x56, 0xa3, 0x21, 0xd5, 0x6e, 0xb8, 0xf5, 0xb2, 0xf3, 0x9b, 0x2f, 0x13, 0x5b, 0x1b, 0xe1, 0x96, 0x02, - 0xca, 0x28, 0xbf, 0xb1, 0x9c, 0xb0, 0x3b, 0xd5, 0x3b, 0x52, 0xb5, 0x23, 0x4e, 0x5c, 0xc0, 0x72, 0xc3, 0x53, 0xab, - 0x6f, 0x62, 0x70, 0x22, 0x54, 0xad, 0x74, 0xb8, 0x93, 0x09, 0xc4, 0xfd, 0xea, 0xbe, 0xee, 0x95, 0xe0, 0x27, 0x21, - 0xaf, 0xdf, 0xf2, 0x0e, 0x00, 0x2b, 0x3e, 0xe4, 0xc5, 0xb4, 0x70, 0xb4, 0x2e, 0x83, 0x32, 0x40, 0x84, 0x66, 0x00, - 0x74, 0x72, 0x75, 0x10, 0xa5, 0x81, 0x2b, 0xee, 0x10, 0xe1, 0xa7, 0xd1, 0xe3, 0xfc, 0x69, 0xf8, 0xb8, 0x9a, 0x86, - 0x17, 0x79, 0x10, 0x5d, 0x54, 0x41, 0xf4, 0xb8, 0xba, 0x0a, 0x1f, 0xe7, 0xd3, 0xe8, 0x22, 0x0f, 0xc2, 0x8b, 0xaa, - 0xb1, 0xef, 0xda, 0xdd, 0x3d, 0x21, 0x6f, 0xbb, 0xfa, 0x23, 0xe7, 0xca, 0x9e, 0x32, 0x3d, 0x3f, 0xaf, 0xf5, 0x4a, - 0xed, 0x36, 0xd7, 0x6b, 0xd4, 0x4c, 0x7d, 0x94, 0xfd, 0xcd, 0x36, 0x16, 0x1e, 0xcd, 0x21, 0xf4, 0x19, 0x69, 0x31, - 0xf7, 0x38, 0xd7, 0x9b, 0x3d, 0x29, 0x0c, 0x8c, 0x98, 0x54, 0x32, 0x72, 0x7a, 0x81, 0x8b, 0x50, 0x85, 0x18, 0xd6, - 0xd2, 0xd5, 0x3e, 0xeb, 0xd2, 0x1b, 0xa8, 0x6b, 0x8a, 0x7d, 0x0d, 0x19, 0x78, 0xd1, 0xf4, 0x32, 0x18, 0x03, 0x72, - 0x04, 0xde, 0xf1, 0xd9, 0x12, 0x0e, 0xcc, 0x35, 0x40, 0xdf, 0x3c, 0xe8, 0xeb, 0x72, 0xcb, 0xd7, 0xaa, 0x6f, 0xa6, - 0xeb, 0x91, 0x52, 0x7e, 0xac, 0xf8, 0xed, 0xc5, 0x13, 0x76, 0xc3, 0x35, 0x2a, 0xca, 0x73, 0xbd, 0x58, 0xef, 0x80, - 0xab, 0xee, 0x39, 0xdc, 0x66, 0xf1, 0xd8, 0x95, 0x07, 0x2c, 0xdb, 0xb2, 0x7b, 0xf6, 0x86, 0x3d, 0x62, 0xef, 0xd9, - 0x27, 0xf6, 0x95, 0xd5, 0x08, 0x51, 0x5e, 0x2a, 0x29, 0xcf, 0x5f, 0xf0, 0x1b, 0x69, 0x7b, 0x94, 0xb0, 0x64, 0xf7, - 0xb6, 0x9d, 0x66, 0xb8, 0x61, 0x8f, 0xf8, 0x62, 0xb8, 0x62, 0x9f, 0x20, 0x1b, 0x0a, 0xc5, 0x83, 0x15, 0xab, 0xe1, - 0x0a, 0x4b, 0x19, 0xf4, 0x69, 0x58, 0x5a, 0xc2, 0xa2, 0x29, 0x14, 0xa5, 0xe8, 0x4f, 0xbc, 0x26, 0xec, 0xb4, 0x1a, - 0x0b, 0x91, 0x1f, 0x1a, 0xae, 0xd8, 0x3d, 0x5f, 0x0c, 0x56, 0xec, 0x91, 0xb6, 0x11, 0x0d, 0x36, 0x6e, 0x71, 0x04, - 0x66, 0xa5, 0x0b, 0x93, 0x02, 0xf5, 0xd6, 0xbe, 0x09, 0x6e, 0xd8, 0x1b, 0xac, 0xdf, 0x7b, 0x2c, 0x1a, 0x65, 0xfe, - 0xc1, 0x8a, 0x7d, 0xe5, 0x12, 0x43, 0xcd, 0x2d, 0x4f, 0x3a, 0x86, 0xea, 0x02, 0xe9, 0x8a, 0xf0, 0x9e, 0xd3, 0x8b, - 0xec, 0x2b, 0x96, 0x41, 0x5f, 0x19, 0xae, 0xd8, 0x16, 0x6b, 0xf7, 0xc6, 0x18, 0xb7, 0xac, 0xea, 0x49, 0x50, 0x60, - 0x94, 0x55, 0x4a, 0xcb, 0xc5, 0x11, 0xcb, 0xa6, 0x8e, 0x1a, 0xd4, 0x86, 0x01, 0x7d, 0x30, 0xfa, 0x8b, 0xaf, 0xdf, - 0x7d, 0xe7, 0x95, 0xfa, 0xe6, 0xfb, 0xdc, 0xf1, 0xae, 0x2c, 0xd1, 0xbb, 0xf2, 0x37, 0x5e, 0xce, 0x9e, 0xcf, 0x27, - 0xba, 0x96, 0xb4, 0xc9, 0x90, 0xbb, 0xe9, 0xec, 0x79, 0x87, 0xbf, 0xe5, 0x6f, 0xbe, 0xdf, 0x58, 0x7d, 0xac, 0xbe, - 0xab, 0xbb, 0xf7, 0x7e, 0xb0, 0x69, 0x9c, 0x8a, 0xef, 0x4e, 0x57, 0x1c, 0xdb, 0x59, 0x6b, 0xef, 0xcc, 0xff, 0xe1, - 0x5a, 0x6f, 0x71, 0xec, 0xde, 0xf0, 0xed, 0x70, 0x63, 0x0f, 0x83, 0xfc, 0xbe, 0x54, 0x1c, 0x67, 0x35, 0x7f, 0xe6, - 0x75, 0x4a, 0xb2, 0x80, 0x6a, 0xf4, 0xda, 0x48, 0x43, 0x97, 0xcc, 0xc4, 0x34, 0xc4, 0x17, 0x19, 0xa0, 0x73, 0x81, - 0x78, 0x76, 0xc7, 0xc7, 0x93, 0xbb, 0xab, 0x78, 0x72, 0x37, 0xe0, 0xaf, 0x4d, 0x0b, 0xda, 0x0b, 0xee, 0xce, 0x67, - 0xbf, 0xf1, 0xc2, 0x5e, 0x92, 0xcf, 0x7d, 0xf6, 0x56, 0xb8, 0xab, 0xf4, 0xb9, 0xcf, 0xbe, 0x0a, 0xfe, 0xdb, 0x48, - 0x93, 0x65, 0xb0, 0xaf, 0x35, 0xff, 0x6d, 0x84, 0xac, 0x1f, 0xec, 0xb3, 0xe0, 0x6f, 0xc1, 0xff, 0xbb, 0x4a, 0xd0, - 0x32, 0xfe, 0xb9, 0x56, 0x3f, 0xdf, 0xc9, 0xd8, 0x1c, 0x78, 0x13, 0x5a, 0x41, 0x6f, 0xde, 0xd4, 0xf2, 0x27, 0x71, - 0x71, 0xa4, 0xea, 0xa9, 0xe1, 0xa0, 0xc5, 0x62, 0x16, 0xf5, 0x51, 0x3a, 0x95, 0x37, 0xb9, 0xe6, 0xb1, 0xb4, 0x30, - 0xdf, 0x41, 0x38, 0xf0, 0xb5, 0x0d, 0x53, 0xb0, 0xe3, 0xb8, 0x19, 0x5c, 0x33, 0x80, 0x90, 0xcc, 0xa6, 0x5b, 0xfe, - 0x86, 0xbf, 0xe7, 0x5f, 0xf9, 0x2e, 0xb8, 0xe7, 0x8f, 0xf8, 0x27, 0x5e, 0xd7, 0x7c, 0xc7, 0x96, 0x12, 0xf2, 0xb4, - 0xde, 0x5e, 0x06, 0x5b, 0x56, 0xef, 0x2e, 0x83, 0x7b, 0x56, 0x6f, 0x9f, 0x04, 0x6f, 0x58, 0xbd, 0x7b, 0x12, 0x3c, - 0x62, 0xdb, 0xcb, 0xe0, 0x3d, 0xdb, 0x5d, 0x06, 0x9f, 0xd8, 0xf6, 0x49, 0xf0, 0x95, 0xed, 0x9e, 0x04, 0xb5, 0x42, - 0x7a, 0xf8, 0x2a, 0x24, 0xd3, 0xc9, 0xd7, 0x9a, 0x19, 0x56, 0xdd, 0xe0, 0xb3, 0xb0, 0x7e, 0x51, 0x2d, 0x83, 0xcf, - 0x35, 0xd3, 0x6d, 0x0e, 0x84, 0x60, 0xba, 0xc5, 0xc1, 0x0d, 0x3d, 0x31, 0xed, 0x0a, 0x52, 0xc1, 0xba, 0x5a, 0x1a, - 0x2c, 0xea, 0xa6, 0x75, 0x32, 0x3b, 0xde, 0x89, 0x71, 0x87, 0x77, 0xe2, 0x82, 0x2d, 0x9b, 0x4e, 0x57, 0x9d, 0xd3, - 0xe7, 0x81, 0x3e, 0x02, 0xf4, 0xde, 0x5f, 0x49, 0x0f, 0x9a, 0xa2, 0xe1, 0xb9, 0xd2, 0x1d, 0xb7, 0xf6, 0xfb, 0xd0, - 0xda, 0xef, 0x99, 0x54, 0xa4, 0x45, 0x2c, 0x2a, 0x8b, 0xaa, 0x42, 0x3e, 0xf1, 0x20, 0xd3, 0x5a, 0xb5, 0x84, 0x91, - 0x3a, 0x13, 0x30, 0xe9, 0x0b, 0x3a, 0x0c, 0x72, 0xb2, 0x2b, 0xb0, 0x25, 0xdf, 0x0c, 0x12, 0xb6, 0xe6, 0xf1, 0x74, - 0x98, 0x04, 0x4b, 0x76, 0xcb, 0x87, 0xdd, 0x62, 0xc1, 0x4a, 0x85, 0x31, 0xe9, 0xeb, 0xd3, 0xd1, 0xee, 0xce, 0x7b, - 0xab, 0x34, 0x8e, 0x33, 0x81, 0x3a, 0xb7, 0x4a, 0x6f, 0xf3, 0x5b, 0x67, 0x57, 0x5f, 0xab, 0x5d, 0x1e, 0x04, 0x86, - 0xdf, 0x80, 0x68, 0x87, 0x78, 0xef, 0xa0, 0xc6, 0x48, 0xb7, 0x64, 0xd6, 0x7d, 0x65, 0xef, 0xeb, 0x5b, 0xb3, 0x55, - 0xff, 0xa7, 0x45, 0xd0, 0x5e, 0x2e, 0x7b, 0xff, 0xb5, 0x79, 0xf5, 0xf7, 0x8e, 0x57, 0x37, 0xfe, 0xe4, 0x9e, 0xbf, - 0xc6, 0xe8, 0x04, 0x4c, 0x64, 0x3b, 0xfe, 0x7a, 0xb4, 0x6d, 0x9c, 0xf2, 0xe4, 0x5e, 0xfe, 0x7f, 0xa5, 0x40, 0x7b, - 0x37, 0xaf, 0xec, 0x4d, 0x71, 0xcb, 0x3b, 0xf6, 0xf2, 0xa5, 0xb5, 0x27, 0x1a, 0x84, 0x92, 0xd7, 0xdc, 0x0d, 0x8a, - 0x86, 0x3d, 0xf1, 0x39, 0xaf, 0x66, 0xaf, 0xe7, 0x93, 0x2d, 0x3f, 0xde, 0x11, 0x5f, 0x77, 0xec, 0x88, 0xcf, 0xfd, - 0xc1, 0xb2, 0xf9, 0x56, 0xaf, 0x76, 0xee, 0xe4, 0x4e, 0xa5, 0x77, 0xfc, 0x78, 0x1f, 0x1f, 0xfe, 0xc7, 0x95, 0xde, - 0x7d, 0x77, 0xa5, 0xed, 0x2a, 0x77, 0x77, 0xbe, 0xe9, 0xf8, 0x46, 0xd6, 0x1a, 0xc3, 0xcd, 0x8c, 0x82, 0x11, 0xa6, - 0x2d, 0x4c, 0xd3, 0x20, 0xb2, 0x14, 0x8b, 0x90, 0xa8, 0x51, 0x3a, 0x27, 0xfa, 0x2c, 0xe8, 0x14, 0x74, 0x71, 0xa3, - 0xbf, 0xe1, 0x63, 0xb6, 0x30, 0x2e, 0x9b, 0x37, 0x57, 0x8b, 0xc9, 0x60, 0x70, 0xe3, 0xef, 0xef, 0x78, 0x38, 0xbb, - 0x99, 0xb3, 0x6b, 0x7e, 0x47, 0xeb, 0x69, 0xa2, 0x1a, 0x5f, 0x3c, 0x24, 0x81, 0xdd, 0xf8, 0xfe, 0xc4, 0x22, 0x82, - 0xb5, 0x6f, 0x9c, 0x37, 0xfe, 0x40, 0x9a, 0xa5, 0xe5, 0xd6, 0xfe, 0xe8, 0x61, 0x0d, 0xc5, 0x0d, 0x08, 0x19, 0x8f, - 0x6c, 0x95, 0xc3, 0x27, 0xfe, 0xc1, 0xbb, 0xf6, 0xa7, 0xd7, 0x3a, 0xf8, 0x66, 0xa2, 0xce, 0xa5, 0x4f, 0x17, 0x4f, - 0xd8, 0x6f, 0xfc, 0xb5, 0x3c, 0x53, 0xde, 0x0a, 0x39, 0x6d, 0x3f, 0x22, 0x89, 0x13, 0x1d, 0x15, 0x5f, 0xdd, 0x44, - 0x02, 0x85, 0x80, 0x5d, 0xe1, 0x6b, 0xcd, 0xef, 0x27, 0xe5, 0xd4, 0xdb, 0x01, 0xc9, 0x2b, 0xb7, 0x15, 0xd1, 0x37, - 0x9c, 0xf3, 0xc5, 0xf0, 0x72, 0xfa, 0xb5, 0xdb, 0xb7, 0x47, 0x85, 0xb5, 0xa9, 0x88, 0xb7, 0x1b, 0x0c, 0xc2, 0x3a, - 0x99, 0x59, 0xe6, 0x92, 0x2f, 0x7d, 0xad, 0xcd, 0xdc, 0x63, 0x7a, 0xc7, 0x99, 0x66, 0xc8, 0xe8, 0x0b, 0xcc, 0x4c, - 0x87, 0xc3, 0xed, 0x39, 0x96, 0xc7, 0x87, 0x9f, 0x1e, 0xbf, 0x1f, 0xbc, 0xc7, 0x10, 0x2e, 0x2b, 0x2c, 0xe4, 0x2b, - 0x1f, 0x66, 0x75, 0xeb, 0xda, 0x71, 0xf1, 0x64, 0xf8, 0x1c, 0xf2, 0x06, 0x5d, 0x0f, 0x4d, 0x11, 0xad, 0xf2, 0x3b, - 0x8a, 0x3e, 0x51, 0x72, 0xd0, 0xf1, 0x04, 0x6a, 0x87, 0x5c, 0xb8, 0x5f, 0x1f, 0x73, 0x50, 0x74, 0x60, 0xa9, 0xfd, - 0xfe, 0xf9, 0x6b, 0x22, 0x94, 0x86, 0xf1, 0x7e, 0x1e, 0x46, 0x7f, 0xc6, 0x65, 0xb1, 0x86, 0x23, 0x76, 0x00, 0x9f, - 0x7b, 0xac, 0xaf, 0x61, 0xb7, 0xbe, 0xef, 0x07, 0xde, 0x96, 0xbf, 0x61, 0x5f, 0xb9, 0x77, 0x39, 0xfc, 0xe4, 0x3f, - 0x7e, 0x0f, 0xf2, 0x13, 0xe2, 0xa4, 0x60, 0x48, 0x6c, 0x47, 0x31, 0x6a, 0x1d, 0x7e, 0xae, 0x21, 0x56, 0xeb, 0x35, - 0x52, 0x77, 0x41, 0xfa, 0x7b, 0x85, 0xec, 0x27, 0x04, 0x56, 0x93, 0xf4, 0x29, 0x30, 0x89, 0x6f, 0x6a, 0x48, 0x20, - 0x4d, 0x0b, 0xc4, 0xe0, 0x40, 0xf1, 0xa9, 0xe0, 0x5f, 0x87, 0x9f, 0x49, 0xfe, 0x5b, 0xd4, 0x7c, 0x0c, 0x7f, 0xc3, - 0xd0, 0x4c, 0xaa, 0xfb, 0xb4, 0x86, 0x88, 0x68, 0x38, 0xf5, 0xc2, 0x4a, 0xa8, 0x93, 0x21, 0x48, 0xc5, 0x90, 0x0b, - 0x71, 0xf1, 0x64, 0x72, 0x53, 0x8a, 0xf0, 0xcf, 0x09, 0x3e, 0x93, 0x2b, 0x4d, 0x3e, 0xa3, 0x27, 0x8d, 0x2c, 0xe0, - 0x5e, 0xbe, 0x2f, 0x7b, 0x35, 0x58, 0xd4, 0x43, 0x7e, 0x53, 0xbb, 0xef, 0xcb, 0x39, 0x41, 0x8f, 0xec, 0x07, 0x34, - 0x07, 0x03, 0x35, 0x03, 0x29, 0x43, 0x70, 0x03, 0x97, 0x7e, 0x4f, 0x15, 0xe4, 0xcb, 0xef, 0x7d, 0x16, 0x32, 0x70, - 0x65, 0x41, 0x98, 0x72, 0xa9, 0x90, 0x02, 0xc7, 0x4d, 0x3d, 0xf8, 0xac, 0xd1, 0x49, 0x24, 0xf8, 0x94, 0x80, 0x24, - 0x69, 0x79, 0x20, 0x69, 0xc4, 0x74, 0x20, 0x2e, 0x94, 0xa6, 0x59, 0x49, 0x11, 0x87, 0xd8, 0x55, 0xaf, 0x91, 0xf0, - 0x2c, 0x78, 0xc4, 0x60, 0xed, 0x48, 0xd1, 0xe2, 0xab, 0x31, 0x1d, 0xeb, 0xb0, 0xa1, 0x5b, 0x59, 0xdc, 0x6f, 0x92, - 0x3a, 0x8d, 0xc4, 0x95, 0xb7, 0x42, 0xfe, 0xfc, 0x97, 0x12, 0x81, 0xf4, 0xae, 0x06, 0x62, 0x10, 0xfc, 0x00, 0xfd, - 0x07, 0x2c, 0x72, 0x10, 0x94, 0xea, 0x32, 0xcc, 0xab, 0x8c, 0x0a, 0x9c, 0xed, 0xd8, 0x76, 0xce, 0x54, 0xdd, 0x82, - 0xcf, 0xc2, 0x30, 0xa4, 0x9d, 0xad, 0x9a, 0x93, 0x5b, 0xbd, 0x81, 0x7a, 0x26, 0x71, 0xa4, 0x96, 0xe2, 0x48, 0x5b, - 0x73, 0x9f, 0x2e, 0xbd, 0x6e, 0x79, 0x41, 0xc3, 0x05, 0xe8, 0x45, 0xe9, 0xae, 0xf3, 0x09, 0x85, 0x2e, 0xab, 0x71, - 0x35, 0x14, 0x75, 0x28, 0xc7, 0x58, 0xfb, 0x73, 0x25, 0xcf, 0xef, 0xc0, 0x7a, 0x84, 0x86, 0xaf, 0x4a, 0x1d, 0xc4, - 0xf6, 0x13, 0xbd, 0xeb, 0x54, 0xea, 0x6f, 0x00, 0x18, 0x38, 0x75, 0x3c, 0xd4, 0x47, 0xed, 0x14, 0xb2, 0x9d, 0x7b, - 0x4b, 0x8c, 0xca, 0x95, 0xf0, 0x54, 0x69, 0x79, 0x4a, 0x59, 0xf5, 0xb5, 0xe0, 0x56, 0x76, 0x9f, 0x0d, 0x20, 0xa3, - 0x0d, 0x0a, 0xe4, 0x19, 0xb5, 0x35, 0x1e, 0xa4, 0x9a, 0x66, 0x89, 0x63, 0xf8, 0xa0, 0x48, 0xb3, 0x0a, 0x2c, 0x5e, - 0xe6, 0x92, 0x39, 0x28, 0x58, 0xae, 0x37, 0x9b, 0x69, 0xa6, 0xfa, 0x22, 0xb7, 0x37, 0x1a, 0x2f, 0xd3, 0x7f, 0xb3, - 0x64, 0xc0, 0xa3, 0x8b, 0x27, 0x7e, 0x00, 0x69, 0x92, 0xe2, 0x01, 0x92, 0x60, 0x7b, 0xb0, 0x8b, 0x1d, 0x86, 0xad, - 0x62, 0x65, 0x4f, 0x9e, 0x2e, 0x77, 0x68, 0xca, 0x25, 0xb8, 0xe4, 0xc4, 0x5c, 0x4e, 0x7d, 0x5f, 0xb2, 0xde, 0x50, - 0x9c, 0xb2, 0x69, 0x02, 0x4a, 0x02, 0xed, 0x16, 0xfc, 0x17, 0x3e, 0x35, 0x74, 0x5a, 0x80, 0xa5, 0xb6, 0x1b, 0xf0, - 0x5f, 0xe8, 0x17, 0xdb, 0x5d, 0xd4, 0x0f, 0xcc, 0x83, 0xbd, 0x59, 0x5c, 0x19, 0x03, 0x4e, 0x12, 0x57, 0x9a, 0x47, - 0xae, 0x1f, 0x14, 0x7d, 0xba, 0xac, 0x1d, 0x38, 0x53, 0x5c, 0x58, 0xa5, 0x36, 0x49, 0xaf, 0xfd, 0x96, 0x9a, 0x78, - 0x13, 0x25, 0x55, 0x61, 0x3b, 0xa4, 0xfd, 0x4b, 0xca, 0x99, 0x2a, 0xee, 0x10, 0x3d, 0xd9, 0x4d, 0x5c, 0x05, 0x5e, - 0x58, 0x55, 0x6c, 0x84, 0xda, 0x8c, 0x2c, 0x27, 0x70, 0xba, 0xc7, 0xea, 0x82, 0x8f, 0xed, 0x6a, 0x76, 0xc1, 0x4a, - 0xb6, 0x66, 0xd2, 0x7d, 0xde, 0x8e, 0xb9, 0x90, 0x57, 0x7a, 0x59, 0xb4, 0x02, 0xda, 0x83, 0xc0, 0xe1, 0xe7, 0x9a, - 0xee, 0xd1, 0xb3, 0xcd, 0x36, 0xb5, 0xd9, 0xd8, 0x5a, 0x84, 0x90, 0x81, 0x68, 0xe8, 0x0b, 0x39, 0xa3, 0xc8, 0x57, - 0x69, 0xb9, 0x56, 0x1b, 0xab, 0x8c, 0x17, 0x98, 0x08, 0x32, 0x9c, 0x85, 0x77, 0xe8, 0x69, 0x3d, 0xd2, 0x14, 0x93, - 0xe0, 0xa4, 0x8b, 0xbf, 0x00, 0x1b, 0xca, 0x93, 0xdc, 0x1c, 0x90, 0x03, 0xa8, 0x5c, 0x8a, 0x52, 0x29, 0x83, 0x5f, - 0xab, 0x3b, 0xb2, 0xad, 0xfa, 0xef, 0x34, 0x90, 0xc1, 0x1d, 0xe8, 0xdb, 0x5e, 0x68, 0xed, 0x68, 0xe7, 0xca, 0xd6, - 0xb4, 0x2d, 0xd3, 0x3c, 0x46, 0x16, 0x1b, 0x40, 0x3e, 0x91, 0xce, 0x81, 0xc8, 0x6b, 0xa2, 0xf1, 0xce, 0x9e, 0xf2, - 0xf1, 0x54, 0x3c, 0x24, 0xef, 0x55, 0xbe, 0x6f, 0xee, 0xf5, 0xc1, 0x18, 0xfb, 0x16, 0x94, 0x89, 0x0f, 0x56, 0x5b, - 0xeb, 0x12, 0xeb, 0xad, 0xd2, 0x24, 0xba, 0xe1, 0x0a, 0x3a, 0x8e, 0xc4, 0x0d, 0x62, 0x70, 0xcc, 0x78, 0x6d, 0x95, - 0xa5, 0xaf, 0xb0, 0xcc, 0x75, 0xcc, 0x92, 0x21, 0x93, 0x3a, 0x4f, 0x14, 0x3c, 0xf9, 0x79, 0x42, 0x32, 0x22, 0x6a, - 0xb6, 0xe5, 0x28, 0xe5, 0xa6, 0x05, 0x5c, 0x66, 0x64, 0x00, 0xdf, 0xa4, 0x09, 0x40, 0xb9, 0x7c, 0x09, 0x52, 0x69, - 0x88, 0xe0, 0x9a, 0xed, 0x25, 0xa3, 0x1b, 0x47, 0xeb, 0xa0, 0x4a, 0x32, 0x77, 0x70, 0x6e, 0x67, 0x91, 0x52, 0x6f, - 0x3e, 0xc2, 0xb0, 0x93, 0xf7, 0x61, 0x9d, 0xe0, 0xb7, 0x01, 0x35, 0xe9, 0x53, 0xe1, 0x45, 0x23, 0x40, 0x53, 0xdf, - 0xa9, 0x32, 0x3e, 0x15, 0x5e, 0x36, 0xda, 0xb2, 0x8c, 0x52, 0xa8, 0x2e, 0x98, 0xdd, 0x9a, 0x2e, 0xc4, 0xbc, 0xaa, - 0x06, 0xda, 0x20, 0xb7, 0xeb, 0x98, 0x01, 0x8d, 0xda, 0xae, 0x3c, 0xb2, 0x00, 0xb7, 0x66, 0x22, 0x30, 0x72, 0xfe, - 0x5d, 0x7e, 0xad, 0xc2, 0x79, 0xfa, 0xfd, 0xd0, 0xdb, 0x6f, 0x83, 0x68, 0xb4, 0xbd, 0x64, 0xbb, 0x20, 0x1a, 0xed, - 0x2e, 0x1b, 0x46, 0xbf, 0x9f, 0xd0, 0xef, 0x27, 0x0d, 0xa8, 0x4a, 0x84, 0x89, 0xb8, 0xd7, 0x6f, 0xd4, 0xf2, 0x95, - 0x5a, 0xbf, 0x53, 0xcb, 0x97, 0x6a, 0x78, 0x6b, 0x4f, 0x22, 0x41, 0x64, 0x69, 0x6c, 0xee, 0x25, 0x5b, 0xaa, 0xa5, - 0xd2, 0x31, 0xaa, 0x8c, 0xa8, 0xa5, 0xb3, 0x39, 0x56, 0x8c, 0xb4, 0x73, 0x50, 0x32, 0x20, 0xd3, 0xe2, 0xaa, 0xc6, - 0x74, 0xb3, 0xa2, 0x25, 0x26, 0x23, 0xac, 0x6c, 0xcb, 0xdb, 0x4d, 0xaa, 0xa6, 0x73, 0x72, 0x73, 0xab, 0x94, 0x9b, - 0x5b, 0xc1, 0xf3, 0x6f, 0xe8, 0x96, 0x4b, 0xae, 0xbd, 0xcc, 0xa6, 0x85, 0xd2, 0x2d, 0xe3, 0x1a, 0x6c, 0xed, 0x9b, - 0x40, 0x96, 0xf9, 0x40, 0x51, 0x63, 0x7b, 0xd1, 0x28, 0xdf, 0x20, 0x5b, 0x11, 0xa3, 0x4e, 0x59, 0x30, 0xfe, 0x76, - 0x47, 0x0f, 0x64, 0xa0, 0xaa, 0xaa, 0x8d, 0x83, 0x3b, 0x2b, 0xfd, 0x61, 0x79, 0xf1, 0x84, 0x25, 0x56, 0x3a, 0xb9, - 0x50, 0x85, 0xfe, 0x20, 0x44, 0x37, 0x95, 0x0d, 0x07, 0x87, 0xba, 0xd8, 0xca, 0x80, 0xd0, 0xc3, 0xf4, 0xde, 0xc6, - 0x4a, 0x96, 0xbb, 0xa6, 0x7c, 0x31, 0xe3, 0x09, 0xc7, 0xd1, 0x97, 0xab, 0x45, 0x58, 0xab, 0x45, 0x76, 0x02, 0x3c, - 0xb4, 0x56, 0x4b, 0x21, 0x57, 0x8b, 0x70, 0x66, 0xba, 0x50, 0x33, 0x3d, 0x03, 0x05, 0xa4, 0x50, 0xb3, 0x3c, 0x01, - 0x58, 0x78, 0x61, 0x66, 0xb8, 0x30, 0x33, 0x1c, 0x87, 0xd4, 0xf8, 0x3f, 0xe8, 0xbd, 0xce, 0x3d, 0xb7, 0xdc, 0x8d, - 0x4e, 0x23, 0xbe, 0x1d, 0x6d, 0x30, 0xc7, 0x07, 0xe1, 0xa4, 0xea, 0xf7, 0xd3, 0x12, 0xb1, 0x7a, 0x0c, 0x8c, 0xa0, - 0x1c, 0x2a, 0x47, 0xfb, 0x65, 0x61, 0x49, 0x96, 0x84, 0x25, 0xb9, 0x57, 0xe3, 0x5c, 0x5a, 0x2e, 0x5e, 0x25, 0x81, - 0x48, 0x64, 0xbc, 0x94, 0x26, 0xf8, 0x84, 0x97, 0x23, 0x23, 0x35, 0x4f, 0x16, 0xa9, 0x97, 0xb3, 0x8c, 0x8d, 0x11, - 0xc3, 0x28, 0xf4, 0x9b, 0xaa, 0xdf, 0xcf, 0x4b, 0x2f, 0xa7, 0x76, 0x7e, 0x02, 0xd7, 0xcb, 0x53, 0x67, 0x91, 0x23, - 0xe4, 0xd5, 0x48, 0x2a, 0x2c, 0xaf, 0x95, 0x7a, 0xfa, 0x12, 0x7c, 0x50, 0x77, 0x6f, 0x14, 0x00, 0x71, 0x91, 0x4b, - 0xff, 0xda, 0x12, 0x2e, 0x4d, 0xb9, 0x81, 0x41, 0x0f, 0x79, 0x4e, 0x42, 0xa8, 0x04, 0x21, 0x29, 0xac, 0x1b, 0xf7, - 0xc5, 0x93, 0x89, 0xeb, 0xce, 0x62, 0x03, 0x13, 0x1c, 0x0e, 0x80, 0x78, 0x30, 0xf5, 0xa2, 0x01, 0x2f, 0xd5, 0x9c, - 0xf9, 0xe0, 0xe5, 0x04, 0x93, 0x01, 0xaa, 0x8a, 0x81, 0x53, 0xd6, 0x63, 0xf9, 0xc8, 0xb8, 0x99, 0xf9, 0x7e, 0x80, - 0xef, 0xd6, 0x85, 0x44, 0x7f, 0x50, 0x00, 0x05, 0x99, 0x02, 0x28, 0x48, 0x0c, 0x40, 0x41, 0x6c, 0x00, 0x0a, 0x36, - 0x0d, 0x5f, 0x49, 0x1d, 0x6e, 0x04, 0x74, 0x11, 0x3e, 0xf4, 0x2c, 0x6c, 0xac, 0x50, 0x3c, 0x1b, 0xb3, 0x31, 0x2b, - 0xd4, 0xce, 0x93, 0xcb, 0xa9, 0xd8, 0x59, 0x8c, 0x75, 0x15, 0xb9, 0x4d, 0xbc, 0x90, 0x50, 0xe4, 0x9c, 0x1b, 0x89, - 0xba, 0xfb, 0xb9, 0xf7, 0x92, 0x8c, 0x25, 0xf3, 0x86, 0x46, 0x0d, 0xe6, 0x65, 0xd7, 0x01, 0x4c, 0x4b, 0xbe, 0x2d, - 0x68, 0x30, 0x9d, 0x2a, 0x8f, 0x48, 0x93, 0xa0, 0x76, 0x2e, 0x93, 0x22, 0x27, 0x84, 0x49, 0xd0, 0x2b, 0xc1, 0x6f, - 0x24, 0xca, 0xff, 0x37, 0x9d, 0xe0, 0x01, 0x8e, 0x89, 0x56, 0xc9, 0x57, 0x30, 0x60, 0xe6, 0xfc, 0x99, 0x74, 0xca, - 0x46, 0x28, 0xc6, 0x32, 0x8d, 0x47, 0x5f, 0xd9, 0x10, 0xa1, 0xad, 0x9e, 0xa1, 0x89, 0x09, 0xea, 0x00, 0x8f, 0xe8, - 0xaf, 0xd1, 0x57, 0x43, 0xa1, 0xd2, 0xd5, 0x48, 0x5d, 0xb3, 0x73, 0xce, 0xdf, 0xd6, 0x86, 0x13, 0x19, 0xd3, 0xa6, - 0xc0, 0x37, 0x20, 0x90, 0x6f, 0x20, 0x00, 0x5c, 0x35, 0x9d, 0xd9, 0x2b, 0x80, 0x73, 0x20, 0x80, 0xc7, 0x79, 0xc7, - 0xe3, 0x07, 0xfa, 0xab, 0x38, 0xee, 0x9d, 0xa6, 0x61, 0xfb, 0xaf, 0xc0, 0x58, 0x0c, 0xe5, 0x78, 0xbe, 0x53, 0x90, - 0xec, 0x51, 0xca, 0xd2, 0x55, 0x13, 0xd9, 0xa1, 0x58, 0x9f, 0xe6, 0x94, 0xb1, 0xb4, 0x2d, 0xc7, 0x68, 0xe3, 0xf5, - 0x43, 0x3c, 0xbe, 0xb9, 0xd1, 0x93, 0x0f, 0x7a, 0x70, 0x7b, 0x7b, 0xf5, 0xa2, 0xc7, 0x6c, 0xbe, 0x15, 0x8b, 0x67, - 0x45, 0x9c, 0x38, 0xad, 0x43, 0x0e, 0x70, 0x90, 0x93, 0x10, 0x48, 0xc7, 0xb8, 0xd4, 0xa2, 0x83, 0x9a, 0xe5, 0xbc, - 0x06, 0x96, 0x59, 0x04, 0xd9, 0x00, 0x51, 0x4d, 0x53, 0xb1, 0x1a, 0x1e, 0x94, 0xaa, 0x39, 0xa5, 0x52, 0xfb, 0x86, - 0xb3, 0xd5, 0xe9, 0x13, 0xab, 0x36, 0xe1, 0xd6, 0xbf, 0xd5, 0x9e, 0xa0, 0xad, 0xa4, 0x81, 0x50, 0xcf, 0x17, 0xe9, - 0x2d, 0x45, 0xf1, 0x38, 0x33, 0xf1, 0x54, 0x05, 0xc6, 0xbe, 0xb5, 0x23, 0x28, 0x48, 0x9a, 0xae, 0x03, 0x0e, 0xd3, - 0xe8, 0x84, 0xc5, 0x3f, 0xa5, 0x0f, 0xe5, 0x45, 0xad, 0xc0, 0x49, 0xfe, 0x29, 0x5c, 0x44, 0x12, 0x0b, 0xfd, 0x92, - 0x00, 0x48, 0x64, 0xf0, 0x6a, 0x54, 0xac, 0x85, 0x0a, 0x90, 0x53, 0x94, 0xde, 0x2a, 0x3e, 0x2e, 0x45, 0xa9, 0x52, - 0x2a, 0x73, 0xa3, 0x52, 0x40, 0x58, 0x1b, 0x38, 0xba, 0x80, 0x2f, 0x20, 0x68, 0x2d, 0x77, 0x6b, 0xdb, 0xf3, 0x46, - 0xe6, 0x33, 0xd3, 0x3c, 0xad, 0xde, 0xab, 0xbf, 0xdf, 0x2d, 0x31, 0xcc, 0xc6, 0xd3, 0xdf, 0xb7, 0x19, 0xc2, 0xcd, - 0xdf, 0x30, 0x44, 0xb7, 0x00, 0x8e, 0x59, 0xda, 0x43, 0x21, 0x0b, 0x26, 0x58, 0x43, 0x55, 0x9e, 0xf2, 0xd9, 0xcb, - 0x27, 0x3b, 0x40, 0x53, 0x43, 0x17, 0x37, 0x3a, 0xd5, 0x55, 0x09, 0xc2, 0xf7, 0x5d, 0xa1, 0x1e, 0x9b, 0x03, 0x4e, - 0x0d, 0x00, 0xc5, 0x22, 0xaf, 0xf5, 0xd8, 0xfe, 0x41, 0x6f, 0xd4, 0x1b, 0x20, 0x9e, 0xce, 0x79, 0xe1, 0x1f, 0xd1, - 0xaf, 0x53, 0x7f, 0xc6, 0x85, 0x20, 0xea, 0xf5, 0x24, 0xbc, 0x13, 0x67, 0x69, 0x1c, 0x9c, 0xf5, 0x06, 0xe6, 0x22, - 0x50, 0x9c, 0xa5, 0xf9, 0x19, 0x88, 0xe5, 0x08, 0x8f, 0x58, 0xb3, 0x1b, 0x40, 0x0c, 0x2c, 0x75, 0x48, 0xb2, 0xea, - 0xd8, 0x7e, 0xff, 0xe5, 0xc8, 0xf0, 0xa6, 0x23, 0x22, 0x8c, 0xfe, 0x5d, 0x81, 0x00, 0x05, 0xcb, 0xcc, 0x76, 0x66, - 0xd2, 0xd5, 0x9e, 0xd5, 0xf3, 0x66, 0x93, 0x77, 0xf5, 0x8e, 0xd5, 0xb4, 0x9c, 0x9a, 0x56, 0x59, 0x4d, 0x9b, 0xe4, - 0x50, 0x33, 0xd1, 0xef, 0x6b, 0x7c, 0xd4, 0x7c, 0x0e, 0xb8, 0x6c, 0x98, 0xfc, 0x72, 0x56, 0xcd, 0xfb, 0x7d, 0x4f, - 0x3e, 0x82, 0x5f, 0x48, 0x5c, 0xe6, 0xd6, 0x58, 0x3e, 0x7d, 0x45, 0x7c, 0x66, 0x06, 0xf1, 0xe8, 0xe6, 0x08, 0xea, - 0xeb, 0xa3, 0xf0, 0x3a, 0xe6, 0x0a, 0x9b, 0x89, 0xe9, 0x4b, 0x18, 0x3c, 0x4f, 0xf8, 0xe0, 0x2d, 0x47, 0x7f, 0x23, - 0x9d, 0x99, 0x82, 0x85, 0x9c, 0xfb, 0x93, 0x97, 0x08, 0x9d, 0x8c, 0x48, 0x0f, 0x3a, 0x9d, 0xa0, 0x21, 0xfb, 0xfd, - 0x05, 0x74, 0x66, 0x2b, 0x95, 0xb2, 0x55, 0x51, 0x99, 0xae, 0xeb, 0xa2, 0xac, 0xa0, 0x63, 0xe9, 0xe7, 0x8d, 0x90, - 0x99, 0xf5, 0x33, 0x0b, 0xf9, 0x69, 0x21, 0xb1, 0xa6, 0x6c, 0xfb, 0x44, 0x6d, 0x90, 0x66, 0x5d, 0xa8, 0x2e, 0x70, - 0xee, 0xac, 0xbd, 0xde, 0x08, 0xf5, 0xcf, 0xf9, 0x68, 0x5d, 0xac, 0x3d, 0x70, 0x89, 0x99, 0xa5, 0x73, 0xc5, 0xa1, - 0x91, 0xfb, 0xa3, 0xcf, 0x45, 0x9a, 0x53, 0x1e, 0xa0, 0x41, 0x14, 0x73, 0xfb, 0x2d, 0x90, 0x7e, 0xe8, 0x2d, 0x90, - 0x7d, 0x74, 0xce, 0xc9, 0x4b, 0x00, 0xa7, 0x43, 0x44, 0xdc, 0x8a, 0x04, 0x1d, 0xab, 0x86, 0x3b, 0x0b, 0xf7, 0xb4, - 0x97, 0xc6, 0xbd, 0x34, 0x3f, 0x4b, 0xfb, 0x7d, 0x03, 0xa0, 0x99, 0x22, 0x32, 0x3c, 0xce, 0xc8, 0x6d, 0xd2, 0x42, - 0x30, 0xa5, 0xfd, 0x57, 0x63, 0x48, 0x10, 0x08, 0xf8, 0x3f, 0x85, 0xf7, 0x1e, 0xd0, 0x36, 0x69, 0x03, 0xae, 0x7a, - 0x4c, 0x07, 0x66, 0x4b, 0xce, 0x56, 0x9d, 0x0d, 0x40, 0x39, 0x55, 0x5a, 0x4f, 0x79, 0x5c, 0x53, 0x44, 0xa4, 0xca, - 0x42, 0xfd, 0xc6, 0x7a, 0x32, 0x59, 0xe5, 0x22, 0x43, 0x8e, 0xca, 0xf4, 0xb6, 0x66, 0x84, 0xd8, 0xa5, 0x9f, 0x2f, - 0x60, 0xc9, 0xc6, 0x1f, 0x70, 0xf2, 0x96, 0x00, 0x69, 0x3b, 0x6b, 0x57, 0xd5, 0x2e, 0xc7, 0xad, 0xdd, 0x1c, 0x90, - 0x7c, 0xbd, 0xd1, 0x68, 0xa4, 0xfd, 0xe4, 0x04, 0x0c, 0x55, 0x4f, 0x2d, 0x85, 0x1e, 0xab, 0x15, 0xb6, 0x6e, 0x47, - 0x2e, 0xb3, 0x64, 0x30, 0x5f, 0x18, 0xc7, 0xd7, 0xe6, 0xa3, 0x0f, 0x97, 0xca, 0xda, 0x75, 0xc4, 0xd7, 0x7f, 0x92, - 0xd5, 0xfa, 0x9e, 0x77, 0x55, 0x13, 0xf0, 0x45, 0x15, 0x5b, 0xfa, 0x1d, 0xef, 0xc9, 0xde, 0xc5, 0xd7, 0x3e, 0x62, - 0x97, 0x7c, 0xcf, 0x5b, 0xd4, 0x79, 0xbe, 0xf2, 0x75, 0xa3, 0x4a, 0xb7, 0xf7, 0x92, 0x05, 0xae, 0xbd, 0xa3, 0xa6, - 0xb1, 0x9e, 0xf9, 0xd1, 0xc3, 0x22, 0x64, 0x3b, 0x1f, 0x7a, 0x5f, 0x35, 0x4f, 0xcf, 0x1a, 0x7a, 0x93, 0x1a, 0xfa, - 0xd0, 0x8b, 0xb2, 0x7d, 0x6a, 0x1a, 0xd1, 0x6b, 0xd8, 0xd0, 0x87, 0xde, 0x92, 0x93, 0x43, 0x82, 0xc1, 0xa9, 0x31, - 0x7f, 0x78, 0x38, 0x9d, 0xe1, 0xef, 0x18, 0x50, 0x89, 0xc9, 0x7c, 0x7a, 0x4c, 0x3b, 0x0a, 0x30, 0xa3, 0x4a, 0x6f, - 0x9f, 0x1e, 0xd8, 0x8e, 0x97, 0xf5, 0xd0, 0xd2, 0xbb, 0x27, 0x47, 0xb7, 0xe3, 0x55, 0x35, 0xbe, 0x94, 0x43, 0x9e, - 0xe7, 0xb3, 0xd1, 0x68, 0x24, 0x0c, 0x3a, 0x77, 0xa5, 0x37, 0xb0, 0x02, 0x19, 0x5c, 0x54, 0x1f, 0xca, 0xa5, 0xb7, - 0x53, 0x87, 0x76, 0xe5, 0x4f, 0xf2, 0xc3, 0xa1, 0x18, 0x99, 0x63, 0x1c, 0x70, 0x4e, 0x0a, 0x25, 0x47, 0xc9, 0x5a, - 0x82, 0xe8, 0x94, 0xc6, 0x53, 0x59, 0xaf, 0xad, 0x88, 0xbc, 0x1a, 0x21, 0x1f, 0x82, 0x9f, 0x3d, 0x50, 0x8b, 0x3f, - 0xd5, 0x82, 0xd8, 0x43, 0x9f, 0x2a, 0xa5, 0x43, 0xbc, 0x2a, 0x20, 0x44, 0x18, 0xf0, 0x06, 0xda, 0x41, 0x09, 0x0e, - 0x3b, 0xdc, 0x7b, 0x44, 0x88, 0x7e, 0xe1, 0xe5, 0x33, 0x19, 0xae, 0xdc, 0x1b, 0x54, 0x73, 0x06, 0x88, 0x95, 0x3e, - 0x03, 0x17, 0x4c, 0x40, 0x3d, 0xc5, 0xa7, 0xe8, 0x5f, 0x6f, 0x1e, 0x36, 0x5d, 0x9f, 0x96, 0x80, 0x8a, 0xe8, 0xd9, - 0xcf, 0xc7, 0x00, 0xde, 0xd9, 0xb5, 0x19, 0x69, 0x2f, 0x7f, 0x03, 0x0c, 0x2b, 0x25, 0x89, 0x76, 0x4e, 0x89, 0xc0, - 0x9d, 0x8f, 0x6c, 0xe9, 0x47, 0x29, 0x10, 0x73, 0xc7, 0x93, 0x44, 0xf6, 0x60, 0x23, 0x27, 0x70, 0x8b, 0x01, 0x8f, - 0x0e, 0x40, 0xe5, 0x4a, 0x41, 0xee, 0x35, 0x47, 0x72, 0xc7, 0x8f, 0xbd, 0x1f, 0x07, 0xf5, 0xe0, 0xc7, 0xde, 0x59, - 0x4a, 0x72, 0x47, 0x78, 0xa6, 0xa6, 0x84, 0x88, 0xcf, 0x7e, 0x1c, 0xe4, 0x03, 0x3c, 0x4b, 0xb4, 0x48, 0x8b, 0xdc, - 0x6a, 0xa2, 0xc6, 0x4d, 0x78, 0x9b, 0x48, 0x1a, 0xa2, 0xbb, 0xce, 0x23, 0x62, 0x01, 0x20, 0x59, 0x7c, 0x36, 0x6f, - 0x28, 0xea, 0xdd, 0x84, 0x6f, 0xd1, 0x5d, 0x16, 0xfb, 0xfd, 0x55, 0x9e, 0xd6, 0x3d, 0x1d, 0x2a, 0x83, 0x2f, 0x48, - 0x35, 0x01, 0x1e, 0xed, 0x2f, 0xcc, 0xf1, 0xea, 0xd5, 0xe6, 0x48, 0x59, 0xa8, 0x12, 0xf5, 0x5b, 0xac, 0x66, 0x3d, - 0x44, 0xe4, 0xce, 0x32, 0x63, 0x6f, 0x2f, 0x78, 0x25, 0x67, 0x55, 0x6c, 0x97, 0xe3, 0x2b, 0xc2, 0xda, 0x4a, 0x02, - 0x74, 0xb4, 0x1e, 0x6b, 0x53, 0x8c, 0xfc, 0x4a, 0x21, 0x01, 0x17, 0x1d, 0x5b, 0x0b, 0xc5, 0xc6, 0x0b, 0xd0, 0x97, - 0xec, 0x4c, 0x03, 0xac, 0x37, 0x7a, 0x15, 0x71, 0x5b, 0x3e, 0x50, 0xe1, 0x4d, 0x6e, 0xaa, 0xcc, 0xca, 0x66, 0xd1, - 0xee, 0xa7, 0x8a, 0x57, 0x88, 0x5b, 0x6f, 0xd4, 0x1e, 0x05, 0xa8, 0x3d, 0xb4, 0x50, 0x06, 0xe8, 0xd2, 0x34, 0x03, - 0x40, 0x06, 0x00, 0x99, 0x2a, 0xe2, 0x33, 0x01, 0x2a, 0x6d, 0x75, 0xa3, 0xc0, 0x89, 0xf4, 0x02, 0x18, 0x17, 0x58, - 0xe9, 0x23, 0x1b, 0x19, 0x2c, 0xb6, 0x08, 0x70, 0xcb, 0x91, 0x3e, 0x4c, 0xc3, 0xc9, 0x36, 0x9a, 0xc3, 0x24, 0xcd, - 0xef, 0xc2, 0x2c, 0x95, 0xd0, 0x12, 0xaf, 0x64, 0x8d, 0x11, 0x0b, 0x48, 0xdf, 0xa7, 0x17, 0x45, 0x16, 0x13, 0x24, - 0x9c, 0xf5, 0xd4, 0x01, 0x54, 0x93, 0x73, 0xad, 0x69, 0xf5, 0xac, 0x36, 0x79, 0xc8, 0x02, 0x9d, 0x3d, 0x18, 0x93, - 0x5a, 0x6e, 0xe8, 0x91, 0xfd, 0x95, 0xe3, 0x19, 0xe1, 0xbb, 0x9e, 0xe1, 0xd4, 0x7f, 0x1f, 0x6b, 0x20, 0x65, 0x4a, - 0x00, 0x41, 0x06, 0x47, 0x13, 0x42, 0x79, 0x3a, 0x26, 0x53, 0x9b, 0x1f, 0x81, 0x70, 0x44, 0xf0, 0x0a, 0x9e, 0x1b, - 0x5a, 0xb7, 0xdc, 0xd8, 0x59, 0xe4, 0x69, 0x02, 0xc8, 0xe2, 0x05, 0xbf, 0x07, 0x64, 0x4e, 0xbd, 0x2a, 0x64, 0xcf, - 0x9e, 0x8b, 0xe9, 0x6c, 0x1e, 0x7c, 0x4c, 0x68, 0xff, 0x62, 0xc2, 0x6f, 0xba, 0xab, 0xe4, 0xca, 0xd4, 0xba, 0x37, - 0xd1, 0x63, 0x2e, 0x77, 0xfa, 0xb4, 0xe2, 0x18, 0xf1, 0x0c, 0x56, 0x01, 0x39, 0x67, 0x43, 0xfe, 0xf4, 0x1c, 0xb0, - 0x5b, 0x56, 0xc2, 0x8b, 0xf8, 0xd3, 0x50, 0x56, 0x0b, 0x90, 0x1f, 0x39, 0x8f, 0xcc, 0x2f, 0x5f, 0x6d, 0x87, 0x72, - 0x4e, 0x51, 0x44, 0xcb, 0xa9, 0x69, 0x49, 0x21, 0x3b, 0xf4, 0x14, 0x4c, 0xa6, 0xb6, 0xfc, 0x7d, 0x9f, 0xb8, 0x24, - 0xdf, 0x4c, 0x22, 0xfb, 0x3a, 0xc0, 0x9a, 0xb5, 0xea, 0x1e, 0xba, 0x21, 0x18, 0x20, 0x32, 0x42, 0x99, 0xcd, 0xf5, - 0xdd, 0x7a, 0x30, 0x50, 0x30, 0xbf, 0x82, 0x6e, 0x5a, 0x74, 0x8a, 0x03, 0xe4, 0xac, 0x75, 0x8d, 0x4a, 0x55, 0x71, - 0xe8, 0x30, 0xef, 0x96, 0x55, 0xd9, 0x65, 0xe9, 0x85, 0x20, 0x35, 0xea, 0x2a, 0x58, 0xa4, 0x54, 0x44, 0xf1, 0x9e, - 0xfc, 0x1a, 0x98, 0x78, 0x66, 0xe5, 0x28, 0x8d, 0xe7, 0x80, 0x18, 0xa4, 0x80, 0x38, 0xe5, 0x57, 0x80, 0x26, 0xba, - 0x88, 0xc2, 0xec, 0x55, 0x5c, 0x05, 0xb5, 0xd5, 0xf4, 0x3f, 0x1d, 0xc8, 0xd8, 0xf3, 0xba, 0xdf, 0x4f, 0x89, 0xd1, - 0x0f, 0xa3, 0x30, 0xf0, 0xef, 0xf1, 0x74, 0xdf, 0x04, 0xa9, 0x79, 0xe5, 0x23, 0xbc, 0xa2, 0xcb, 0xad, 0x4d, 0xb9, - 0xa2, 0x71, 0xe1, 0xaf, 0x11, 0x1c, 0x3e, 0x75, 0x14, 0xdb, 0x6d, 0xaa, 0x9c, 0xda, 0x18, 0x0c, 0x42, 0xb8, 0x6f, - 0x65, 0xfc, 0xcf, 0xc4, 0xcb, 0x67, 0xd1, 0x1c, 0x14, 0xa5, 0x99, 0xe6, 0x0b, 0x29, 0xa4, 0x9b, 0x00, 0x7d, 0x34, - 0x08, 0xb5, 0xba, 0xf2, 0x4d, 0xe2, 0xa5, 0x6a, 0x5a, 0x9b, 0xa7, 0x58, 0xa3, 0x40, 0xcc, 0xa2, 0x79, 0xc3, 0x32, - 0x3a, 0x24, 0xd5, 0xe5, 0xd2, 0x34, 0xe3, 0x8d, 0xd5, 0x0c, 0xd5, 0x8a, 0xa3, 0x26, 0xa8, 0x51, 0xfa, 0x08, 0x17, - 0xc0, 0x7f, 0xd0, 0x1d, 0x47, 0x35, 0x8a, 0x14, 0x0d, 0xf8, 0x04, 0x31, 0x62, 0xcd, 0xe6, 0x09, 0x6b, 0x4d, 0x5d, - 0x33, 0xfa, 0x7d, 0x19, 0x32, 0x64, 0x92, 0x90, 0xa7, 0x0f, 0x97, 0xeb, 0x07, 0x52, 0x5d, 0x00, 0xbf, 0x72, 0xc5, - 0x66, 0xbd, 0xde, 0x1c, 0xe0, 0x7a, 0x61, 0xfd, 0xc2, 0xc6, 0x15, 0x9c, 0x5f, 0x12, 0xfc, 0xae, 0xfa, 0x11, 0x66, - 0x19, 0x54, 0x01, 0x19, 0x7f, 0x2c, 0xa8, 0xe2, 0xdc, 0xc5, 0xa4, 0x7e, 0x39, 0x52, 0x17, 0x94, 0x59, 0x3a, 0xb7, - 0x38, 0x41, 0xc0, 0x79, 0x58, 0x3d, 0x81, 0x64, 0x5f, 0x3e, 0xf6, 0x69, 0x46, 0x81, 0xea, 0x08, 0xf0, 0xd9, 0xac, - 0x1f, 0xc2, 0xfe, 0x01, 0x91, 0x85, 0xfa, 0x9b, 0xd7, 0x72, 0xd6, 0x90, 0x3c, 0x90, 0x6a, 0xee, 0x63, 0x38, 0x35, - 0x16, 0xf8, 0xd2, 0xa2, 0x37, 0x15, 0xbc, 0x26, 0x64, 0xee, 0x05, 0x5a, 0xfb, 0x16, 0x70, 0x84, 0x08, 0x2e, 0xa3, - 0x14, 0xa7, 0xbd, 0x5d, 0x2f, 0x40, 0x6e, 0x73, 0x0b, 0xf2, 0xfa, 0x91, 0x8b, 0x5f, 0x9c, 0x22, 0x3d, 0x8b, 0x2e, - 0x30, 0xd0, 0x05, 0x99, 0x37, 0xfe, 0x55, 0xc1, 0xca, 0x05, 0xf4, 0x5e, 0x2a, 0x56, 0x72, 0xb2, 0xed, 0xd4, 0x1f, - 0xa5, 0xb2, 0xdf, 0x9e, 0x59, 0x13, 0xf8, 0x5d, 0x62, 0xbf, 0x44, 0x26, 0xdf, 0xf4, 0xd8, 0xe4, 0x2b, 0xc3, 0xa2, - 0x53, 0xcb, 0xe0, 0x9c, 0x1e, 0x19, 0x9c, 0x7b, 0x3b, 0xab, 0x36, 0x11, 0x0c, 0x05, 0x49, 0xa0, 0xe9, 0xd2, 0xc3, - 0xba, 0xe9, 0xcf, 0x4f, 0x5a, 0x54, 0x5b, 0xb5, 0x6f, 0xdd, 0x8f, 0x43, 0xec, 0xe2, 0x77, 0x89, 0x67, 0x88, 0x48, - 0x7d, 0xa0, 0x03, 0x93, 0xc1, 0x13, 0x97, 0xfd, 0x3e, 0x14, 0x36, 0x1b, 0xcf, 0x47, 0x75, 0xf1, 0xba, 0xb8, 0x07, - 0x54, 0x87, 0x0a, 0xec, 0x72, 0x28, 0x43, 0x19, 0xb1, 0xa9, 0x2d, 0xf7, 0xfc, 0x71, 0x1d, 0xe6, 0x20, 0xef, 0x68, - 0x78, 0x9c, 0x33, 0x10, 0xc3, 0xe0, 0xeb, 0x3f, 0x3e, 0xda, 0xa7, 0xcd, 0x8f, 0x67, 0xf0, 0xdd, 0xd1, 0xd9, 0x7b, - 0xa4, 0xbb, 0x39, 0x5b, 0x97, 0xc5, 0x5d, 0x1a, 0x8b, 0xb3, 0x1f, 0x21, 0xf5, 0xc7, 0xb3, 0xa2, 0x3c, 0xfb, 0x51, - 0x55, 0xe6, 0xc7, 0x33, 0x5a, 0x70, 0xa3, 0x3f, 0xac, 0x89, 0xf7, 0x7b, 0xa5, 0x19, 0xd0, 0x96, 0x10, 0x99, 0xa5, - 0xd5, 0x8f, 0xa0, 0x44, 0x54, 0xfc, 0xa8, 0x32, 0xaa, 0xd5, 0xda, 0x71, 0xde, 0x27, 0x1a, 0x29, 0x9b, 0x26, 0x24, - 0xae, 0x96, 0xb0, 0x0e, 0xf5, 0xec, 0xb4, 0xf9, 0x76, 0x9c, 0x07, 0xea, 0x80, 0xc8, 0xf9, 0xd3, 0x7c, 0xb4, 0xa5, - 0xaf, 0xc1, 0xb7, 0x0e, 0x87, 0x7c, 0xb4, 0x33, 0x3f, 0x7d, 0xb2, 0x56, 0xca, 0xb8, 0x23, 0xd9, 0x3b, 0x58, 0x5b, - 0xe0, 0x04, 0x01, 0x0e, 0x00, 0xff, 0x70, 0xa0, 0xdf, 0x3b, 0xf9, 0x5b, 0xed, 0x96, 0x56, 0x3d, 0x9f, 0xb5, 0xb8, - 0x33, 0x5e, 0xd5, 0x86, 0xa8, 0x6d, 0x2f, 0xb1, 0xa5, 0xf7, 0x4d, 0x83, 0x9a, 0x22, 0xfa, 0x09, 0xab, 0x89, 0x55, - 0x1c, 0x16, 0xa4, 0x84, 0x24, 0x86, 0x63, 0xb4, 0x43, 0x8f, 0xd3, 0xc5, 0xd2, 0x93, 0xfb, 0x0e, 0x2f, 0xb7, 0xbe, - 0x0f, 0x48, 0x5a, 0x85, 0xf3, 0x77, 0x5e, 0x68, 0xe0, 0xd1, 0x8b, 0xbc, 0x2a, 0x32, 0x31, 0x12, 0x34, 0xca, 0xaf, - 0x48, 0x9c, 0x39, 0xc3, 0x5a, 0x9c, 0x29, 0xb0, 0xb0, 0x90, 0x20, 0xc1, 0x8b, 0x92, 0xd2, 0x83, 0xb3, 0x47, 0xfb, - 0xb2, 0xf9, 0x83, 0xe0, 0x21, 0x46, 0x0b, 0x60, 0xc4, 0xd9, 0xb5, 0xcb, 0xbb, 0x0f, 0xcb, 0xdc, 0xfb, 0xe3, 0xd5, - 0x6d, 0x5e, 0x40, 0x88, 0xe6, 0x99, 0x54, 0xac, 0x96, 0x67, 0xc0, 0x98, 0x27, 0xe2, 0xb3, 0xb0, 0x92, 0xd3, 0xa0, - 0xea, 0x28, 0x56, 0x6d, 0xe3, 0x51, 0xee, 0x01, 0xc5, 0xf7, 0xfb, 0x04, 0xb8, 0xdc, 0x7d, 0xf6, 0x52, 0xb9, 0xa6, - 0x92, 0x1e, 0x79, 0x0e, 0xd1, 0x92, 0x8f, 0x12, 0xa0, 0x78, 0x86, 0x38, 0x49, 0x61, 0xf5, 0xdc, 0x04, 0xa9, 0xc8, - 0xd7, 0x27, 0x14, 0x5f, 0x34, 0x8f, 0xa2, 0x86, 0x85, 0x2c, 0x81, 0xe3, 0x21, 0x99, 0x65, 0x73, 0x64, 0x29, 0x4f, - 0xdb, 0x53, 0xa4, 0xa3, 0x13, 0x4b, 0xfc, 0xb6, 0xe6, 0xd7, 0x8b, 0x54, 0x04, 0x26, 0xed, 0x6c, 0x61, 0xee, 0x85, - 0x30, 0x54, 0x09, 0xf7, 0x5e, 0xd5, 0xb3, 0x50, 0x6e, 0x8a, 0x56, 0xc5, 0xec, 0x61, 0x4a, 0xcc, 0x30, 0xc5, 0xfa, - 0x0b, 0x1b, 0x7e, 0x9d, 0x78, 0x31, 0x18, 0xae, 0x97, 0xbc, 0x9c, 0x6d, 0xcc, 0x42, 0x38, 0x1c, 0x36, 0x93, 0x62, - 0xb6, 0x84, 0x30, 0xd7, 0xe5, 0xfc, 0x70, 0xe8, 0x6a, 0xd9, 0x5a, 0x78, 0xf0, 0x50, 0xb5, 0x70, 0xd3, 0xb0, 0x1c, - 0x7e, 0x26, 0xb3, 0x18, 0xdb, 0xd7, 0xf8, 0xcc, 0xfe, 0x7c, 0xd1, 0x3d, 0x4b, 0x90, 0x7c, 0x63, 0x0d, 0xb4, 0x63, - 0xb3, 0x76, 0x87, 0xab, 0x11, 0x90, 0x94, 0xee, 0x46, 0xe7, 0x58, 0x76, 0xf2, 0x94, 0x20, 0x77, 0xb4, 0x02, 0xfb, - 0xdd, 0x37, 0xfe, 0x44, 0x8b, 0x3d, 0x68, 0xb7, 0xb1, 0x25, 0x44, 0x35, 0xed, 0xb9, 0x5c, 0x29, 0x96, 0x6e, 0xb0, - 0xb4, 0xd1, 0xf3, 0x61, 0x7d, 0xee, 0x1b, 0x39, 0x50, 0x30, 0x46, 0x3c, 0xb5, 0x0e, 0xa2, 0xd9, 0x1c, 0x68, 0x30, - 0xd0, 0x3c, 0xc2, 0x53, 0x0b, 0x1d, 0x94, 0x59, 0x1b, 0xf6, 0x4f, 0xc9, 0xc9, 0xf2, 0x38, 0x7c, 0x0b, 0xff, 0xf2, - 0x19, 0x36, 0x89, 0x29, 0xb6, 0xc7, 0x2f, 0x95, 0xa2, 0xc2, 0x63, 0x3b, 0xe2, 0x5a, 0xfb, 0x28, 0x6a, 0x43, 0xe5, - 0xf0, 0x6f, 0x61, 0x1f, 0x61, 0x5f, 0xd0, 0x04, 0x61, 0xb0, 0xeb, 0xcf, 0x04, 0x42, 0xc4, 0x42, 0xbc, 0xe0, 0x97, - 0x4a, 0x52, 0xd1, 0x09, 0x9f, 0xed, 0x4a, 0xe0, 0xad, 0xc3, 0x80, 0x3e, 0x21, 0x3f, 0x13, 0x09, 0x43, 0x33, 0xa1, - 0x77, 0xf4, 0xdf, 0x89, 0x9d, 0x6c, 0x92, 0x5b, 0x21, 0x1f, 0x48, 0x2a, 0x09, 0x26, 0x58, 0x79, 0xa1, 0x7c, 0xe5, - 0x5e, 0x28, 0xb5, 0xd6, 0x82, 0xd6, 0x2f, 0xff, 0x29, 0xf1, 0x0c, 0xfe, 0x1e, 0xc8, 0x18, 0x74, 0x1b, 0x51, 0x4d, - 0x72, 0x4c, 0x1f, 0xa5, 0xf3, 0x0c, 0x54, 0x40, 0x67, 0xeb, 0x2c, 0xac, 0x97, 0x45, 0xb9, 0x6a, 0x45, 0x8a, 0xca, - 0xd2, 0x47, 0xea, 0x31, 0xe6, 0x85, 0x79, 0x72, 0x22, 0x1f, 0x3c, 0x02, 0x60, 0x3c, 0xca, 0xd3, 0xaa, 0xa3, 0xb4, - 0x7e, 0x60, 0x19, 0x30, 0x02, 0x27, 0xca, 0x80, 0x47, 0x58, 0x06, 0xe6, 0x69, 0x97, 0xa1, 0x06, 0xb1, 0x46, 0xd5, - 0x95, 0xda, 0x60, 0x4e, 0x14, 0x25, 0x9f, 0x62, 0x69, 0x85, 0x31, 0x34, 0x75, 0xe5, 0x91, 0xf5, 0x92, 0x13, 0xf6, - 0x64, 0x37, 0x90, 0x6e, 0x61, 0xa3, 0x70, 0x06, 0x5d, 0xcb, 0x12, 0xe5, 0xa2, 0x5b, 0x46, 0x94, 0x89, 0x90, 0xfa, - 0xd9, 0xc3, 0x99, 0x56, 0xfb, 0x8d, 0x9d, 0xb4, 0x6f, 0x8f, 0x14, 0xbd, 0x60, 0xd0, 0x3e, 0xed, 0x91, 0x52, 0xcf, - 0x1a, 0xb9, 0x0c, 0x6c, 0xe9, 0x52, 0xd5, 0xf3, 0xdf, 0xa0, 0x7c, 0x07, 0x33, 0xe3, 0x6c, 0xf6, 0x87, 0xde, 0xdc, - 0x1e, 0xed, 0xeb, 0xe6, 0x0f, 0xd6, 0xeb, 0xc1, 0xd6, 0x20, 0x13, 0x9f, 0x29, 0x16, 0x2a, 0xab, 0x10, 0x2b, 0x48, - 0xfb, 0xdf, 0xc2, 0xfb, 0x03, 0xde, 0x1a, 0xa1, 0x59, 0x19, 0x0f, 0xf3, 0xd1, 0xa3, 0xbd, 0x68, 0xfe, 0xe8, 0x2c, - 0xdb, 0xca, 0x55, 0xc9, 0x6c, 0x7f, 0x1c, 0x25, 0xcd, 0xd9, 0xc3, 0x35, 0x92, 0x3a, 0xc0, 0x87, 0xeb, 0x33, 0x7c, - 0xa0, 0x12, 0x4a, 0x2d, 0xa8, 0x6a, 0xd0, 0xfa, 0xd8, 0x1f, 0xad, 0xe7, 0xf4, 0xf1, 0x63, 0x39, 0xdd, 0x92, 0x22, - 0x8c, 0x1f, 0x18, 0x4c, 0xd9, 0x89, 0x53, 0x97, 0xbc, 0x19, 0xd2, 0xbb, 0x6e, 0x95, 0xd4, 0x65, 0x8f, 0x12, 0x41, - 0xa8, 0x83, 0xf5, 0x8b, 0xfd, 0x10, 0x66, 0xb6, 0xe8, 0x0f, 0x9b, 0xd5, 0x9c, 0x00, 0x11, 0x01, 0xad, 0x55, 0xde, - 0x07, 0x8e, 0xf9, 0xc2, 0xac, 0xb9, 0x21, 0xdd, 0x7a, 0x73, 0xa5, 0xbd, 0x92, 0x02, 0xfa, 0x39, 0xc8, 0xdc, 0x3e, - 0xba, 0xe5, 0xaa, 0x65, 0x9e, 0x4b, 0x5b, 0x0e, 0x58, 0xb4, 0x10, 0xa8, 0xd9, 0xb9, 0x74, 0x38, 0x50, 0x10, 0xea, - 0x4a, 0x54, 0x11, 0x57, 0x47, 0xd1, 0x42, 0xd4, 0x6a, 0xd5, 0x2e, 0x27, 0x9b, 0x0a, 0xd9, 0x92, 0x08, 0x32, 0x4a, - 0xf6, 0x4a, 0xa8, 0x8f, 0x72, 0xb5, 0x67, 0x1a, 0x0e, 0xd0, 0x04, 0x6c, 0xda, 0xe0, 0x6f, 0x81, 0x7b, 0x19, 0x9c, - 0x99, 0xf6, 0x69, 0x18, 0x01, 0xa7, 0x39, 0xc4, 0xfc, 0xf9, 0x5d, 0x0f, 0x2a, 0x78, 0xd0, 0x91, 0xfe, 0xaa, 0x9e, - 0x15, 0x78, 0xe6, 0x9e, 0x78, 0xfe, 0xf2, 0x44, 0x7a, 0x99, 0xc3, 0x03, 0x4d, 0x83, 0x98, 0xf1, 0x67, 0x65, 0x19, - 0xee, 0x46, 0xcb, 0xb2, 0x58, 0x79, 0x91, 0xde, 0xc7, 0x33, 0x29, 0x06, 0x12, 0x33, 0x66, 0x46, 0x57, 0xb1, 0x8e, - 0x73, 0x18, 0xf7, 0xf6, 0x24, 0xac, 0xd0, 0xfe, 0x59, 0x62, 0xaf, 0x0b, 0xc0, 0x72, 0xc8, 0x1a, 0xb4, 0xc2, 0x3b, - 0xdd, 0xde, 0xee, 0x71, 0xc9, 0x8e, 0xe2, 0x06, 0xd0, 0xcf, 0x6a, 0x68, 0x99, 0xa0, 0x96, 0x59, 0x77, 0x32, 0x99, - 0x22, 0xb9, 0x7c, 0x1b, 0xf6, 0x92, 0x95, 0xf9, 0xbc, 0x91, 0xdb, 0xc3, 0xdb, 0x70, 0x25, 0x62, 0x6d, 0x41, 0x27, - 0x1d, 0x19, 0x87, 0x7b, 0xa1, 0xb9, 0x91, 0xee, 0x1f, 0x55, 0x49, 0x58, 0x8a, 0x18, 0x6e, 0x81, 0x6c, 0xaf, 0xb6, - 0x95, 0xa0, 0x04, 0x3e, 0xd8, 0xf7, 0xa5, 0x58, 0xa6, 0x5b, 0x01, 0xb8, 0x0e, 0xfc, 0x37, 0x89, 0x48, 0xe8, 0xee, - 0x3c, 0x44, 0xb1, 0x46, 0xde, 0x37, 0x88, 0xc6, 0xfe, 0x09, 0xe4, 0x34, 0x20, 0x13, 0x29, 0x46, 0xb2, 0x60, 0xe0, - 0x03, 0xc8, 0xf9, 0x1a, 0x4c, 0x72, 0xd3, 0xdc, 0xf3, 0x83, 0x5c, 0x77, 0x30, 0xed, 0x83, 0xee, 0xc5, 0xb5, 0x66, - 0x39, 0x78, 0xc5, 0x44, 0xfc, 0x1f, 0xb5, 0x57, 0xb2, 0x9c, 0x65, 0x7e, 0x63, 0x2e, 0x3a, 0x19, 0x5c, 0x35, 0x84, - 0x5f, 0xcc, 0xb2, 0x39, 0x8f, 0x66, 0x99, 0x8e, 0xfa, 0x2f, 0x9a, 0xa3, 0x52, 0x00, 0x4e, 0x1d, 0x2f, 0xc0, 0x1a, - 0xfa, 0x4a, 0x37, 0xad, 0x78, 0xa0, 0x31, 0x46, 0x41, 0x85, 0x0e, 0x42, 0xff, 0xa8, 0x01, 0x69, 0x83, 0x49, 0x9a, - 0x84, 0xca, 0x07, 0x17, 0x74, 0xc3, 0xd8, 0x5c, 0xb9, 0x5c, 0x35, 0xa9, 0x5a, 0x7e, 0x39, 0xa2, 0xbe, 0xab, 0x25, - 0x97, 0x6a, 0xf3, 0xa9, 0x51, 0xd6, 0x08, 0x32, 0x39, 0x4a, 0xbf, 0x4f, 0xb9, 0x70, 0x2b, 0x63, 0xb2, 0x3e, 0x1c, - 0xbc, 0x82, 0x9b, 0x1a, 0xbf, 0xc8, 0x89, 0x50, 0xd4, 0x1e, 0x12, 0x61, 0x6b, 0xb7, 0x42, 0xf7, 0x1e, 0x37, 0x4a, - 0xf3, 0x28, 0xdb, 0xc4, 0xa2, 0xf2, 0x7a, 0x09, 0x58, 0x8b, 0x7b, 0xc0, 0x8b, 0x4a, 0x4b, 0xbf, 0x62, 0x05, 0xa0, - 0x07, 0x48, 0x61, 0xe3, 0x05, 0x32, 0x60, 0xbd, 0xf3, 0x52, 0xbf, 0xdf, 0x37, 0xa6, 0xfc, 0x77, 0xf7, 0x39, 0x90, - 0x14, 0x8a, 0xb2, 0xde, 0xc1, 0x04, 0x82, 0x6b, 0x27, 0x69, 0xcf, 0x6a, 0xfe, 0x74, 0x5d, 0x7b, 0xc0, 0x6f, 0xe5, - 0x5b, 0x24, 0x56, 0x9f, 0xec, 0x8b, 0xcd, 0x3e, 0xad, 0x3e, 0x1a, 0x8d, 0x83, 0x60, 0x69, 0xf5, 0x4a, 0xab, 0x1c, - 0xf2, 0x86, 0x17, 0x20, 0x52, 0x59, 0x57, 0xd7, 0xca, 0xb9, 0xba, 0x16, 0x1c, 0xb9, 0x64, 0x4b, 0x9e, 0xc3, 0x7f, - 0x21, 0xf7, 0xca, 0xc3, 0xa1, 0xf0, 0xfb, 0xfd, 0x74, 0x46, 0x5a, 0x59, 0x60, 0x4f, 0x5b, 0xd7, 0x5e, 0xe8, 0x1f, - 0x0e, 0x2f, 0xc0, 0x6b, 0xc4, 0x3f, 0x1c, 0xca, 0x7e, 0xff, 0x83, 0xb9, 0xc9, 0x9c, 0x8f, 0x95, 0x52, 0xf6, 0x12, - 0x95, 0xee, 0xaf, 0x13, 0xde, 0xfb, 0xdf, 0xa3, 0xff, 0x3d, 0xba, 0xec, 0xc9, 0xae, 0xff, 0x90, 0xf0, 0x19, 0xde, - 0xd0, 0x99, 0xba, 0x9c, 0x33, 0xe9, 0xee, 0xae, 0xfc, 0xd0, 0x7b, 0x1a, 0x2a, 0xbe, 0x37, 0x37, 0x6d, 0xfc, 0x47, - 0x75, 0xa4, 0x49, 0xe8, 0xb8, 0xe8, 0x1f, 0x0e, 0x1f, 0x12, 0xad, 0x4f, 0x4b, 0x95, 0x3e, 0x4d, 0xe1, 0x28, 0x19, - 0x72, 0x37, 0xb7, 0x30, 0x1d, 0xd8, 0x8f, 0x9b, 0xaf, 0x92, 0x17, 0x67, 0x29, 0x5c, 0x7b, 0xf3, 0x59, 0x3a, 0x9f, - 0x82, 0x75, 0x65, 0x98, 0xcf, 0xea, 0x79, 0x00, 0xa9, 0x43, 0x48, 0xb3, 0xa6, 0xe1, 0x3f, 0x2b, 0x57, 0xf0, 0xd6, - 0x1e, 0xef, 0x06, 0x2e, 0x4a, 0x1d, 0xe9, 0x93, 0x36, 0x9a, 0x2e, 0xa9, 0xe4, 0x3f, 0x88, 0x3c, 0xc6, 0x98, 0x8d, - 0x17, 0xc4, 0xfb, 0x59, 0xe4, 0xd7, 0x05, 0x60, 0x17, 0x01, 0x18, 0x72, 0x3a, 0x77, 0x24, 0xf1, 0x97, 0xc9, 0xf7, - 0x7f, 0x4c, 0x97, 0xf6, 0xbe, 0x2c, 0x6e, 0x4b, 0x51, 0x55, 0x47, 0xa5, 0x6d, 0x6d, 0xb9, 0x1e, 0x98, 0x44, 0xfb, - 0x7d, 0xc9, 0x24, 0x9a, 0x62, 0x28, 0x0a, 0xdc, 0x1a, 0x7b, 0xd3, 0x94, 0x2b, 0xc6, 0xea, 0x91, 0xb1, 0x7e, 0x3e, - 0xdf, 0xbd, 0x8a, 0xbd, 0xd4, 0x0f, 0x52, 0x10, 0x84, 0x35, 0x94, 0x52, 0x8a, 0x7c, 0x70, 0x3e, 0xc3, 0x54, 0xa2, - 0xd6, 0xa5, 0x54, 0xf9, 0xc3, 0x48, 0xf3, 0x61, 0x0a, 0x7a, 0xd9, 0x7f, 0x57, 0x30, 0xff, 0x75, 0x7b, 0xb0, 0x3e, - 0xad, 0xcb, 0x34, 0xaa, 0x88, 0x2a, 0x2f, 0x4c, 0xb5, 0x09, 0x44, 0xf0, 0xa7, 0xc2, 0xe2, 0xfb, 0xf5, 0xc9, 0x91, - 0xa0, 0x31, 0x93, 0xe5, 0xed, 0x91, 0xfb, 0x85, 0x7d, 0xe5, 0x3a, 0x9e, 0xff, 0xb9, 0x99, 0xff, 0x03, 0x74, 0x86, - 0x2c, 0x9e, 0x72, 0xcb, 0x60, 0x81, 0xb3, 0x5f, 0xba, 0x7a, 0xc0, 0xdf, 0xcc, 0x13, 0x4f, 0x81, 0x8e, 0xf9, 0x29, - 0xba, 0x2a, 0xa6, 0xb3, 0x62, 0x00, 0x5c, 0xb6, 0x7e, 0x63, 0xcd, 0x89, 0xaf, 0x16, 0xe5, 0x95, 0x5c, 0x10, 0xfa, - 0xba, 0x0a, 0xb3, 0x71, 0x55, 0x6c, 0x2a, 0x51, 0x6c, 0xea, 0x1e, 0xa9, 0x65, 0xf3, 0x69, 0x6d, 0x2b, 0x64, 0xff, - 0x2e, 0x5a, 0x0c, 0x5e, 0x86, 0x75, 0x32, 0xca, 0xd2, 0xf5, 0x14, 0xf8, 0xf5, 0x02, 0x38, 0x8b, 0xcc, 0x2b, 0x9f, - 0x9d, 0x3d, 0x60, 0x8b, 0xc6, 0x53, 0x20, 0x47, 0xa5, 0x3f, 0xf2, 0xc6, 0xe8, 0xf4, 0x44, 0xbf, 0x9f, 0x4f, 0x29, - 0xe6, 0xeb, 0xef, 0x00, 0xcf, 0x55, 0xcb, 0x05, 0xe8, 0xcb, 0x50, 0x07, 0x95, 0x28, 0xb5, 0x62, 0x18, 0xb1, 0xf0, - 0x77, 0x81, 0x44, 0xce, 0x14, 0xd8, 0xac, 0xa2, 0x24, 0x54, 0xa2, 0x52, 0xb2, 0x35, 0x41, 0x2d, 0xbd, 0x2f, 0xca, - 0x7a, 0x5f, 0x81, 0xa3, 0x64, 0xa4, 0xcd, 0x72, 0xd2, 0x8c, 0x2b, 0x50, 0xe6, 0xa2, 0x1f, 0xec, 0xef, 0x95, 0xe7, - 0x37, 0x32, 0x9f, 0xe5, 0xbe, 0xa3, 0x73, 0xda, 0x8e, 0x0b, 0x94, 0xb9, 0xe5, 0xb4, 0xd5, 0x92, 0xc7, 0xe4, 0x3d, - 0x0b, 0xb6, 0xfd, 0x57, 0x09, 0x52, 0x2c, 0xc2, 0x7c, 0x42, 0x95, 0xcd, 0xbf, 0x21, 0xd4, 0x16, 0x07, 0xf6, 0xd8, - 0x85, 0x89, 0xf8, 0x6f, 0xc1, 0x92, 0x18, 0x66, 0xa5, 0x08, 0xe3, 0x1d, 0x78, 0xff, 0x6c, 0x2a, 0x31, 0x3a, 0x43, - 0x27, 0xf7, 0xb3, 0xfb, 0xb4, 0x4e, 0xce, 0x5e, 0xbd, 0x38, 0xfb, 0xb1, 0x37, 0x28, 0x46, 0x69, 0x3c, 0xe8, 0xfd, - 0x78, 0xb6, 0xda, 0x00, 0x5a, 0xa6, 0x38, 0x8b, 0xc9, 0x94, 0x26, 0xe2, 0x33, 0x32, 0x0c, 0x9e, 0xd5, 0x89, 0x38, - 0xa3, 0x89, 0xe9, 0xbe, 0x46, 0x69, 0xf2, 0xed, 0x28, 0xcc, 0xe1, 0xe5, 0x52, 0x6c, 0x2a, 0x11, 0x83, 0x9d, 0x52, - 0xcd, 0xb3, 0xbc, 0x7d, 0x16, 0xe7, 0xa3, 0x0e, 0x59, 0xa5, 0x03, 0x7f, 0x7b, 0x22, 0xed, 0xaa, 0x74, 0x05, 0x84, - 0x1e, 0x00, 0x27, 0x5d, 0xf9, 0xf3, 0x70, 0xc8, 0x13, 0x08, 0xb5, 0x60, 0x4e, 0xa6, 0x11, 0xdd, 0x90, 0xae, 0xb1, - 0xcf, 0xc0, 0x2c, 0xa4, 0x34, 0x0f, 0x6e, 0xae, 0x16, 0x43, 0x77, 0xc5, 0xca, 0x51, 0x58, 0xad, 0x45, 0x54, 0x23, - 0xeb, 0x31, 0x38, 0xef, 0x40, 0x04, 0x80, 0x22, 0x07, 0xcf, 0x78, 0xd4, 0xef, 0x47, 0x2a, 0x28, 0x27, 0xa1, 0x5f, - 0x14, 0xfa, 0xa5, 0xe1, 0x28, 0x63, 0xfe, 0x3c, 0xd4, 0x1c, 0x01, 0xf5, 0x96, 0x87, 0x8a, 0x2e, 0x00, 0x97, 0x73, - 0xc4, 0x8c, 0xf3, 0x1e, 0x77, 0x81, 0x39, 0x15, 0x05, 0x85, 0xba, 0x0e, 0x96, 0x0a, 0x80, 0xde, 0xd4, 0x47, 0x7a, - 0x4e, 0xfe, 0x1f, 0xde, 0xde, 0x85, 0xbb, 0x6d, 0x1b, 0x6b, 0x17, 0xfe, 0x2b, 0x16, 0x4f, 0xaa, 0x12, 0x11, 0x24, - 0x4b, 0x4e, 0xd2, 0x99, 0x52, 0x86, 0x75, 0xdc, 0x5c, 0x9a, 0xcc, 0x34, 0x97, 0x26, 0x69, 0x3b, 0x53, 0x1d, 0xbd, - 0x2e, 0x4d, 0xc2, 0x16, 0x1b, 0x1a, 0x50, 0x49, 0xca, 0xb6, 0x22, 0xf1, 0xbf, 0x7f, 0x6b, 0x6f, 0x5c, 0x49, 0xd1, - 0x4e, 0xe6, 0x3d, 0xef, 0xf9, 0x56, 0xd6, 0x8a, 0x45, 0x10, 0xc4, 0x1d, 0x1b, 0x1b, 0xfb, 0xf2, 0x6c, 0x97, 0x60, - 0xf1, 0xdc, 0xc0, 0xe2, 0xd5, 0xc5, 0xa2, 0xba, 0xe2, 0x5a, 0x6e, 0x61, 0x53, 0xca, 0x2a, 0x86, 0x00, 0x02, 0xcd, - 0x98, 0x61, 0xb7, 0xdc, 0xe5, 0x48, 0xd6, 0x45, 0xc1, 0xc5, 0x5e, 0x60, 0xe8, 0x66, 0x5c, 0x32, 0x73, 0x70, 0x35, - 0xc3, 0x3a, 0xa9, 0x28, 0xc0, 0xae, 0x2e, 0x40, 0xf6, 0xc2, 0x50, 0xd7, 0xcd, 0x6c, 0xb9, 0x0e, 0x7c, 0x5d, 0xba, - 0xf0, 0x25, 0x05, 0x2f, 0x57, 0x52, 0x94, 0xd9, 0x35, 0xff, 0xc9, 0xbe, 0x6c, 0xc6, 0x92, 0x42, 0x3b, 0xd2, 0xd7, - 0xed, 0xee, 0x68, 0x31, 0x8e, 0x2d, 0xc7, 0xb7, 0x54, 0xba, 0xd6, 0xa3, 0xea, 0x85, 0xd0, 0xd6, 0xb9, 0x96, 0x59, - 0x9a, 0x72, 0xf1, 0x4a, 0xa4, 0x59, 0xe2, 0x25, 0xc7, 0x3a, 0x56, 0xb5, 0x0b, 0x82, 0xe5, 0xc2, 0x24, 0x3f, 0xcb, - 0x4a, 0x8c, 0x1d, 0xdc, 0x68, 0x54, 0x2b, 0xea, 0x94, 0x89, 0x81, 0x21, 0xdf, 0x63, 0xf0, 0x6d, 0x56, 0x24, 0xc0, - 0xf0, 0x63, 0xa2, 0xbe, 0xa4, 0xa7, 0x10, 0xf0, 0x41, 0x85, 0xe6, 0x7e, 0xc6, 0x11, 0xfc, 0xda, 0xaa, 0xcc, 0x81, - 0xc9, 0xd6, 0x2a, 0x48, 0xc4, 0xbd, 0xcb, 0xe6, 0x7a, 0x11, 0x2d, 0xd4, 0x5d, 0xa8, 0x17, 0xef, 0x76, 0xbd, 0x44, - 0xd1, 0x01, 0x27, 0x3f, 0x0d, 0x5e, 0xc4, 0x59, 0xce, 0xd3, 0x83, 0x4a, 0x1e, 0xa8, 0x0d, 0x75, 0xa0, 0x9c, 0x39, - 0x60, 0xe7, 0x7d, 0x5b, 0x1d, 0xe8, 0x35, 0x7d, 0xa0, 0xdb, 0x79, 0x00, 0x17, 0x0c, 0xdc, 0xb9, 0x97, 0xd9, 0x35, - 0x17, 0x07, 0xa0, 0x0c, 0xb4, 0xc6, 0x03, 0x75, 0x59, 0x8d, 0xd4, 0xc4, 0xe8, 0x18, 0xd6, 0x89, 0x3e, 0x98, 0x03, - 0xfa, 0x33, 0x84, 0xb5, 0x6f, 0xbd, 0x5d, 0xe9, 0x83, 0x36, 0xa0, 0x2f, 0x96, 0xa6, 0x0f, 0x3a, 0x70, 0xbc, 0x8a, - 0x0e, 0xdc, 0x18, 0x52, 0x0d, 0xda, 0x6a, 0x64, 0x15, 0x28, 0xde, 0xf0, 0x16, 0xef, 0xde, 0xb5, 0x64, 0xeb, 0xbd, - 0x44, 0x8c, 0xaf, 0x4c, 0x54, 0x71, 0x26, 0x4e, 0xbd, 0x54, 0x5e, 0x6b, 0x27, 0x19, 0x61, 0x7c, 0xcb, 0x4a, 0xea, - 0xef, 0x10, 0x73, 0x8b, 0x34, 0x87, 0xc1, 0xab, 0xb0, 0x22, 0x33, 0xde, 0xef, 0xcb, 0x99, 0x8c, 0xca, 0x99, 0x38, - 0x2c, 0x23, 0x05, 0xd6, 0x76, 0x97, 0x08, 0xe8, 0x5e, 0x09, 0x90, 0x2f, 0x00, 0xaa, 0xee, 0x13, 0xfe, 0xdc, 0x27, - 0xf5, 0xe9, 0x14, 0xfa, 0x14, 0xda, 0x7a, 0xc5, 0x15, 0xc4, 0xab, 0xba, 0x31, 0xb2, 0x8d, 0x0a, 0x5a, 0x3c, 0x96, - 0x67, 0xb5, 0x61, 0x6c, 0x4e, 0xad, 0x7f, 0xbd, 0xd9, 0x60, 0xca, 0xe6, 0x42, 0xad, 0xc2, 0x90, 0x44, 0x9f, 0x4a, - 0x2f, 0x92, 0x88, 0x85, 0xcd, 0x6a, 0x6d, 0x7e, 0x13, 0x06, 0x24, 0x13, 0x29, 0xee, 0x67, 0x4b, 0x9c, 0xbb, 0x78, - 0x3c, 0xaf, 0xfa, 0x5a, 0x4b, 0x8b, 0x4c, 0x9b, 0x6f, 0xf5, 0x65, 0x48, 0x53, 0x51, 0x43, 0x1a, 0x75, 0x66, 0xd0, - 0x7d, 0xbb, 0xbc, 0x65, 0x35, 0xc2, 0x04, 0x78, 0xa5, 0x33, 0xe8, 0x46, 0xe3, 0x81, 0x58, 0x56, 0xa3, 0x62, 0x2d, - 0x04, 0x02, 0x0f, 0x43, 0x8e, 0x99, 0x25, 0x24, 0xd9, 0x67, 0xfe, 0x83, 0x8a, 0xb3, 0x50, 0xc4, 0x37, 0x06, 0xd9, - 0xbb, 0xb2, 0xae, 0xdd, 0x75, 0xe4, 0xe7, 0xc4, 0xc2, 0x6a, 0xff, 0xa1, 0x79, 0xd4, 0x1a, 0x67, 0x01, 0x6d, 0x4d, - 0xab, 0x1b, 0x0e, 0xf7, 0xa8, 0x8e, 0x45, 0x69, 0xb0, 0x89, 0x3d, 0xb2, 0x5c, 0xb4, 0x8e, 0x19, 0x34, 0xa0, 0xbf, - 0xcd, 0xae, 0xd6, 0x57, 0x08, 0xe0, 0x56, 0x22, 0xeb, 0x24, 0x95, 0x7f, 0x49, 0x7b, 0xd4, 0xb5, 0x3d, 0x95, 0xff, - 0x6d, 0x9b, 0x2a, 0x87, 0x16, 0x53, 0x1e, 0xbb, 0x39, 0x0b, 0x54, 0x47, 0x82, 0x28, 0x50, 0x5b, 0x2f, 0x98, 0x7a, - 0xa7, 0x4c, 0xd1, 0x01, 0x02, 0x5d, 0x98, 0x33, 0xec, 0x2b, 0x8e, 0x18, 0xb3, 0x54, 0x62, 0x30, 0xf5, 0x31, 0x46, - 0x35, 0xad, 0x15, 0xa0, 0xeb, 0xa7, 0x5b, 0xf8, 0x13, 0x15, 0x35, 0x1a, 0x6a, 0x8d, 0xa4, 0x50, 0x34, 0x51, 0xa1, - 0xc8, 0xd2, 0x42, 0xc7, 0x55, 0xe8, 0x24, 0x12, 0x96, 0x80, 0x86, 0x09, 0xd1, 0x49, 0x05, 0xde, 0x1a, 0xc0, 0x99, - 0x8f, 0x8b, 0x72, 0x5d, 0x68, 0x83, 0xb9, 0x97, 0xf1, 0x35, 0x7f, 0xf5, 0xcc, 0x19, 0xd5, 0xb7, 0xac, 0xf5, 0x3d, - 0x2d, 0xc8, 0xcb, 0x90, 0x53, 0x74, 0x60, 0x62, 0x27, 0x5b, 0x34, 0xc6, 0x28, 0x6b, 0x1d, 0xf5, 0xe2, 0xad, 0x0e, - 0xc5, 0xa2, 0x4d, 0xf0, 0xee, 0xf1, 0x14, 0xd1, 0x86, 0x87, 0xc2, 0x58, 0x55, 0xe3, 0x53, 0xc9, 0x5a, 0x7a, 0xb0, - 0x82, 0xa7, 0xeb, 0x84, 0x87, 0xa0, 0x47, 0x22, 0xec, 0x24, 0x2c, 0xe6, 0xf1, 0x02, 0x8e, 0x93, 0x82, 0x80, 0xda, - 0x41, 0x5f, 0xc1, 0xe7, 0x0b, 0x74, 0x7f, 0x95, 0xe8, 0x01, 0x86, 0x16, 0xc4, 0xcd, 0x28, 0xa8, 0xa3, 0xab, 0x78, - 0xd5, 0x50, 0x91, 0xf0, 0x79, 0x01, 0xb6, 0x43, 0x4a, 0x3d, 0x05, 0x5a, 0xa8, 0x44, 0xe9, 0x87, 0x81, 0xef, 0xd0, - 0x18, 0xd8, 0x5a, 0x07, 0x68, 0xe8, 0x67, 0x4c, 0x53, 0xeb, 0x0c, 0x95, 0xcf, 0xbc, 0x7b, 0x66, 0xb4, 0x9c, 0x59, - 0x34, 0x06, 0x7d, 0x1b, 0x4d, 0x51, 0x9c, 0x93, 0xcf, 0x82, 0x22, 0x4e, 0xb3, 0x38, 0x07, 0xbf, 0xcd, 0xb8, 0xc0, - 0x8c, 0x49, 0x5c, 0xf1, 0x4b, 0x59, 0x80, 0xb6, 0x3b, 0x57, 0xa9, 0x75, 0x0d, 0x02, 0xb2, 0x97, 0x60, 0xf5, 0xd2, - 0xd0, 0x51, 0x39, 0xef, 0x2e, 0x6d, 0x0a, 0x91, 0x88, 0x10, 0x6c, 0x9a, 0xe9, 0x92, 0x9d, 0x86, 0x4a, 0x9b, 0x03, - 0xa1, 0x8e, 0xd0, 0xb8, 0x7f, 0x1a, 0xc6, 0x56, 0x53, 0x6c, 0xed, 0xde, 0x76, 0xbb, 0x7f, 0x96, 0x5e, 0x3a, 0xcd, - 0x49, 0x8f, 0xb1, 0x7f, 0x96, 0x61, 0x31, 0xb2, 0x1d, 0x21, 0xb0, 0xe4, 0xbc, 0x4f, 0xfd, 0x57, 0xb4, 0x9c, 0x27, - 0x60, 0x3a, 0xa2, 0x83, 0xe5, 0x02, 0x65, 0xc7, 0x80, 0xee, 0xc0, 0xe0, 0x8a, 0x7e, 0x1f, 0xac, 0x32, 0xcc, 0x85, - 0x64, 0x49, 0x52, 0x06, 0xcf, 0x53, 0x0f, 0x0e, 0x7e, 0xcd, 0x94, 0xb9, 0x8b, 0xb2, 0x3e, 0x5d, 0x92, 0x69, 0x8a, - 0x0c, 0xc4, 0x3a, 0xdc, 0x66, 0x69, 0x94, 0x28, 0x11, 0xd9, 0x12, 0xfd, 0x23, 0x0d, 0xc5, 0xd2, 0x91, 0x7b, 0x91, - 0x2a, 0x11, 0x2a, 0xe6, 0x29, 0x9e, 0xd4, 0x69, 0x9d, 0x8e, 0x30, 0xf4, 0x24, 0x28, 0xe5, 0x6a, 0x18, 0xa8, 0x92, - 0xea, 0xa5, 0xb0, 0x2d, 0x76, 0x3b, 0x7d, 0xb1, 0x12, 0xf3, 0x78, 0x81, 0x2f, 0x05, 0x8e, 0xe2, 0x3f, 0xb9, 0x17, - 0x76, 0x4a, 0x6d, 0x0f, 0x6a, 0x47, 0x94, 0xd0, 0x7f, 0x72, 0xb8, 0x48, 0xfc, 0x20, 0x75, 0x08, 0x40, 0xb4, 0x08, - 0x39, 0x53, 0x07, 0xa9, 0xe1, 0x86, 0xf6, 0x84, 0xff, 0x86, 0xeb, 0x33, 0xce, 0xe8, 0x4d, 0x35, 0xa3, 0x86, 0xf2, - 0xf5, 0xa0, 0x8d, 0x51, 0x9f, 0x0d, 0x1c, 0x56, 0x88, 0x42, 0x1b, 0x76, 0x52, 0x2a, 0xd1, 0xc2, 0x50, 0xaa, 0xbf, - 0x84, 0x8a, 0x13, 0xee, 0xcc, 0x28, 0x4b, 0xc6, 0xa7, 0xe5, 0xb1, 0x98, 0x0e, 0x06, 0x25, 0xa9, 0x8c, 0x85, 0x1e, - 0x5c, 0x0f, 0x3c, 0xff, 0x1e, 0xb8, 0x85, 0x78, 0xc8, 0xc8, 0x62, 0xc8, 0x0d, 0x4e, 0x7e, 0x8b, 0x93, 0xab, 0x46, - 0xa5, 0x8a, 0x63, 0x4d, 0x54, 0x0b, 0x7e, 0x2c, 0xc3, 0x00, 0x7d, 0x92, 0x02, 0x30, 0x19, 0x4c, 0xf9, 0x2d, 0x48, - 0x94, 0xce, 0xd4, 0x0d, 0xe9, 0x17, 0x51, 0xf0, 0x0b, 0x5e, 0x70, 0x91, 0xb8, 0x02, 0x2c, 0xef, 0x60, 0x7b, 0x1d, - 0x55, 0x54, 0x61, 0xf2, 0x9a, 0x1e, 0x47, 0xdc, 0x78, 0xff, 0x99, 0x1e, 0x5b, 0xcc, 0x56, 0xeb, 0xd8, 0xe0, 0x33, - 0xc7, 0xe0, 0x82, 0xae, 0x25, 0xb6, 0x86, 0x6a, 0x58, 0x11, 0x18, 0xb8, 0x80, 0x83, 0xb0, 0x44, 0x71, 0x6c, 0x25, - 0xaf, 0x48, 0x43, 0x4a, 0x7b, 0xcf, 0x70, 0xb4, 0x49, 0x8e, 0x6f, 0xb3, 0xec, 0x26, 0x70, 0xbe, 0xe8, 0x9c, 0x34, - 0x13, 0xd6, 0x06, 0xef, 0xf3, 0xe6, 0xfc, 0xba, 0x7b, 0x48, 0xa8, 0x8a, 0x7b, 0xc3, 0xdb, 0x71, 0x6f, 0x9c, 0xf0, - 0x6b, 0x2e, 0x16, 0x3a, 0x54, 0x8b, 0xb9, 0x64, 0xf9, 0xad, 0xf5, 0x6e, 0x49, 0x52, 0x2b, 0xa0, 0x7d, 0x96, 0x05, - 0x35, 0x11, 0x00, 0xf2, 0x87, 0xbf, 0x40, 0xe8, 0x0c, 0x7f, 0x7b, 0x0c, 0xae, 0x48, 0xe1, 0x9d, 0x43, 0x20, 0xac, - 0xe9, 0xe6, 0x5e, 0x6d, 0xc0, 0x17, 0xe3, 0xfe, 0x8c, 0xa9, 0xa7, 0xdf, 0x66, 0x72, 0x5f, 0xd7, 0xed, 0x91, 0x65, - 0xf8, 0x08, 0x57, 0x0a, 0xe0, 0x66, 0xc2, 0x5f, 0x0c, 0x33, 0xa9, 0x3e, 0x01, 0x4c, 0x35, 0x1d, 0xdc, 0x27, 0x08, - 0x0c, 0xa0, 0x12, 0x2d, 0x46, 0xd7, 0xca, 0x11, 0xcd, 0xc0, 0xad, 0xe9, 0x56, 0x18, 0x6f, 0x3d, 0x68, 0xa1, 0x67, - 0x1a, 0x4e, 0xfc, 0x07, 0xcd, 0xbc, 0x2a, 0x20, 0x80, 0x56, 0x46, 0xf0, 0xd6, 0xfa, 0x64, 0x8e, 0x10, 0x9f, 0xb0, - 0x24, 0x9a, 0xb0, 0x78, 0xa6, 0xf8, 0x31, 0xa1, 0xdb, 0xa6, 0xb6, 0xe9, 0x23, 0xd2, 0x5f, 0x5c, 0xb3, 0x7e, 0xca, - 0xb2, 0xf6, 0xed, 0xa1, 0xe2, 0xc5, 0xb4, 0x19, 0x07, 0x31, 0x51, 0xc5, 0xf8, 0x5f, 0x70, 0x5f, 0x6a, 0x05, 0x88, - 0xcc, 0x5d, 0xf5, 0xf4, 0xfb, 0xcd, 0x6c, 0x39, 0x10, 0x2a, 0xbf, 0x33, 0x48, 0xfa, 0x74, 0x68, 0x3f, 0xb0, 0x49, - 0xd4, 0x16, 0x7a, 0xfe, 0xb8, 0xd4, 0x4d, 0xbc, 0xbc, 0x36, 0x35, 0xa2, 0x15, 0x32, 0x54, 0xb6, 0x0e, 0x58, 0xdf, - 0x2f, 0xc3, 0xfd, 0x45, 0x4d, 0x43, 0xad, 0x7b, 0xee, 0x5a, 0x14, 0x9c, 0xf8, 0x03, 0x8c, 0xc5, 0x85, 0xa4, 0xd6, - 0xf1, 0x98, 0xf4, 0xa3, 0x85, 0x4c, 0x6e, 0xd4, 0xd5, 0xc9, 0x99, 0x62, 0x9e, 0xc0, 0x05, 0xb8, 0x6c, 0xfb, 0x2b, - 0x2a, 0x75, 0x29, 0xb7, 0x57, 0x94, 0xa6, 0x87, 0xb4, 0xbd, 0x8a, 0xf3, 0xb6, 0xe0, 0x82, 0x7f, 0xa5, 0xe0, 0xc2, - 0x3a, 0x58, 0x77, 0xdc, 0x29, 0x7b, 0xc2, 0x13, 0x65, 0x5a, 0x1b, 0xdc, 0x75, 0x83, 0x31, 0x31, 0xf6, 0xbb, 0x4b, - 0x9e, 0x7c, 0x42, 0x16, 0xfc, 0x87, 0x4c, 0x80, 0x67, 0xb2, 0x7b, 0xa5, 0xf2, 0xbf, 0xf4, 0xaf, 0xb6, 0xf6, 0x9d, - 0x35, 0xff, 0xf4, 0xac, 0x87, 0x3b, 0x87, 0xc9, 0x8f, 0xd5, 0x19, 0xd0, 0xed, 0x95, 0x4c, 0x39, 0x20, 0x03, 0x58, - 0x8b, 0x64, 0x34, 0xe0, 0x43, 0x2b, 0xcb, 0xb6, 0xef, 0xb4, 0xba, 0x20, 0xdc, 0x49, 0xe0, 0xa6, 0x77, 0xd7, 0x66, - 0x66, 0x4e, 0xd7, 0x4a, 0x34, 0x5d, 0x1a, 0x5b, 0xcb, 0x52, 0x85, 0xf1, 0x7e, 0xe7, 0x49, 0x36, 0xcd, 0x8f, 0x97, - 0xd3, 0xdc, 0x52, 0xb7, 0xad, 0x5b, 0x36, 0x80, 0x86, 0xd8, 0xb5, 0xb6, 0x72, 0xc0, 0xcb, 0xed, 0x41, 0x34, 0x5f, - 0x2b, 0x42, 0x4f, 0x95, 0x08, 0x7d, 0x9a, 0x36, 0xfb, 0x60, 0x57, 0xd5, 0xba, 0x11, 0xf2, 0x68, 0x90, 0x6a, 0x46, - 0xfe, 0xed, 0x35, 0x2f, 0x2e, 0x72, 0x79, 0x03, 0x70, 0xc8, 0xa4, 0x36, 0x0a, 0xcb, 0x2b, 0x70, 0xe7, 0x47, 0xc7, - 0x71, 0x26, 0x46, 0x39, 0xc6, 0x6d, 0x45, 0xa4, 0x64, 0x9d, 0x38, 0x03, 0x3c, 0x64, 0x7f, 0xd2, 0x74, 0x68, 0xd7, - 0x02, 0xc3, 0xfb, 0x02, 0x77, 0x95, 0xb3, 0x93, 0x6d, 0x6e, 0x17, 0x7d, 0x73, 0x86, 0x75, 0x47, 0x4a, 0x6b, 0x63, - 0xd1, 0x75, 0x07, 0x6b, 0xcd, 0xa0, 0x2d, 0x42, 0xc9, 0x87, 0xdc, 0x49, 0xfb, 0x39, 0xa0, 0xc1, 0x59, 0x96, 0xde, - 0x5a, 0xab, 0xfc, 0xad, 0x16, 0xe2, 0x44, 0x31, 0x75, 0xe2, 0x9b, 0x28, 0xd1, 0xe7, 0x67, 0x62, 0xdc, 0x40, 0x20, - 0xf5, 0x25, 0xc6, 0xd7, 0x28, 0xc2, 0x04, 0xae, 0x03, 0x51, 0x6c, 0x4f, 0xd4, 0xc6, 0x72, 0x04, 0x9d, 0x10, 0xe2, - 0x1d, 0x94, 0x61, 0xac, 0x2e, 0x0e, 0xb4, 0xc1, 0xd2, 0xd7, 0xad, 0x75, 0x6e, 0x08, 0x85, 0x71, 0x02, 0x53, 0x0c, - 0x92, 0x3a, 0xeb, 0x2c, 0x13, 0x54, 0xd9, 0x31, 0xe9, 0xbc, 0x0f, 0xd0, 0xfd, 0xb5, 0x68, 0x8a, 0xaf, 0x3b, 0x77, - 0xd0, 0x5d, 0x5c, 0xbf, 0xd6, 0x22, 0x37, 0xf8, 0xf3, 0x96, 0x08, 0x8b, 0xc0, 0x59, 0x6b, 0xf2, 0x55, 0x23, 0x1c, - 0x98, 0x92, 0x4c, 0xc3, 0x5e, 0xae, 0x6c, 0xba, 0x77, 0xbb, 0x5e, 0xef, 0x4e, 0x11, 0x57, 0x8f, 0xb1, 0xca, 0xbb, - 0x99, 0xdb, 0x3b, 0xd5, 0x5a, 0xec, 0xdf, 0xb4, 0xfd, 0x14, 0x3b, 0x6a, 0xad, 0xdd, 0x6e, 0x38, 0xa1, 0x86, 0x7c, - 0x2b, 0xaa, 0xb4, 0x3a, 0xdd, 0x18, 0xb4, 0x43, 0x68, 0x6b, 0x91, 0xc1, 0x8d, 0xf2, 0x99, 0x13, 0x3a, 0xa9, 0x90, - 0xab, 0x4e, 0x5d, 0xb0, 0xbd, 0xe2, 0xd5, 0x52, 0xa6, 0x91, 0xa0, 0x68, 0x73, 0x1e, 0x95, 0x34, 0x91, 0x6b, 0x51, - 0x45, 0xb2, 0x46, 0xbd, 0xa8, 0xd5, 0x18, 0x20, 0x20, 0xd3, 0x59, 0xd3, 0x83, 0x2a, 0x98, 0x0d, 0x65, 0x24, 0xa7, - 0x6f, 0xc0, 0xd2, 0x1e, 0x39, 0xd6, 0xfa, 0xae, 0x3a, 0x5b, 0x7c, 0xab, 0x27, 0x04, 0x53, 0x98, 0x3d, 0x10, 0x11, - 0xae, 0x69, 0x0c, 0x39, 0xed, 0x12, 0x97, 0x35, 0xdd, 0x12, 0xee, 0xe0, 0x76, 0x25, 0x3b, 0x71, 0xf3, 0xa4, 0xb9, - 0xb9, 0x82, 0x9d, 0x14, 0xf3, 0x31, 0x68, 0xbf, 0xa4, 0xba, 0x76, 0x69, 0x6e, 0x3d, 0x1e, 0x04, 0x34, 0x18, 0x14, - 0x86, 0x7f, 0x9d, 0x18, 0x0f, 0x4f, 0x1a, 0x10, 0x24, 0xe5, 0x22, 0x1c, 0xfb, 0x46, 0xf4, 0x93, 0xa9, 0x3c, 0xe6, - 0x68, 0xf1, 0x0e, 0xad, 0xce, 0x21, 0xa0, 0x97, 0x08, 0x25, 0x31, 0xaa, 0x42, 0x23, 0x82, 0xf2, 0xb4, 0xfc, 0xa5, - 0xaa, 0x0e, 0x01, 0x85, 0xb4, 0xaf, 0x28, 0x94, 0x6d, 0x12, 0x43, 0x33, 0xfc, 0x72, 0x3e, 0x59, 0xe8, 0x19, 0x18, - 0xc8, 0xf9, 0xd1, 0x42, 0xcf, 0xc2, 0x40, 0xce, 0x1f, 0x2d, 0x6a, 0xb7, 0x0e, 0x34, 0x01, 0xf1, 0x5c, 0x38, 0x3a, - 0x29, 0xad, 0xca, 0x16, 0xd0, 0xed, 0x7d, 0x04, 0xfd, 0x9f, 0xf6, 0x10, 0x74, 0x72, 0xa1, 0x3d, 0xb9, 0x01, 0x6d, - 0x87, 0x24, 0xb0, 0x57, 0x4c, 0x2a, 0x4c, 0x2c, 0xa2, 0x63, 0x36, 0x06, 0x43, 0x6c, 0xf5, 0xc1, 0x31, 0x1b, 0x4f, - 0x7d, 0x12, 0x04, 0x8c, 0xee, 0x4b, 0x03, 0x0e, 0x7e, 0x8b, 0x57, 0xe9, 0x93, 0xad, 0x40, 0x37, 0x7d, 0x77, 0x37, - 0xf4, 0x2e, 0xae, 0xe0, 0x54, 0xed, 0xee, 0x49, 0xe8, 0x26, 0xd3, 0x8e, 0xd5, 0x6b, 0x88, 0x1b, 0xf2, 0x2b, 0xa3, - 0xd1, 0xc8, 0xa6, 0x84, 0x84, 0x18, 0xce, 0xa1, 0x99, 0xd3, 0x72, 0xf9, 0xea, 0xd6, 0xb3, 0x05, 0x19, 0x66, 0x7a, - 0xcb, 0x64, 0x7d, 0x0f, 0x65, 0xd5, 0x63, 0x68, 0x87, 0xde, 0x23, 0xc7, 0xf7, 0x0f, 0xbe, 0xc9, 0xf8, 0x85, 0xc3, - 0xb5, 0x87, 0x73, 0xe1, 0xbb, 0xac, 0x19, 0x99, 0x43, 0xe7, 0xd9, 0xc7, 0xf1, 0x1e, 0xc6, 0xc9, 0x97, 0x59, 0x28, - 0x6f, 0xbc, 0xa6, 0xff, 0xad, 0xd2, 0x9b, 0x1d, 0x0e, 0x39, 0x5d, 0xc1, 0x8a, 0x9b, 0x55, 0xa1, 0xe1, 0x67, 0x91, - 0x37, 0x8e, 0x78, 0x4d, 0xa2, 0xaa, 0xfb, 0xbc, 0xb7, 0x11, 0x4b, 0x3b, 0xc6, 0x01, 0xc0, 0x89, 0x5a, 0x35, 0xec, - 0x4b, 0xe3, 0x5a, 0x1d, 0xc4, 0x88, 0x94, 0xb0, 0x55, 0xe2, 0x48, 0x28, 0x7f, 0x03, 0x10, 0x16, 0x43, 0x71, 0xbc, - 0x35, 0xac, 0xf7, 0xb0, 0x1f, 0xba, 0x40, 0xd3, 0x9c, 0x52, 0xcd, 0x00, 0x20, 0x09, 0xf8, 0xa3, 0xa7, 0x9b, 0x86, - 0xca, 0x36, 0xcf, 0x43, 0xcb, 0xea, 0x0a, 0xee, 0xe9, 0xa9, 0x2b, 0x19, 0x18, 0x57, 0x75, 0xec, 0x6d, 0xef, 0x6e, - 0x8f, 0x56, 0x91, 0xef, 0x6d, 0x52, 0xd3, 0x2c, 0x80, 0x14, 0x8d, 0x4b, 0x5f, 0xe8, 0xe9, 0x04, 0x68, 0xbd, 0xb6, - 0x54, 0xb4, 0xdf, 0x47, 0x31, 0x6a, 0x5c, 0x28, 0xb0, 0x0a, 0x13, 0x14, 0x0e, 0x11, 0x46, 0x08, 0xfd, 0xb9, 0x0c, - 0xb7, 0xbe, 0x20, 0x83, 0x68, 0xb8, 0x16, 0x1d, 0x8a, 0xc8, 0xf1, 0xa2, 0x6d, 0xa9, 0xaa, 0x39, 0x69, 0xda, 0x12, - 0x78, 0x13, 0x19, 0xb0, 0x9d, 0x7f, 0xda, 0x10, 0xb9, 0x0a, 0x17, 0x30, 0x7c, 0x4f, 0x5c, 0x0b, 0xa2, 0x9b, 0xda, - 0xd4, 0xdb, 0xb0, 0x43, 0x74, 0x34, 0xc5, 0xa3, 0x43, 0xee, 0xb9, 0x7b, 0x6e, 0x8b, 0xf8, 0xe6, 0x0b, 0xe4, 0xae, - 0xe9, 0xec, 0xa5, 0x08, 0x83, 0xba, 0x65, 0x03, 0xc5, 0x3a, 0x76, 0x82, 0x02, 0x0c, 0xe0, 0xf2, 0x19, 0xe8, 0xd8, - 0x60, 0x50, 0x11, 0x7c, 0x52, 0xd8, 0x36, 0x0d, 0xf2, 0x47, 0xbc, 0x1b, 0x3a, 0xbc, 0xb6, 0xe4, 0x81, 0x78, 0x85, - 0x7d, 0xa1, 0x84, 0xbb, 0x17, 0x14, 0x74, 0x47, 0x79, 0xb9, 0x2a, 0x5c, 0x95, 0x06, 0xa0, 0xca, 0x9e, 0xe7, 0x5a, - 0x53, 0xd2, 0x02, 0x56, 0x4a, 0xea, 0xce, 0x6f, 0x82, 0xe3, 0x96, 0x4c, 0x85, 0x6f, 0xd5, 0x8d, 0x2a, 0x8f, 0x25, - 0x8a, 0x74, 0xec, 0xd9, 0xce, 0xc1, 0x1a, 0x00, 0x4f, 0x61, 0x7b, 0x71, 0x26, 0xe0, 0x73, 0xa7, 0x5d, 0xb6, 0xcc, - 0x25, 0x50, 0xd4, 0xf7, 0xe3, 0xbc, 0xec, 0xf9, 0x72, 0x77, 0xb4, 0xbd, 0x87, 0xde, 0x88, 0x8d, 0xf1, 0xfa, 0x3a, - 0x6a, 0xfa, 0xd5, 0x33, 0x5c, 0x59, 0x0a, 0x72, 0x4f, 0x53, 0x3d, 0xc2, 0xe8, 0x10, 0x98, 0xa6, 0xfc, 0x84, 0x8d, - 0xa7, 0xc3, 0xa1, 0x21, 0x83, 0x5e, 0x33, 0x31, 0x14, 0xd8, 0x57, 0xd0, 0x3a, 0x33, 0x71, 0x8d, 0x4f, 0xdb, 0x57, - 0xd0, 0xea, 0x16, 0x65, 0x72, 0x67, 0x60, 0xf8, 0x40, 0x4b, 0xa6, 0x60, 0xaa, 0xf0, 0x86, 0x48, 0x25, 0xfb, 0x73, - 0x69, 0x1d, 0xf6, 0xed, 0x42, 0xa1, 0x85, 0x26, 0x7e, 0x95, 0x21, 0x7e, 0xea, 0x3a, 0xf3, 0x1f, 0xd3, 0x3e, 0x35, - 0x88, 0x85, 0x23, 0x31, 0x88, 0xf8, 0xc5, 0xa9, 0xb2, 0x9d, 0x10, 0x2a, 0x36, 0x1e, 0xba, 0xd6, 0x8d, 0x23, 0xa9, - 0xc2, 0x50, 0x0a, 0x8d, 0xa7, 0x86, 0xfb, 0x5e, 0xe8, 0xf0, 0x75, 0x98, 0xc5, 0x6d, 0xd6, 0x48, 0x6a, 0x8c, 0x53, - 0x61, 0xe2, 0x54, 0xca, 0x55, 0x24, 0x30, 0x50, 0x9e, 0x2d, 0x0c, 0x02, 0x4c, 0x62, 0x92, 0xb1, 0xb5, 0x10, 0x26, - 0x8c, 0x9d, 0x2b, 0x4c, 0x53, 0x17, 0xa9, 0xdf, 0x0c, 0x4c, 0x16, 0x34, 0xe4, 0xf7, 0x68, 0xb4, 0xa6, 0x6a, 0x0a, - 0x30, 0x8c, 0xa3, 0x54, 0xe3, 0x3f, 0x22, 0xd4, 0x66, 0x18, 0x00, 0xd8, 0xe6, 0x9d, 0xcc, 0x44, 0xf5, 0x4a, 0x20, - 0x04, 0x9a, 0xb3, 0x9f, 0x8a, 0xab, 0xbd, 0x59, 0x30, 0x8a, 0x76, 0x7b, 0xe5, 0xf3, 0x81, 0x13, 0xca, 0x53, 0x75, - 0x81, 0x7a, 0x21, 0x8b, 0xd7, 0x32, 0xe5, 0xad, 0x10, 0x99, 0x07, 0x92, 0xbd, 0xcf, 0x47, 0x70, 0x5e, 0xa1, 0x53, - 0xb9, 0xd9, 0x26, 0xca, 0x2c, 0x49, 0x32, 0x16, 0x18, 0x9b, 0x97, 0x60, 0x26, 0x35, 0x33, 0x86, 0x5f, 0x43, 0x9c, - 0xb1, 0xbd, 0x93, 0x70, 0x7b, 0x37, 0x0f, 0x0c, 0x51, 0xca, 0x45, 0x4b, 0x34, 0x6c, 0xed, 0x78, 0x3d, 0xb9, 0x26, - 0xdc, 0x87, 0x8d, 0x58, 0x93, 0x31, 0xc6, 0xb5, 0xb9, 0x91, 0xf5, 0xa3, 0x05, 0x1e, 0x8c, 0x29, 0xeb, 0x4f, 0x20, - 0xd3, 0x4a, 0xca, 0x3a, 0x5f, 0x18, 0x31, 0x93, 0x4a, 0xf4, 0x6e, 0xdf, 0xf8, 0xac, 0xee, 0x22, 0xea, 0xb7, 0xf6, - 0x7b, 0x52, 0x0f, 0x1b, 0xff, 0x41, 0x61, 0x0d, 0x2a, 0x23, 0x2e, 0x23, 0xca, 0x33, 0x07, 0xba, 0x69, 0x52, 0xc4, - 0xe9, 0xd9, 0x2a, 0x2e, 0x4a, 0x9e, 0x42, 0xa5, 0x9a, 0xba, 0x45, 0xbd, 0x09, 0xd8, 0x1b, 0x22, 0x49, 0xb2, 0x96, - 0xc6, 0x56, 0xec, 0xd2, 0x20, 0x3d, 0x77, 0x46, 0x5c, 0x7a, 0x51, 0xa1, 0x21, 0x2d, 0xf5, 0xce, 0x42, 0x25, 0xf3, - 0x57, 0xfc, 0x67, 0x50, 0x2b, 0xd0, 0xd1, 0x26, 0xc5, 0x78, 0x0a, 0x8c, 0xf8, 0x7e, 0x30, 0xab, 0x7b, 0x88, 0x8b, - 0x26, 0x28, 0xf5, 0x9e, 0xd8, 0xf1, 0x4b, 0x93, 0x87, 0x77, 0x21, 0xe7, 0x0c, 0x3e, 0xbd, 0x9f, 0x25, 0x6a, 0xad, - 0x23, 0x31, 0x52, 0x33, 0x80, 0xa6, 0x83, 0x32, 0xe7, 0xb1, 0x08, 0x66, 0x3d, 0x93, 0x18, 0xf5, 0xb8, 0xfe, 0x05, - 0x1a, 0x6a, 0xbf, 0x59, 0x59, 0x9e, 0x55, 0x9b, 0xaf, 0xe1, 0xc0, 0xa6, 0xb6, 0x82, 0x1e, 0xaf, 0x2b, 0x79, 0x79, - 0xa9, 0xba, 0xed, 0x17, 0x62, 0xe4, 0x74, 0x8d, 0x6b, 0xe9, 0xbc, 0x5a, 0xb0, 0x5e, 0x77, 0xba, 0x59, 0xdc, 0xcd, - 0x32, 0x1a, 0x08, 0x6b, 0x7b, 0x9f, 0x68, 0xfe, 0xac, 0xd9, 0x76, 0x1f, 0x6f, 0x41, 0xcc, 0x02, 0x80, 0x48, 0x0f, - 0xa2, 0x60, 0x99, 0xa5, 0x3c, 0xa0, 0xf2, 0x2e, 0x8e, 0xb2, 0x50, 0x7a, 0x39, 0xcb, 0xf8, 0x69, 0xd3, 0x58, 0xeb, - 0xac, 0x50, 0x86, 0xd6, 0x46, 0x77, 0xba, 0xca, 0x10, 0xdb, 0x4f, 0xe2, 0x6c, 0x01, 0xee, 0x8f, 0x19, 0x0a, 0x0d, - 0x9d, 0x65, 0xa4, 0x89, 0x86, 0xef, 0xba, 0x63, 0x90, 0x51, 0x9c, 0xac, 0xf3, 0x4a, 0xba, 0xd5, 0x67, 0x6d, 0x24, - 0xcc, 0x3d, 0x44, 0xbf, 0x8a, 0xc1, 0xa3, 0xdc, 0xe7, 0xb5, 0xd1, 0xc9, 0xb4, 0x8c, 0xb4, 0x3b, 0x3f, 0xa9, 0x97, - 0x59, 0xaa, 0x75, 0xd8, 0x3e, 0xc3, 0xde, 0x1a, 0x93, 0xde, 0x84, 0xd4, 0x30, 0x12, 0x5f, 0xce, 0xa8, 0x11, 0x02, - 0xda, 0x72, 0xfc, 0x3d, 0x3e, 0xc3, 0xd0, 0x14, 0x58, 0xaa, 0xb8, 0x85, 0xdd, 0xf0, 0x35, 0x9f, 0xac, 0x5a, 0x00, - 0x82, 0x59, 0xf9, 0x7a, 0x17, 0xaf, 0x84, 0xfa, 0x4c, 0x9b, 0x01, 0x20, 0x0b, 0x4a, 0xb9, 0xe3, 0xa7, 0x54, 0x3a, - 0x58, 0xa2, 0x68, 0x7b, 0x39, 0x7d, 0xa3, 0x63, 0xe3, 0xfb, 0xf4, 0x5c, 0xc0, 0x76, 0x21, 0xbf, 0x75, 0xa7, 0x5e, - 0xa2, 0x22, 0xb5, 0x6d, 0xd6, 0x3d, 0x7c, 0xb9, 0x41, 0x93, 0x30, 0x82, 0x32, 0x65, 0x0a, 0x60, 0x70, 0x53, 0x8d, - 0x82, 0x49, 0xab, 0x91, 0xb0, 0xa5, 0x9e, 0x64, 0xb9, 0xe9, 0x83, 0x53, 0xdd, 0x21, 0xe8, 0xb9, 0x55, 0xce, 0x17, - 0x2d, 0xfb, 0xb5, 0x82, 0xa3, 0x93, 0xab, 0x21, 0x6a, 0xe6, 0xbd, 0xb6, 0x23, 0x43, 0xca, 0x65, 0x18, 0x08, 0xa6, - 0x1c, 0xf3, 0xf4, 0xd8, 0x7a, 0x46, 0x44, 0xf7, 0x9c, 0x7d, 0xa6, 0x5b, 0x75, 0x25, 0x01, 0xd1, 0xf1, 0xbb, 0xc7, - 0xaf, 0xae, 0xe2, 0x4b, 0x83, 0xa2, 0xd4, 0xb0, 0x88, 0x51, 0xa6, 0x7d, 0x95, 0x84, 0xc1, 0xfb, 0xe5, 0xfd, 0x4f, - 0x2a, 0x4b, 0xed, 0xf7, 0x60, 0x6b, 0x45, 0x55, 0xbf, 0x94, 0xbc, 0x68, 0x0a, 0xb0, 0xee, 0xb2, 0x44, 0x81, 0xdc, - 0xef, 0x6d, 0x9a, 0xf9, 0x26, 0x6a, 0xdc, 0x6c, 0x58, 0x6f, 0x5c, 0xb7, 0x4b, 0x6d, 0xc9, 0x8e, 0xac, 0x44, 0xce, - 0x2c, 0x06, 0x33, 0x7e, 0x54, 0x18, 0x94, 0x86, 0x2d, 0xaa, 0x52, 0xf1, 0x7b, 0x23, 0x82, 0x53, 0xc7, 0xaa, 0xc2, - 0x98, 0x06, 0xcc, 0xb6, 0xa2, 0xd6, 0xa0, 0x0e, 0x4a, 0x69, 0x6b, 0x02, 0xb2, 0xfd, 0x8b, 0x15, 0xd4, 0xfc, 0xfe, - 0xb7, 0x31, 0xe4, 0x6b, 0x4a, 0x41, 0x25, 0x01, 0x3b, 0x83, 0x46, 0x4f, 0x95, 0x30, 0x90, 0x82, 0xe0, 0x09, 0x50, - 0xbe, 0x88, 0x1a, 0xab, 0xfd, 0xbe, 0x3a, 0x35, 0x46, 0x5b, 0x40, 0x68, 0x21, 0x3d, 0xba, 0xec, 0xe3, 0xb6, 0xd6, - 0x81, 0xc4, 0x83, 0x13, 0x6c, 0xe7, 0xea, 0x1a, 0x8d, 0x84, 0xe6, 0xf7, 0x8d, 0x06, 0xbc, 0xa6, 0x15, 0x28, 0xd4, - 0x73, 0x1c, 0x0d, 0x9d, 0x1d, 0x52, 0x10, 0xb1, 0x41, 0x0b, 0xfb, 0xee, 0xf8, 0xd0, 0xec, 0xeb, 0x79, 0xb2, 0x20, - 0x35, 0x95, 0xee, 0x73, 0xb7, 0x84, 0xac, 0x55, 0x87, 0xb2, 0xf2, 0x00, 0xc7, 0x0b, 0x25, 0xf3, 0x77, 0x98, 0xd4, - 0x28, 0x8d, 0x09, 0x8d, 0x11, 0x0b, 0x58, 0x12, 0xb4, 0xd7, 0x03, 0xf5, 0xcb, 0x20, 0x54, 0x38, 0xd3, 0x13, 0x89, - 0x4f, 0x29, 0x57, 0x9f, 0x16, 0xa4, 0x9e, 0x16, 0xcc, 0x81, 0x5e, 0xfa, 0x56, 0x7e, 0x65, 0xe3, 0xa3, 0xfd, 0xbd, - 0x6b, 0x2e, 0xac, 0x63, 0x88, 0x8b, 0x2d, 0xfc, 0xe6, 0xd4, 0x14, 0x80, 0x0d, 0x4f, 0x75, 0x59, 0xbe, 0x51, 0x13, - 0x99, 0xc5, 0x21, 0x89, 0x40, 0xb2, 0xdd, 0xdc, 0xdc, 0x46, 0xb0, 0xed, 0x2d, 0xd4, 0x86, 0xfa, 0xcb, 0xdb, 0xee, - 0x77, 0x0c, 0x2f, 0xf7, 0xe4, 0xde, 0x4d, 0x1b, 0xca, 0x97, 0x77, 0xaf, 0x92, 0xff, 0xab, 0x4a, 0xee, 0xb6, 0xca, - 0xac, 0xdb, 0xe2, 0xfd, 0xae, 0xe3, 0x96, 0x63, 0x34, 0x08, 0xac, 0x29, 0x30, 0x90, 0x9e, 0x34, 0xa6, 0x89, 0x8e, - 0xae, 0xcc, 0x98, 0xc1, 0xa3, 0x0b, 0xd0, 0x1c, 0xa6, 0xf3, 0x3c, 0x06, 0xe0, 0x00, 0xff, 0xc8, 0x23, 0xd4, 0x3f, - 0x9d, 0xe7, 0xc1, 0x59, 0x30, 0x28, 0x07, 0x81, 0xfe, 0xc4, 0x35, 0x27, 0x58, 0x80, 0xce, 0x2d, 0x66, 0x10, 0x77, - 0xd2, 0x9a, 0x39, 0xc4, 0xc7, 0xc9, 0x74, 0x30, 0x88, 0xc9, 0x16, 0x40, 0xfa, 0xe2, 0x85, 0x75, 0x0e, 0x2a, 0xf4, - 0x82, 0x6c, 0xd5, 0x5d, 0x34, 0x2b, 0xf6, 0xaa, 0x9d, 0xe6, 0xfd, 0x7e, 0x3e, 0x2f, 0x07, 0x41, 0xa3, 0xc2, 0xc2, - 0x78, 0xff, 0xd1, 0xe6, 0x97, 0x46, 0x27, 0x4d, 0x30, 0x62, 0xed, 0x29, 0xaa, 0x57, 0x3c, 0xcd, 0x68, 0xe3, 0x76, - 0xac, 0x94, 0x2f, 0x20, 0x8a, 0x07, 0x86, 0xac, 0x95, 0x77, 0xef, 0xe0, 0x75, 0xb9, 0xf1, 0xe6, 0x88, 0x02, 0xec, - 0xa6, 0x30, 0x4e, 0x6a, 0x2e, 0xba, 0xa8, 0x89, 0x67, 0xb0, 0xd3, 0xd5, 0x5b, 0x89, 0x56, 0xe3, 0xbd, 0x78, 0xdf, - 0x6c, 0xfc, 0x8d, 0x3c, 0xd0, 0x65, 0x1e, 0x5c, 0x00, 0xe2, 0xec, 0x41, 0x5c, 0x1d, 0x60, 0xa9, 0x07, 0xc1, 0xc0, - 0x22, 0x87, 0xb4, 0xab, 0xd5, 0x43, 0x11, 0xa9, 0xf3, 0x18, 0x0c, 0x98, 0x4c, 0x43, 0x6a, 0x32, 0xed, 0xc5, 0x0a, - 0xd2, 0xc6, 0x5a, 0x0b, 0x68, 0xc3, 0x61, 0xb1, 0x67, 0x37, 0xec, 0x4e, 0xb7, 0x0e, 0x85, 0x12, 0x06, 0xb2, 0xae, - 0x9b, 0x87, 0x5a, 0xc3, 0x13, 0x41, 0x0f, 0xaa, 0xd1, 0x7e, 0x7a, 0x28, 0x4f, 0xda, 0x63, 0x01, 0x2e, 0x7a, 0xf8, - 0xf2, 0xb9, 0xc0, 0x8b, 0xf6, 0x1e, 0xf2, 0x9c, 0xf9, 0x54, 0xf9, 0x20, 0x36, 0xdc, 0x32, 0x7c, 0x68, 0x1f, 0xdf, - 0x0a, 0x64, 0x52, 0x77, 0x34, 0xb5, 0xb5, 0x3b, 0x1a, 0xc7, 0x04, 0xfa, 0x4d, 0x39, 0x4a, 0x99, 0x98, 0x5a, 0x96, - 0xec, 0xa4, 0x97, 0x2b, 0x6f, 0xa8, 0x94, 0x9d, 0x2c, 0xdb, 0x9c, 0x5f, 0xda, 0x48, 0xe8, 0xf7, 0xb5, 0x3b, 0x10, - 0xbe, 0x51, 0xeb, 0x0d, 0x79, 0xd9, 0x10, 0xb1, 0x1c, 0x62, 0x06, 0x8e, 0x17, 0x52, 0xb9, 0x76, 0x17, 0x4d, 0x55, - 0xdd, 0xde, 0x56, 0x2e, 0x68, 0x89, 0xb7, 0x52, 0x60, 0x15, 0xa9, 0xd3, 0xeb, 0xa9, 0xc4, 0xbb, 0x3e, 0x8a, 0xed, - 0x47, 0xc0, 0x36, 0x36, 0x8e, 0xc6, 0xc6, 0x2d, 0x62, 0x8b, 0xaf, 0xa2, 0x8a, 0x16, 0x1c, 0x20, 0xb8, 0xdb, 0x92, - 0x5a, 0x9a, 0x39, 0xc4, 0x7d, 0xc5, 0x03, 0xb4, 0xef, 0xe2, 0x70, 0x26, 0x15, 0x60, 0x5b, 0xd7, 0x3a, 0x67, 0xb5, - 0x1c, 0xb0, 0x99, 0xe8, 0xf9, 0xa7, 0x55, 0x23, 0x11, 0xc3, 0x2a, 0x1b, 0x29, 0x2b, 0xb4, 0x7b, 0xa5, 0x4b, 0xb8, - 0xf8, 0x02, 0xbc, 0x6c, 0xdf, 0xad, 0xec, 0x3e, 0x5b, 0x62, 0xff, 0x30, 0xaf, 0x9a, 0xe0, 0x91, 0xd7, 0x78, 0x7b, - 0x0f, 0x13, 0x5f, 0x2b, 0x85, 0xf0, 0x2a, 0xa5, 0xa1, 0x04, 0x60, 0x90, 0x04, 0x35, 0x5c, 0x69, 0xdb, 0x0c, 0x52, - 0x19, 0xc3, 0xee, 0x57, 0x6f, 0xf5, 0x7f, 0x5a, 0x85, 0x8b, 0x4a, 0x16, 0x63, 0x12, 0xe8, 0x9c, 0x6a, 0xb9, 0x09, - 0x2c, 0x78, 0xb6, 0x4f, 0x8e, 0x40, 0x61, 0x27, 0x80, 0x1b, 0x4a, 0xd8, 0x5f, 0x78, 0x1b, 0xca, 0xd9, 0x67, 0x2b, - 0x79, 0x72, 0xfb, 0x92, 0x0a, 0x9a, 0x90, 0xa9, 0xb0, 0xfb, 0xb7, 0xb5, 0x61, 0x9f, 0x85, 0x72, 0x24, 0x05, 0x2e, - 0x0e, 0x3a, 0x07, 0xb0, 0x3f, 0xc8, 0x65, 0x6c, 0x3e, 0x93, 0x7e, 0x5f, 0xbd, 0x7f, 0x9a, 0x67, 0xc9, 0xa7, 0xbd, - 0xf7, 0x86, 0xa7, 0x59, 0x32, 0xa0, 0x12, 0x31, 0xb5, 0xae, 0x8a, 0xe1, 0x52, 0xbb, 0x18, 0x37, 0x48, 0x46, 0x7c, - 0x27, 0x75, 0x88, 0x11, 0xe3, 0x8b, 0xec, 0x91, 0x94, 0x9c, 0x2e, 0xeb, 0xce, 0x9e, 0x6b, 0xd1, 0x0c, 0x1a, 0xc3, - 0xed, 0x79, 0x2f, 0xe9, 0x15, 0xa0, 0x02, 0x44, 0xf7, 0x2c, 0x70, 0x0d, 0x6f, 0x2e, 0x89, 0xc6, 0x96, 0x9e, 0xb6, - 0x44, 0x03, 0x77, 0xca, 0x84, 0xa4, 0xda, 0x38, 0xc0, 0x22, 0xd6, 0xf5, 0xa7, 0xb0, 0x00, 0xa0, 0x56, 0x83, 0xf4, - 0x4a, 0x5f, 0x10, 0xaa, 0x92, 0x10, 0x8c, 0x4e, 0x24, 0xbc, 0x0c, 0x68, 0x9c, 0x99, 0x44, 0x0b, 0x1b, 0x1c, 0xd0, - 0x57, 0x95, 0x49, 0x34, 0x36, 0xe4, 0x01, 0xe5, 0x36, 0x0d, 0x60, 0xf0, 0x41, 0x92, 0x44, 0x7f, 0x5a, 0x9a, 0x24, - 0x10, 0x94, 0xa0, 0x7c, 0x83, 0xfe, 0x5e, 0x7a, 0x3e, 0x96, 0xff, 0xf0, 0x0e, 0xa5, 0x97, 0x61, 0x01, 0x32, 0x45, - 0x5d, 0x31, 0xcd, 0xd8, 0x49, 0xd6, 0x6d, 0x4c, 0xe2, 0x79, 0xda, 0x5d, 0x17, 0xca, 0xa5, 0x0b, 0xfc, 0xca, 0x32, - 0xc4, 0xb1, 0x7e, 0x1a, 0xaf, 0xd8, 0x69, 0xc8, 0x35, 0x5e, 0xfa, 0xd3, 0x78, 0x85, 0x33, 0x44, 0xab, 0x56, 0x02, - 0x51, 0xfe, 0xab, 0x36, 0x70, 0x88, 0xfb, 0x04, 0x83, 0x5c, 0x54, 0xde, 0x03, 0x81, 0xbc, 0xad, 0x20, 0x22, 0xcd, - 0xec, 0x3a, 0x8c, 0x48, 0xb5, 0x97, 0x64, 0xbe, 0xfc, 0x87, 0xcc, 0x84, 0xf7, 0x0d, 0x3c, 0x36, 0x9b, 0x65, 0x53, - 0xcc, 0x17, 0x2a, 0x98, 0x83, 0xfb, 0x44, 0xc5, 0xa5, 0xa8, 0xfc, 0x27, 0xec, 0x82, 0x17, 0xe3, 0xc1, 0xeb, 0x35, - 0x02, 0xec, 0x57, 0xfe, 0x93, 0x37, 0x66, 0x3f, 0x58, 0x37, 0xbe, 0xcc, 0x44, 0x7c, 0xe0, 0xa3, 0x5b, 0xca, 0x47, - 0x1b, 0x2f, 0xd3, 0xaf, 0x0d, 0x28, 0x91, 0x51, 0x59, 0xf1, 0xd5, 0x8a, 0xa7, 0xb3, 0x9b, 0x24, 0xca, 0x46, 0x15, - 0x17, 0x30, 0xbd, 0xe0, 0x78, 0x97, 0xac, 0xcf, 0xb3, 0xe4, 0x15, 0xc4, 0x1e, 0x58, 0x49, 0x85, 0xc5, 0x0f, 0xcb, - 0x4c, 0x2d, 0x66, 0x21, 0x2b, 0x29, 0x78, 0x30, 0xfb, 0x94, 0x44, 0x3f, 0x2c, 0x3d, 0x10, 0x39, 0x33, 0x65, 0xdb, - 0xda, 0x11, 0x6a, 0xe3, 0xeb, 0x48, 0xb7, 0xda, 0x02, 0x00, 0xee, 0xd9, 0x22, 0x8d, 0x24, 0x13, 0xc3, 0x49, 0xcd, - 0xb8, 0x49, 0x2f, 0x30, 0x35, 0xae, 0x59, 0x45, 0x13, 0x67, 0x21, 0x03, 0x7a, 0x7f, 0x9a, 0xeb, 0xe7, 0x0c, 0xee, - 0x3f, 0x68, 0x0d, 0x5c, 0x1e, 0x17, 0xfd, 0xbe, 0x3c, 0x2e, 0x76, 0xbb, 0xf2, 0x24, 0xee, 0xf7, 0xe5, 0x49, 0x6c, - 0xf8, 0x07, 0xa5, 0xd8, 0x36, 0xe6, 0x06, 0x09, 0xcd, 0x25, 0x44, 0x2d, 0x1a, 0xc1, 0x1f, 0x9a, 0xe5, 0x5c, 0x44, - 0xf9, 0x71, 0xd2, 0xef, 0xf7, 0x96, 0x33, 0x31, 0xc8, 0x87, 0x49, 0x94, 0x0f, 0x13, 0xcf, 0x09, 0xf1, 0xa5, 0xe7, - 0x84, 0xa8, 0x68, 0xe0, 0x0a, 0xce, 0x0c, 0x40, 0x14, 0xf0, 0xe9, 0x1f, 0xd5, 0xb5, 0x14, 0xba, 0x96, 0x58, 0xd5, - 0x92, 0xe8, 0x0a, 0x6a, 0x76, 0x53, 0x84, 0x25, 0x96, 0x42, 0x97, 0xec, 0xd7, 0x25, 0xf0, 0x44, 0x39, 0xaf, 0xb6, - 0xc0, 0xc0, 0x46, 0x78, 0xe7, 0x30, 0xe1, 0x24, 0xd6, 0x35, 0xa0, 0x9d, 0x6e, 0x6b, 0x7a, 0x41, 0x57, 0xf4, 0x12, - 0xf9, 0xd9, 0x0b, 0x30, 0x58, 0x3a, 0x66, 0xf9, 0x74, 0x30, 0xb8, 0x20, 0x2b, 0x56, 0xce, 0xc3, 0x78, 0x10, 0xae, - 0x67, 0xf9, 0xf0, 0x22, 0xba, 0x20, 0xe4, 0x9b, 0x62, 0x41, 0x7b, 0xab, 0x51, 0xf9, 0x29, 0x83, 0xf0, 0x7e, 0xe9, - 0x2c, 0xcc, 0x4c, 0x9c, 0x8f, 0xd5, 0xe8, 0x96, 0xae, 0x20, 0x7e, 0x0d, 0xdc, 0x48, 0x48, 0x04, 0x1d, 0xb9, 0xa4, - 0x2b, 0xba, 0xa6, 0xd2, 0xcc, 0x30, 0x46, 0xeb, 0xb6, 0xc7, 0x49, 0x02, 0x8e, 0xc9, 0xae, 0xf8, 0x68, 0xac, 0x0a, - 0xef, 0xfa, 0x8e, 0xd0, 0x5e, 0x2f, 0x71, 0x83, 0xf4, 0x4b, 0x7b, 0x90, 0x80, 0x11, 0x19, 0xa9, 0x81, 0x32, 0x23, - 0x23, 0xa9, 0x99, 0x54, 0x1c, 0x92, 0xd8, 0x1f, 0x12, 0x35, 0x0e, 0x89, 0x3f, 0x0e, 0xb9, 0x1e, 0x07, 0xe4, 0xee, - 0x97, 0x6c, 0x4c, 0x53, 0x36, 0xa6, 0x6b, 0x35, 0x2a, 0xf4, 0x8a, 0x9e, 0x6b, 0xea, 0x78, 0xc6, 0x9e, 0xc2, 0x81, - 0x3d, 0x08, 0xf3, 0x59, 0x3c, 0x7c, 0x1a, 0x3d, 0x25, 0xe4, 0x1b, 0x49, 0xaf, 0xd5, 0xa5, 0x0c, 0x02, 0x21, 0x5e, - 0x81, 0x73, 0xa9, 0x0b, 0x75, 0x72, 0x65, 0x76, 0x1c, 0x3e, 0x5d, 0x36, 0x9e, 0xce, 0x21, 0xa2, 0x0f, 0x5a, 0xa9, - 0xf4, 0xfb, 0xe1, 0x05, 0x2b, 0xe7, 0x67, 0xe1, 0x98, 0x00, 0x0e, 0x8f, 0x1e, 0xce, 0x8b, 0xd1, 0x2d, 0xbd, 0x18, - 0x6d, 0x08, 0x58, 0x78, 0x8d, 0xa7, 0xeb, 0x63, 0x16, 0x4f, 0x07, 0x83, 0x35, 0x52, 0x75, 0x95, 0x7b, 0x4d, 0x16, - 0xf4, 0x02, 0x27, 0x82, 0x00, 0x43, 0x9f, 0x89, 0xb5, 0xa1, 0xe1, 0x4f, 0x19, 0x7c, 0xbc, 0x61, 0x17, 0xa3, 0x0d, - 0xbd, 0x65, 0x4f, 0x77, 0xe3, 0x29, 0x30, 0x53, 0xab, 0x59, 0xb8, 0x39, 0xbe, 0x9c, 0x5d, 0xb2, 0x4d, 0xb4, 0x39, - 0x81, 0x86, 0x5e, 0xb1, 0x0d, 0x02, 0x2e, 0xa5, 0x0f, 0x97, 0x83, 0xa7, 0xe4, 0x70, 0x30, 0x48, 0x49, 0x14, 0x5e, - 0x87, 0x5e, 0x2b, 0x9f, 0xd2, 0x0d, 0xa1, 0x2b, 0x76, 0x8b, 0xa3, 0x71, 0xc9, 0xf0, 0x83, 0x73, 0xb6, 0xa9, 0xaf, - 0x43, 0x6f, 0x37, 0xe7, 0xa2, 0x13, 0xc4, 0x08, 0x7d, 0x0d, 0x1c, 0xcd, 0x72, 0x61, 0x26, 0xe0, 0xc9, 0x5c, 0x64, - 0xb4, 0x28, 0x34, 0x03, 0x71, 0x56, 0x02, 0x62, 0x49, 0xd4, 0xfd, 0x66, 0xa3, 0x33, 0x58, 0xce, 0xfd, 0x7e, 0xaf, - 0x32, 0xf4, 0x00, 0x91, 0x33, 0x3b, 0xe9, 0x41, 0xcf, 0xa7, 0x07, 0xf8, 0x89, 0x5e, 0x35, 0x88, 0x93, 0xf9, 0xcb, - 0x32, 0x7a, 0xe9, 0xd1, 0x87, 0xdf, 0xba, 0x29, 0x8f, 0xcc, 0xff, 0x73, 0xca, 0x53, 0xe4, 0xd1, 0xeb, 0xca, 0x03, - 0x62, 0xf3, 0xd6, 0xa4, 0xd2, 0x48, 0x54, 0xa3, 0xb3, 0x55, 0x0c, 0xda, 0x48, 0xd4, 0x36, 0xe8, 0x27, 0xb4, 0xb0, - 0x82, 0x08, 0x39, 0x47, 0xcf, 0xc0, 0x20, 0x15, 0x42, 0xe5, 0xa8, 0x45, 0x89, 0x86, 0x20, 0xb9, 0x2c, 0xb9, 0x0a, - 0x9f, 0x43, 0xa8, 0x3a, 0x7d, 0x9c, 0x89, 0xb0, 0xa1, 0xc7, 0xa1, 0x0f, 0x00, 0xff, 0xd7, 0x1e, 0xb9, 0x28, 0xf9, - 0x25, 0x9e, 0xcd, 0x6d, 0x82, 0x51, 0xb0, 0x5c, 0x34, 0x43, 0xdb, 0x20, 0xf6, 0x63, 0x49, 0xb0, 0x1e, 0x49, 0xe3, - 0x51, 0x69, 0x8e, 0x08, 0x3f, 0x8a, 0x8f, 0xa2, 0xa7, 0xb1, 0x21, 0x91, 0x1c, 0x49, 0x24, 0x1f, 0x00, 0xe1, 0x24, - 0xe8, 0x2f, 0xee, 0x9a, 0xec, 0x5a, 0xa8, 0xbd, 0x7e, 0x0f, 0xfe, 0xb5, 0x64, 0x5a, 0x76, 0xaf, 0x7a, 0xec, 0x2b, - 0x82, 0x3c, 0x98, 0x00, 0xaf, 0x0f, 0xff, 0x5a, 0xe2, 0x0c, 0x5a, 0xcf, 0x17, 0xd5, 0x99, 0x99, 0x37, 0xb8, 0x91, - 0xd7, 0x65, 0xed, 0xba, 0x7c, 0xc1, 0x0f, 0xf8, 0x6d, 0xc5, 0x45, 0x5a, 0x1e, 0xfc, 0x5c, 0xb5, 0xf1, 0x9c, 0xca, - 0xf5, 0xca, 0xc5, 0x59, 0x51, 0xc6, 0xa9, 0x9e, 0xd4, 0xc5, 0x58, 0xc3, 0x36, 0xfc, 0x1e, 0x51, 0x57, 0xd2, 0x72, - 0xf4, 0x94, 0x72, 0xd5, 0x4c, 0xb9, 0x58, 0xe7, 0xf9, 0x4f, 0x7b, 0xa9, 0x38, 0xc5, 0xcd, 0x14, 0xa4, 0x4a, 0x2d, - 0x17, 0x50, 0x3d, 0x47, 0x2d, 0x77, 0x4b, 0xb3, 0x03, 0x9c, 0xdb, 0xa6, 0xfa, 0x58, 0x99, 0x5d, 0x78, 0xc9, 0x8d, - 0xfb, 0x93, 0x29, 0xc3, 0x82, 0x51, 0x68, 0xb3, 0xea, 0x4a, 0xdb, 0x17, 0x5a, 0xa7, 0x61, 0xb8, 0xf2, 0xe3, 0x05, - 0xa4, 0x0b, 0x18, 0xc7, 0x8b, 0x92, 0x89, 0x71, 0x7b, 0xf4, 0x56, 0x10, 0x5f, 0xb3, 0x15, 0x48, 0xbf, 0xdf, 0x13, - 0xde, 0xae, 0xeb, 0x68, 0xbb, 0x27, 0x4e, 0x19, 0x95, 0xab, 0x58, 0xfc, 0x18, 0xaf, 0x0c, 0x64, 0xb2, 0x3a, 0x1e, - 0x1b, 0x63, 0x3a, 0xfd, 0x39, 0x09, 0xfd, 0x42, 0x28, 0xf8, 0xac, 0x97, 0x56, 0x9e, 0xdc, 0x1e, 0x96, 0x71, 0x8d, - 0x5e, 0x89, 0x2b, 0xdd, 0x37, 0x23, 0x85, 0xd4, 0x23, 0x5f, 0x35, 0x05, 0xf4, 0x66, 0xec, 0x9b, 0xa9, 0x30, 0x6f, - 0x77, 0x8c, 0xb9, 0x42, 0xb0, 0x52, 0x65, 0xb7, 0xef, 0xd4, 0x98, 0x8a, 0x19, 0x4c, 0xb1, 0xed, 0x2c, 0x26, 0xdd, - 0xca, 0x3f, 0xed, 0xdc, 0xaf, 0xf3, 0x0e, 0x77, 0x45, 0xfd, 0x16, 0xb8, 0xd0, 0xac, 0x28, 0xab, 0xb6, 0x6c, 0xd8, - 0x36, 0xde, 0xc8, 0x42, 0xb1, 0x01, 0x96, 0x3d, 0xf7, 0x2d, 0x3c, 0x40, 0xdc, 0x84, 0x7b, 0x76, 0x51, 0xc3, 0x8d, - 0xe1, 0xeb, 0x4a, 0xf2, 0x5d, 0x69, 0xcc, 0xa5, 0x4f, 0x95, 0x26, 0x86, 0x93, 0xc5, 0x88, 0x8b, 0x74, 0x51, 0x67, - 0x76, 0x2d, 0x7c, 0xc1, 0xcb, 0x70, 0xce, 0x17, 0x46, 0x37, 0xa5, 0x4b, 0x2f, 0x98, 0x0e, 0x99, 0x42, 0xb7, 0x2b, - 0x8d, 0x95, 0x12, 0x71, 0x6b, 0x96, 0x09, 0x94, 0xa5, 0xac, 0x95, 0xf0, 0xa6, 0x68, 0xd9, 0x4a, 0x1a, 0x79, 0xcf, - 0x1c, 0xdc, 0xc7, 0x7e, 0x43, 0x4c, 0x64, 0x13, 0x98, 0x14, 0x0d, 0x1d, 0xd0, 0xae, 0xba, 0xf0, 0xcd, 0xa8, 0x07, - 0x83, 0xdc, 0x92, 0x44, 0xac, 0x20, 0xc5, 0x0a, 0xd6, 0x35, 0x2b, 0xe6, 0xf9, 0x82, 0x5e, 0x30, 0x39, 0x4f, 0x17, - 0x74, 0xc5, 0xe4, 0x7c, 0x8d, 0x37, 0xa1, 0x0b, 0x38, 0x21, 0xc9, 0x36, 0x56, 0x0a, 0xd8, 0x0b, 0xbc, 0xbc, 0xe1, - 0x99, 0xaa, 0x69, 0xd9, 0xa5, 0xe2, 0x00, 0xe3, 0xf3, 0x32, 0x0c, 0xcb, 0xe1, 0x05, 0x58, 0x4b, 0x1c, 0x86, 0xab, - 0x39, 0x5f, 0xa8, 0xdf, 0x10, 0x75, 0x3e, 0x09, 0x15, 0xbb, 0x60, 0xf7, 0x02, 0x99, 0x5e, 0xcd, 0xf9, 0x42, 0x8d, - 0x84, 0x2e, 0xf8, 0xca, 0x1a, 0x9b, 0xc4, 0x9e, 0xa0, 0x65, 0x16, 0xcf, 0xc7, 0x8b, 0x28, 0xae, 0x61, 0x19, 0x7e, - 0x50, 0x33, 0xd3, 0x92, 0xff, 0xe4, 0x6a, 0x43, 0x13, 0x7d, 0x83, 0x55, 0xe4, 0x0f, 0x8f, 0x8f, 0x2e, 0x81, 0x8c, - 0x9d, 0x5d, 0xc9, 0xcc, 0x87, 0xbe, 0x8f, 0x0c, 0xee, 0xb9, 0x29, 0x67, 0x5c, 0x05, 0x89, 0x32, 0x70, 0xf7, 0x6a, - 0x96, 0x8c, 0xb5, 0x08, 0xdf, 0x3f, 0x2a, 0x8a, 0x3e, 0x93, 0xa6, 0x01, 0xdd, 0x47, 0x82, 0x39, 0xd0, 0x7b, 0x85, - 0x0e, 0x97, 0xd5, 0x36, 0x13, 0xf0, 0x17, 0x09, 0xf2, 0x5b, 0xa1, 0x57, 0x35, 0x06, 0x55, 0xb4, 0x8b, 0x58, 0xfa, - 0xf7, 0x11, 0x3f, 0xca, 0xe6, 0x3f, 0xcd, 0x3d, 0x5e, 0x49, 0x18, 0xfc, 0x90, 0x9a, 0x4d, 0x32, 0x6f, 0xaf, 0xd8, - 0x77, 0xd0, 0x51, 0x8f, 0x5a, 0xe3, 0x7d, 0xf5, 0x82, 0x53, 0x88, 0x51, 0x42, 0xd1, 0x49, 0x30, 0x80, 0xdb, 0x25, - 0xa4, 0xb8, 0x1b, 0xec, 0xb6, 0x79, 0xcd, 0x8b, 0x82, 0xf3, 0x75, 0x55, 0x05, 0x7e, 0x40, 0xc3, 0xf9, 0x62, 0x3f, - 0x84, 0xe1, 0x98, 0xb6, 0xae, 0x61, 0x10, 0x66, 0x0c, 0x23, 0x21, 0x78, 0xfd, 0x8b, 0x1e, 0xd1, 0x24, 0x5e, 0xfd, - 0xc0, 0x3f, 0x67, 0xbc, 0x50, 0x44, 0x1a, 0x44, 0x48, 0xdd, 0xc4, 0x37, 0x32, 0x4d, 0x0a, 0x28, 0x04, 0x18, 0x05, - 0x54, 0x62, 0x43, 0x53, 0xf1, 0xb7, 0x5a, 0x7c, 0xf0, 0x53, 0xd3, 0xf1, 0x68, 0x5c, 0xb7, 0x3a, 0xa3, 0x82, 0xce, - 0x40, 0x8f, 0x5a, 0x51, 0x4f, 0x83, 0x56, 0x82, 0x69, 0xa4, 0x79, 0xeb, 0x1e, 0x02, 0xaf, 0x4c, 0x8b, 0x77, 0x1e, - 0xd0, 0xed, 0x99, 0x0f, 0x9e, 0x3c, 0xa6, 0x67, 0x0e, 0x3d, 0xb9, 0x62, 0x27, 0x55, 0x0f, 0xb5, 0xf7, 0x66, 0x84, - 0x82, 0x7e, 0x1f, 0x53, 0xa0, 0x1b, 0x41, 0xed, 0x5d, 0xdd, 0x2b, 0xb9, 0xcf, 0xe1, 0x3b, 0xce, 0x72, 0x0b, 0x58, - 0x2a, 0xb2, 0x56, 0xe0, 0x51, 0x80, 0xba, 0x54, 0x86, 0xb0, 0xc5, 0x1c, 0x0e, 0x95, 0xdd, 0xaa, 0xd5, 0x50, 0x92, - 0xe3, 0x72, 0x04, 0x0e, 0xa1, 0xeb, 0x72, 0x50, 0x8e, 0x96, 0x59, 0xf5, 0x1e, 0x7f, 0x6b, 0xd6, 0x21, 0xc9, 0xee, - 0x62, 0x1d, 0xb8, 0x65, 0x1d, 0xa6, 0x9f, 0x0c, 0x52, 0x00, 0x9a, 0x6c, 0x04, 0x2e, 0x01, 0x78, 0x6f, 0xff, 0x11, - 0xa1, 0x56, 0xa6, 0x77, 0x32, 0x16, 0xea, 0xfb, 0x46, 0x12, 0x94, 0xd0, 0x4c, 0xa8, 0x1c, 0x4b, 0xc1, 0x3b, 0x8f, - 0x74, 0x4e, 0xea, 0x4c, 0xbc, 0x07, 0x71, 0x5a, 0x78, 0xcf, 0xde, 0x82, 0xe0, 0x9c, 0x05, 0xdd, 0xe0, 0x6d, 0x56, - 0x4b, 0x6d, 0xf4, 0x40, 0x01, 0xfc, 0x6e, 0xb0, 0x41, 0x90, 0xaf, 0xc6, 0x70, 0xad, 0xe4, 0x4d, 0xc8, 0x87, 0x05, - 0x3d, 0x22, 0x03, 0xfb, 0x2c, 0x86, 0x31, 0x3d, 0x22, 0xc7, 0xf6, 0x59, 0xba, 0x01, 0x1c, 0x48, 0x3d, 0xaa, 0xf4, - 0x08, 0x1a, 0xf4, 0x2f, 0xdb, 0x22, 0x77, 0x00, 0x4a, 0xa3, 0x88, 0x81, 0x2a, 0x41, 0x44, 0x2d, 0xfe, 0x7d, 0x6f, - 0xae, 0x0d, 0xe6, 0x02, 0x61, 0x0e, 0x06, 0x1c, 0xc4, 0x6d, 0x10, 0x9a, 0x03, 0x66, 0x7b, 0x1b, 0x09, 0xba, 0xb1, - 0x86, 0x99, 0x1d, 0xfd, 0xe1, 0x56, 0x82, 0x6f, 0xb2, 0xd6, 0xa8, 0xf3, 0xe2, 0x10, 0x08, 0x82, 0x37, 0x85, 0xaa, - 0xf6, 0xaa, 0x07, 0x36, 0xde, 0xaa, 0x1f, 0xbb, 0xdd, 0x78, 0x2a, 0xdc, 0xb5, 0x5f, 0x50, 0x38, 0xf9, 0x94, 0xfc, - 0xeb, 0xbd, 0xc9, 0xe0, 0xc0, 0xc8, 0xf0, 0xa5, 0xb7, 0x7f, 0xe1, 0x6b, 0x2d, 0xdd, 0x13, 0x83, 0x92, 0x3c, 0x3c, - 0x52, 0xf4, 0xef, 0x4e, 0x59, 0xf9, 0xd4, 0x4e, 0xff, 0x6e, 0x67, 0xd6, 0xe7, 0xf1, 0x68, 0xb2, 0xdb, 0xf5, 0xe2, - 0x4a, 0x7b, 0xac, 0xe9, 0x05, 0x81, 0xce, 0xf5, 0xe4, 0xf0, 0x08, 0xa2, 0x22, 0x34, 0xe3, 0x6e, 0x96, 0x0d, 0x89, - 0x8c, 0x1f, 0xa7, 0xb3, 0x6c, 0x08, 0x76, 0xb8, 0x17, 0x95, 0xb8, 0x1c, 0xb5, 0x36, 0x38, 0xbd, 0x4d, 0x42, 0x08, - 0xe5, 0x80, 0x95, 0xdd, 0xaa, 0x3f, 0x1b, 0x65, 0x26, 0xa4, 0x26, 0xab, 0xdb, 0x29, 0xdd, 0xc3, 0x34, 0x3f, 0x30, - 0x23, 0x38, 0xe0, 0xde, 0xfe, 0xaa, 0x3f, 0x85, 0x49, 0xa6, 0xc9, 0x29, 0x92, 0x5f, 0xa4, 0xa7, 0x90, 0xb4, 0x47, - 0x4f, 0x15, 0x01, 0x9c, 0x50, 0xfb, 0x31, 0xfc, 0x86, 0x71, 0xff, 0xa1, 0xf9, 0xda, 0x4d, 0x45, 0xf4, 0x98, 0x62, - 0x99, 0x9a, 0x9c, 0x26, 0x59, 0x91, 0x40, 0xd4, 0x46, 0xd5, 0x8c, 0xe8, 0x91, 0x8b, 0xf9, 0xa8, 0x08, 0x9f, 0x57, - 0xeb, 0xff, 0x0c, 0xe1, 0x33, 0x92, 0x5d, 0x80, 0xcb, 0x2b, 0x2e, 0xcf, 0xc3, 0x27, 0x8f, 0xe9, 0xc1, 0xe4, 0xbb, - 0x23, 0x7a, 0x70, 0xf4, 0xe8, 0x09, 0x01, 0x58, 0xb4, 0xcb, 0xf3, 0xf0, 0xe8, 0xc9, 0x13, 0x7a, 0xf0, 0xfd, 0xf7, - 0xf4, 0x60, 0xf2, 0xe8, 0xa8, 0x91, 0x36, 0x79, 0xf2, 0x3d, 0x3d, 0xf8, 0xee, 0x71, 0x23, 0xed, 0x68, 0xfc, 0x84, - 0x1e, 0xfc, 0xfd, 0x3b, 0x93, 0xf6, 0x37, 0xc8, 0xf6, 0xfd, 0x11, 0xfe, 0x67, 0xd2, 0x26, 0x4f, 0x1e, 0xd1, 0x83, - 0xc9, 0x18, 0x2a, 0x79, 0xe2, 0x2a, 0x19, 0x4f, 0xe0, 0xe3, 0x47, 0xf0, 0xdf, 0xdf, 0x08, 0x6c, 0x02, 0xc9, 0x96, - 0x02, 0xf5, 0x67, 0x28, 0xe2, 0x44, 0xd5, 0x44, 0xc2, 0x43, 0xcc, 0xac, 0xbe, 0x89, 0xc3, 0x80, 0xb8, 0x74, 0x28, - 0x88, 0x1e, 0x8c, 0x47, 0x4f, 0x48, 0xe0, 0xc3, 0xd3, 0x7d, 0xf2, 0x41, 0xc6, 0x96, 0x62, 0x9e, 0x7d, 0xb3, 0x34, - 0xb1, 0x15, 0x3c, 0x00, 0xab, 0x0f, 0x7e, 0x2e, 0x2e, 0xe7, 0xd9, 0x37, 0x5c, 0xee, 0xe7, 0xfa, 0xb1, 0x05, 0x28, - 0xef, 0xaf, 0x5a, 0xf6, 0xa9, 0x50, 0xa1, 0xd3, 0x5a, 0xa3, 0xcf, 0x3e, 0x60, 0xfa, 0x60, 0xe0, 0xdd, 0xb0, 0x7f, - 0xde, 0x2b, 0xa7, 0xf5, 0x8d, 0x46, 0xa1, 0x46, 0xe5, 0x21, 0x61, 0x27, 0x50, 0xf4, 0x60, 0x00, 0x3c, 0x81, 0x2b, - 0xe3, 0xf7, 0xff, 0xb0, 0x8c, 0x0f, 0x1d, 0x65, 0xfc, 0x03, 0x65, 0x08, 0x68, 0xd4, 0xc3, 0xec, 0xa6, 0x87, 0x8d, - 0x6e, 0xf5, 0x92, 0xa5, 0x3a, 0x99, 0x9a, 0x9e, 0xc1, 0xbe, 0xd6, 0xb5, 0x3c, 0x30, 0xa2, 0x68, 0x79, 0x71, 0x90, - 0xf2, 0x59, 0xc5, 0x7e, 0x5e, 0xa2, 0x7a, 0x2b, 0x6a, 0xbc, 0x91, 0xd9, 0xac, 0x62, 0xbf, 0x9b, 0x37, 0xc0, 0xcd, - 0xb0, 0x1f, 0xd5, 0x93, 0x1f, 0x38, 0x23, 0x93, 0xb6, 0x3d, 0xca, 0xc4, 0x08, 0xb0, 0x02, 0x32, 0x70, 0xe0, 0x01, - 0xd0, 0x41, 0x7f, 0xb4, 0x77, 0x3b, 0x95, 0xd2, 0xec, 0xb3, 0x85, 0x01, 0x34, 0xcc, 0xdb, 0xc4, 0x95, 0x5d, 0xa5, - 0xbe, 0xbc, 0x04, 0x85, 0x5b, 0xcd, 0xf2, 0xf6, 0x0a, 0x53, 0x71, 0x7b, 0x52, 0x06, 0x80, 0x03, 0x01, 0x06, 0x63, - 0x2d, 0x03, 0x6a, 0xb6, 0x7c, 0xb4, 0xe5, 0x4a, 0x3d, 0x09, 0x9c, 0xc1, 0x85, 0x2c, 0x12, 0xfe, 0x56, 0x8b, 0xfd, - 0xd1, 0xfa, 0xd1, 0xf7, 0xed, 0xf1, 0x60, 0xed, 0x7b, 0x7c, 0xa4, 0x3f, 0x6b, 0x5c, 0x07, 0xb6, 0x2d, 0xdf, 0x78, - 0x51, 0x5b, 0x89, 0x47, 0x09, 0xbc, 0x81, 0x89, 0x48, 0x61, 0x90, 0x6a, 0x81, 0x63, 0x50, 0xde, 0x58, 0x88, 0xa5, - 0xea, 0xea, 0x86, 0x6e, 0xc9, 0x10, 0x3c, 0xdc, 0xaa, 0x54, 0x05, 0x8e, 0xea, 0xf7, 0x33, 0xe9, 0xbb, 0x3d, 0x19, - 0x3b, 0x72, 0x9c, 0xfa, 0xa9, 0x70, 0xf0, 0xdf, 0xa4, 0xae, 0xf5, 0xcb, 0x2c, 0x65, 0x96, 0x65, 0x61, 0x27, 0xa1, - 0x96, 0x7b, 0x54, 0x1e, 0x24, 0x5f, 0xc8, 0x21, 0x92, 0x05, 0x46, 0xa1, 0x20, 0xc3, 0x09, 0x15, 0xa3, 0xb5, 0x28, - 0x97, 0xd9, 0x45, 0x15, 0x6e, 0x95, 0x42, 0x99, 0x53, 0xf4, 0xed, 0x06, 0x07, 0x12, 0x12, 0x65, 0xe5, 0x9b, 0xf8, - 0x4d, 0x88, 0x60, 0x75, 0x5c, 0xdb, 0x42, 0x71, 0x6f, 0x7f, 0x8a, 0xb4, 0x8b, 0x3f, 0x32, 0x2e, 0xa0, 0x2e, 0x16, - 0xd3, 0x70, 0x62, 0x63, 0x1f, 0xb8, 0x2f, 0xac, 0xa6, 0x07, 0xa0, 0xbe, 0x4b, 0x25, 0x46, 0x50, 0x5f, 0x19, 0xfb, - 0xd8, 0x1e, 0x63, 0x72, 0x06, 0xb1, 0x86, 0x75, 0xd9, 0xaa, 0x6f, 0x84, 0x9d, 0x00, 0x70, 0x23, 0xb4, 0x46, 0x47, - 0x26, 0xa9, 0x42, 0x3c, 0x2f, 0x55, 0xf8, 0xd6, 0x8c, 0xd0, 0x31, 0x78, 0x53, 0xb9, 0x46, 0x4a, 0x5f, 0x30, 0x68, - 0x8e, 0x6d, 0x1d, 0x85, 0xd5, 0x56, 0x96, 0x9d, 0x00, 0xdc, 0x40, 0x76, 0x6c, 0x2e, 0x9e, 0xb3, 0x6a, 0x9e, 0x2d, - 0x22, 0x13, 0x14, 0x30, 0x15, 0x96, 0x41, 0x7b, 0x73, 0x87, 0x6c, 0xc7, 0x21, 0x74, 0xc3, 0x7d, 0x04, 0xe3, 0x69, - 0x37, 0x05, 0x2b, 0x88, 0x46, 0x88, 0x87, 0x19, 0xb3, 0xf8, 0x5e, 0x69, 0xca, 0x53, 0xd5, 0x12, 0x08, 0x1c, 0x85, - 0x50, 0x17, 0xfb, 0x46, 0x09, 0x2e, 0x53, 0x23, 0x98, 0xc1, 0x9e, 0x1d, 0xa9, 0xed, 0x92, 0x73, 0x3a, 0x54, 0x53, - 0x5a, 0xea, 0x29, 0xd5, 0xbe, 0x86, 0x62, 0x5e, 0xa2, 0x87, 0x1e, 0xb8, 0x1e, 0x68, 0x87, 0xbc, 0x92, 0x4e, 0x4c, - 0x04, 0x9d, 0x56, 0x9b, 0xb0, 0x73, 0x23, 0xdd, 0xb2, 0x1a, 0x79, 0xc7, 0xd0, 0xec, 0x88, 0x57, 0x7e, 0xa0, 0x2e, - 0x80, 0x08, 0xb9, 0xb3, 0x45, 0x86, 0x38, 0xb3, 0xac, 0x7c, 0x01, 0x65, 0x71, 0xc4, 0xd6, 0x15, 0x70, 0x2d, 0x05, - 0x93, 0x4b, 0x1e, 0x89, 0x14, 0x11, 0x01, 0x4f, 0x95, 0x76, 0x7d, 0xaf, 0x25, 0x84, 0x96, 0x29, 0x10, 0x37, 0x17, - 0xc5, 0xb9, 0xb6, 0x81, 0x2c, 0x80, 0xbe, 0xfd, 0x94, 0x5d, 0x79, 0xe1, 0x60, 0xb7, 0x57, 0x99, 0x78, 0xc6, 0x2f, - 0x32, 0xc1, 0x53, 0x04, 0xbb, 0xba, 0x35, 0x0f, 0xdc, 0xb1, 0x6d, 0x60, 0xf9, 0xf6, 0x03, 0x2c, 0x98, 0x32, 0xd4, - 0x4a, 0x89, 0x4c, 0x44, 0x02, 0x32, 0xfb, 0xcc, 0xdd, 0xeb, 0x4c, 0xbc, 0x8e, 0x6f, 0xc1, 0x9b, 0xa2, 0xc1, 0x4f, - 0x8f, 0xce, 0xf1, 0x4b, 0x44, 0x12, 0x85, 0x18, 0xb6, 0x18, 0x11, 0x0b, 0x91, 0x63, 0xc7, 0x84, 0x72, 0x25, 0x68, - 0x6d, 0x0d, 0x81, 0x17, 0x7f, 0x5a, 0x75, 0xef, 0x2a, 0x13, 0xc6, 0x3e, 0xe3, 0x2a, 0xbe, 0x65, 0xa5, 0x02, 0xb3, - 0xc0, 0x38, 0xf7, 0x6d, 0x29, 0xc9, 0x55, 0x26, 0x8c, 0x80, 0xe4, 0x2a, 0xbe, 0xa5, 0x4d, 0x19, 0x87, 0xb6, 0xa2, - 0xf3, 0xe2, 0xfc, 0xee, 0x0f, 0xbf, 0xc4, 0x50, 0x2b, 0xe3, 0x7e, 0x1f, 0x24, 0x66, 0xd2, 0x36, 0x65, 0x26, 0x23, - 0xa9, 0xd1, 0x42, 0x2a, 0xca, 0x07, 0x13, 0xb2, 0xbf, 0x52, 0x2d, 0x23, 0x6a, 0xbf, 0x0a, 0xc5, 0x6c, 0x1c, 0x4d, - 0x08, 0x9d, 0x74, 0xac, 0x77, 0xd3, 0x5a, 0xc8, 0x34, 0x7a, 0x12, 0x79, 0x3e, 0x9d, 0x05, 0xab, 0xa6, 0xc5, 0x31, - 0xe3, 0xd3, 0x62, 0x30, 0x20, 0xda, 0xa5, 0x70, 0x8b, 0xf5, 0x80, 0x29, 0x8d, 0x8b, 0xb7, 0x66, 0x5a, 0xfd, 0x42, - 0xaa, 0x90, 0xf4, 0x9e, 0x01, 0x89, 0x90, 0x2e, 0xd8, 0x2d, 0x48, 0x14, 0x3d, 0xff, 0x3b, 0xb5, 0x05, 0xf7, 0x3d, - 0x18, 0x9b, 0xd1, 0x7d, 0x3d, 0xe3, 0x3f, 0xd4, 0xb6, 0x20, 0xea, 0x53, 0xc9, 0x7a, 0x1d, 0x89, 0x2a, 0xe4, 0x22, - 0xfc, 0xec, 0x68, 0x88, 0x21, 0xaa, 0x3d, 0x16, 0x88, 0xf5, 0xd5, 0x39, 0x2f, 0x70, 0xfa, 0x99, 0xbb, 0x5c, 0xc1, - 0xb6, 0xa0, 0x95, 0xa1, 0x51, 0x6f, 0xe2, 0x37, 0x91, 0xbd, 0x2c, 0xe8, 0x22, 0x9f, 0xa1, 0x90, 0x35, 0x0f, 0xc3, - 0x6a, 0xd8, 0x1e, 0x44, 0x72, 0xd8, 0x9e, 0x84, 0x46, 0x63, 0x60, 0x81, 0xec, 0xd1, 0x08, 0x5c, 0x84, 0x56, 0xfe, - 0x76, 0x0c, 0x2e, 0x5c, 0x16, 0x91, 0x65, 0xa8, 0xe3, 0x37, 0xb5, 0x9b, 0xa0, 0x7a, 0x85, 0x4e, 0x53, 0x58, 0x95, - 0x32, 0xc9, 0x87, 0x5f, 0x2f, 0x64, 0x81, 0x99, 0xbc, 0x2e, 0x7b, 0xf4, 0xb5, 0xdd, 0xde, 0x81, 0x29, 0x58, 0xf7, - 0xc9, 0xfb, 0xfa, 0x61, 0x67, 0x4f, 0xc0, 0x28, 0x56, 0xe5, 0x68, 0x0a, 0x29, 0xb5, 0x0f, 0x4a, 0xfd, 0x29, 0x4c, - 0x85, 0xe6, 0xd8, 0x2d, 0x60, 0x12, 0xb0, 0xcf, 0x90, 0xea, 0x31, 0xed, 0xd8, 0xe7, 0x68, 0x0b, 0x4b, 0x02, 0x0e, - 0xff, 0x48, 0xc8, 0xda, 0xbf, 0xba, 0xcb, 0xb4, 0x19, 0xb2, 0x65, 0xbe, 0x00, 0x3e, 0x1f, 0x76, 0x6d, 0x54, 0xa2, - 0x6c, 0x22, 0x92, 0x14, 0xb6, 0x3c, 0x06, 0x69, 0x8f, 0x62, 0xba, 0x2a, 0x78, 0x92, 0xa1, 0x94, 0x22, 0xd1, 0x3e, - 0xc1, 0x39, 0xbc, 0xc1, 0xfd, 0xa8, 0x02, 0xc2, 0xab, 0x90, 0xd3, 0x51, 0x4a, 0xb5, 0x05, 0x8c, 0xa2, 0x1e, 0x20, - 0xca, 0xcb, 0x40, 0x8e, 0xb7, 0xdb, 0x4d, 0xe8, 0x8a, 0x2d, 0x87, 0x13, 0x8a, 0xa4, 0xe4, 0x12, 0xcb, 0xbd, 0x02, - 0x9d, 0xc7, 0x39, 0xeb, 0xbd, 0x02, 0x2c, 0x82, 0x33, 0xf8, 0x1b, 0x13, 0x7a, 0x0d, 0x7f, 0x73, 0x42, 0x9f, 0xb2, - 0xf0, 0x6a, 0x78, 0x49, 0x0e, 0xc3, 0x74, 0x30, 0x51, 0x82, 0xb1, 0x0d, 0x4b, 0xcb, 0x50, 0x25, 0xae, 0x0e, 0x2f, - 0xc8, 0xc3, 0x0b, 0x7a, 0x4b, 0x6f, 0xe8, 0x6b, 0xfa, 0x00, 0x08, 0xff, 0xe6, 0x78, 0xc2, 0x87, 0x93, 0xc7, 0xfd, - 0x7e, 0xef, 0xbc, 0xdf, 0xef, 0x9d, 0x19, 0x03, 0x0a, 0xbd, 0x8b, 0x2e, 0x6b, 0xaa, 0x7f, 0x5d, 0xd5, 0x8b, 0xe9, - 0x03, 0xb5, 0x71, 0x13, 0x9e, 0xe5, 0xe1, 0xd5, 0xe1, 0x86, 0x0c, 0xf1, 0xf1, 0x22, 0x97, 0xb2, 0x08, 0x2f, 0x0f, - 0x37, 0x84, 0x3e, 0x38, 0x01, 0xbd, 0x29, 0xd6, 0xf7, 0xe0, 0xe1, 0x46, 0xd7, 0x46, 0xe8, 0xab, 0x30, 0x81, 0x6d, - 0x72, 0xcb, 0xec, 0x5d, 0x7b, 0x32, 0x86, 0x58, 0x26, 0x1b, 0xaf, 0xbc, 0xcd, 0xc3, 0x5b, 0x72, 0x78, 0x0b, 0x9e, - 0xa2, 0x96, 0xfc, 0xcd, 0xc2, 0x1b, 0xd6, 0xaa, 0xe1, 0xe1, 0x86, 0xbe, 0x6e, 0x35, 0xe2, 0xe1, 0x86, 0x44, 0xe1, - 0x0d, 0xbb, 0xa4, 0xaf, 0xd9, 0x15, 0xa1, 0xe7, 0xfd, 0xfe, 0x59, 0xbf, 0x2f, 0xfb, 0xfd, 0x9f, 0xe3, 0x30, 0x8c, - 0x87, 0x05, 0x39, 0x94, 0x74, 0x73, 0x38, 0xe1, 0x8f, 0xc8, 0x2c, 0xd4, 0xcd, 0x57, 0x0b, 0xce, 0xaa, 0xbc, 0x55, - 0xae, 0x0d, 0x05, 0x6b, 0x85, 0x0d, 0x53, 0x4f, 0x0f, 0xe8, 0x0d, 0x2b, 0xe8, 0x6b, 0x16, 0x93, 0xe8, 0x1a, 0x5a, - 0x71, 0x3e, 0x2b, 0xa2, 0x1b, 0xfa, 0x9a, 0x9d, 0xcd, 0xe2, 0xe8, 0x35, 0x7d, 0xc0, 0xf2, 0xe1, 0x04, 0xf2, 0xbe, - 0x1e, 0xde, 0x90, 0xc3, 0x07, 0x24, 0x0a, 0x1f, 0xe8, 0xdf, 0x1b, 0x7a, 0xc9, 0xc3, 0x07, 0xd4, 0xab, 0xe6, 0x01, - 0x31, 0xd5, 0x37, 0x6a, 0x7f, 0x40, 0x22, 0x7f, 0x30, 0x1f, 0x58, 0x7b, 0x9a, 0x77, 0x8e, 0x36, 0xae, 0xcb, 0x70, - 0x43, 0xe8, 0xba, 0x0c, 0x6f, 0x08, 0x99, 0x36, 0xc7, 0x0e, 0x06, 0x74, 0xf6, 0x2e, 0x4a, 0x08, 0xbd, 0xf1, 0x4b, - 0xbd, 0xc1, 0x31, 0x34, 0x23, 0xa4, 0xfb, 0x89, 0x69, 0xb8, 0x0e, 0x3e, 0x6a, 0xb0, 0x8e, 0xf3, 0x7e, 0x3f, 0x5c, - 0xf7, 0xfb, 0x10, 0xe9, 0xbe, 0x98, 0x99, 0xd8, 0x6e, 0x8e, 0x6c, 0xd2, 0x1b, 0xd0, 0xfe, 0x7f, 0x1c, 0x0c, 0xa0, - 0x33, 0x5e, 0x49, 0xe1, 0xcd, 0xe0, 0xe3, 0xc3, 0x0d, 0x51, 0x75, 0x14, 0xb4, 0x94, 0x61, 0x41, 0x9f, 0xd2, 0x0c, - 0x00, 0xbf, 0x3e, 0x0e, 0x06, 0x24, 0x32, 0x9f, 0x91, 0xe9, 0xc7, 0xe3, 0x07, 0xd3, 0xc1, 0xe0, 0xa3, 0xd9, 0x26, - 0x9f, 0xd9, 0x1d, 0xa5, 0xc0, 0xfa, 0x3b, 0xeb, 0xf7, 0x3f, 0x9f, 0xc4, 0xe4, 0xbc, 0xe0, 0xf1, 0xa7, 0x69, 0xb3, - 0x2d, 0x9f, 0x5d, 0x54, 0xb5, 0xb3, 0x7e, 0x7f, 0xdd, 0xef, 0xbf, 0x06, 0xec, 0xa2, 0x99, 0xf3, 0xf5, 0x04, 0x69, - 0xcb, 0xdc, 0x51, 0x24, 0x4d, 0x72, 0x68, 0x0c, 0x6d, 0x8b, 0x55, 0xdb, 0x66, 0x1d, 0x19, 0x58, 0x1c, 0x35, 0x2b, - 0x8a, 0x6b, 0x12, 0x85, 0xbd, 0xb3, 0xdd, 0xee, 0x35, 0x63, 0x2c, 0x26, 0x20, 0xfd, 0xf0, 0x5f, 0xbf, 0xae, 0x1b, - 0x31, 0xc4, 0x4a, 0x25, 0xbe, 0xdb, 0x2e, 0xed, 0x21, 0x10, 0x71, 0xd8, 0xf4, 0xef, 0xcd, 0xbd, 0x5c, 0xd4, 0x8e, - 0x6f, 0xfd, 0x1d, 0x40, 0x88, 0x24, 0x0b, 0xf9, 0x0c, 0xc7, 0xa0, 0xcc, 0x00, 0xc8, 0x3c, 0x52, 0x33, 0x2f, 0x01, - 0x04, 0x98, 0xec, 0x76, 0xa3, 0xf1, 0x78, 0x42, 0x0b, 0x36, 0xfa, 0xdb, 0x93, 0x87, 0xd5, 0xc3, 0x30, 0x08, 0x06, - 0x19, 0x69, 0xe9, 0x29, 0xec, 0x62, 0xad, 0x0e, 0xc1, 0x08, 0x5e, 0xb3, 0x8f, 0xd7, 0xd9, 0x57, 0xb3, 0x8f, 0x48, - 0x58, 0x1b, 0x8c, 0x23, 0x17, 0x69, 0x4b, 0x6f, 0x77, 0x07, 0x83, 0xc9, 0x45, 0xfa, 0x05, 0xb6, 0xd3, 0xe7, 0xdf, - 0x3c, 0x18, 0x4f, 0x38, 0x18, 0xdd, 0x45, 0x41, 0x9f, 0x69, 0xbb, 0x5d, 0xe5, 0x5f, 0x02, 0xdf, 0x60, 0x2a, 0xe8, - 0xd8, 0x2c, 0x0b, 0x37, 0xa8, 0x88, 0x3a, 0x5a, 0x06, 0x55, 0xad, 0x6c, 0xe7, 0x80, 0x5a, 0x62, 0x55, 0x26, 0x6e, - 0x81, 0x61, 0xc8, 0x50, 0x97, 0x7b, 0x5a, 0xfd, 0xce, 0x0b, 0x69, 0xe0, 0x33, 0x9c, 0x88, 0xd0, 0xe3, 0xd6, 0xb8, - 0xcf, 0xad, 0x89, 0x2f, 0x70, 0x6b, 0x25, 0x92, 0x58, 0x03, 0x4b, 0x6a, 0x2e, 0x47, 0x09, 0x3b, 0x29, 0x19, 0x9f, - 0x95, 0x51, 0x42, 0x63, 0x78, 0x90, 0x4c, 0xcc, 0x64, 0x94, 0xa0, 0x7d, 0xa2, 0x8b, 0x30, 0xf8, 0x17, 0x60, 0xf6, - 0xd3, 0x1c, 0xfe, 0x4a, 0x32, 0x4d, 0x8e, 0x21, 0x20, 0xc4, 0xf1, 0x78, 0x16, 0x87, 0x63, 0x12, 0x25, 0x27, 0xf0, - 0x04, 0xff, 0x15, 0xe1, 0x98, 0xd4, 0xfa, 0x0e, 0x23, 0xd5, 0xe5, 0x36, 0x61, 0x00, 0x57, 0x36, 0x9e, 0x4d, 0x22, - 0x2b, 0xdd, 0x95, 0x0f, 0x47, 0xe3, 0x27, 0x64, 0x1a, 0x87, 0x72, 0x90, 0x10, 0x0a, 0xde, 0xbd, 0x61, 0x39, 0x4c, - 0x34, 0x3c, 0x1b, 0xb0, 0x79, 0xa5, 0x63, 0xf3, 0x24, 0x9c, 0x80, 0x30, 0x4c, 0xc8, 0xb1, 0xde, 0x81, 0x94, 0xa2, - 0xcf, 0x73, 0xec, 0xa7, 0x3e, 0x82, 0x30, 0x3b, 0x6a, 0xa9, 0xf8, 0x0a, 0x80, 0x2e, 0x71, 0x70, 0xa8, 0x3d, 0xf3, - 0xc5, 0x2c, 0x2c, 0x3d, 0x2a, 0x65, 0xaa, 0x3b, 0x14, 0x0d, 0xca, 0x6f, 0x1a, 0x74, 0x28, 0xc8, 0x60, 0x42, 0xcb, - 0x93, 0x09, 0x7f, 0x04, 0x01, 0x3c, 0x1a, 0x11, 0xbf, 0x14, 0x4e, 0x0c, 0x84, 0x57, 0x41, 0x06, 0x2a, 0xad, 0x55, - 0x63, 0x46, 0xb6, 0xe2, 0x03, 0x08, 0x93, 0x72, 0x70, 0x23, 0xd7, 0x79, 0x0a, 0x51, 0xc1, 0xd6, 0x79, 0x75, 0x70, - 0x09, 0x96, 0xec, 0x71, 0x05, 0x71, 0xc2, 0xd6, 0x2b, 0xc0, 0xce, 0x7d, 0xb0, 0x2d, 0xeb, 0x03, 0xf5, 0xdd, 0x01, - 0xb6, 0x1c, 0x5e, 0x55, 0xf2, 0x60, 0x32, 0x1e, 0x8f, 0x47, 0x7f, 0xc0, 0xd1, 0x01, 0x84, 0x96, 0x44, 0x86, 0x4f, - 0x06, 0x68, 0xdc, 0x75, 0xc5, 0xbd, 0x71, 0xa1, 0x28, 0x2b, 0x9d, 0x4c, 0x08, 0x88, 0x9f, 0x4d, 0xdf, 0x60, 0x5f, - 0x71, 0x1d, 0xff, 0x64, 0xff, 0x13, 0xb3, 0xa2, 0xd5, 0x4a, 0x1d, 0xbd, 0x7b, 0xfb, 0xe1, 0xd5, 0xc7, 0x57, 0xbf, - 0x3e, 0x3f, 0x7b, 0xf5, 0xe6, 0xc5, 0xab, 0x37, 0xaf, 0x3e, 0xfe, 0xfb, 0x1e, 0x06, 0xdb, 0xb7, 0x15, 0xb1, 0x63, - 0xef, 0xdd, 0x63, 0xbc, 0x5a, 0x7c, 0xe1, 0xec, 0x91, 0xbb, 0xc5, 0x02, 0x6c, 0x82, 0xe1, 0x16, 0x04, 0xd5, 0x8c, - 0x46, 0xa5, 0xef, 0x09, 0xc8, 0x68, 0x54, 0xc8, 0xc6, 0xc3, 0x8a, 0xad, 0x90, 0x8b, 0x77, 0x0c, 0x07, 0x1f, 0xd9, - 0xdf, 0x8a, 0x33, 0xe1, 0x76, 0xb4, 0x35, 0x2b, 0x02, 0x3e, 0x5f, 0x6b, 0x51, 0x79, 0x5c, 0x88, 0xda, 0xdb, 0xf6, - 0x39, 0x24, 0xd4, 0x23, 0x72, 0x1d, 0xbc, 0x6f, 0x83, 0xec, 0xf1, 0x91, 0xf7, 0xa4, 0x3c, 0x43, 0x7d, 0x8e, 0x86, - 0x8f, 0x1a, 0xcf, 0xe8, 0xc4, 0x5c, 0x1b, 0x1d, 0xea, 0x59, 0x01, 0xfb, 0x5b, 0x89, 0xb1, 0xc1, 0x1c, 0x3a, 0x45, - 0xac, 0x0f, 0xa7, 0xfb, 0xdd, 0xbf, 0x19, 0xfd, 0x0c, 0xc7, 0x8f, 0x52, 0x4d, 0x20, 0x2d, 0x0a, 0x94, 0xae, 0x0c, - 0xb9, 0xed, 0x59, 0x58, 0x98, 0x9f, 0x61, 0x83, 0x00, 0xda, 0xcb, 0x8e, 0x25, 0x81, 0x66, 0xf1, 0x5a, 0xd7, 0x3f, - 0x2f, 0x5f, 0x26, 0xda, 0xf9, 0xe2, 0x5b, 0x08, 0x31, 0xec, 0x5f, 0x11, 0x1a, 0x13, 0xee, 0x26, 0xd9, 0x5d, 0x5a, - 0xcc, 0xbd, 0xea, 0x2a, 0xc6, 0xe3, 0xee, 0x8e, 0x2b, 0x45, 0xf3, 0xd6, 0x05, 0xf6, 0x40, 0xcd, 0xeb, 0x78, 0xc9, - 0x42, 0xc0, 0x66, 0x3c, 0xb4, 0x8b, 0xc4, 0xf9, 0xbd, 0xd3, 0x09, 0x39, 0x3c, 0x9a, 0xf2, 0x21, 0x2b, 0xa9, 0x18, - 0xb0, 0xb2, 0xde, 0xa3, 0xe6, 0xbc, 0x4d, 0xc8, 0xc5, 0x3e, 0x0d, 0x17, 0x43, 0x7e, 0xdf, 0x25, 0xe9, 0x23, 0x6f, - 0x38, 0x54, 0xdb, 0xe6, 0x62, 0x48, 0x53, 0x4e, 0xf7, 0xa9, 0x0c, 0x08, 0x91, 0xae, 0xe2, 0x8a, 0xd4, 0xfa, 0xa8, - 0x5a, 0x3b, 0x49, 0xc7, 0x75, 0xb6, 0xfd, 0xc2, 0x25, 0x5b, 0xdd, 0xae, 0xfd, 0x6b, 0x75, 0xfb, 0xc2, 0x0c, 0xe4, - 0xef, 0x4f, 0x44, 0x35, 0x31, 0x10, 0x5d, 0x40, 0x05, 0xff, 0x04, 0x2f, 0x4f, 0x1e, 0x69, 0x05, 0xe8, 0x5d, 0x67, - 0x47, 0xd7, 0x1e, 0x6f, 0xcc, 0x62, 0x6b, 0x89, 0x73, 0x56, 0xf9, 0xce, 0xf2, 0xaa, 0x6c, 0x85, 0xae, 0x23, 0xd8, - 0xef, 0x61, 0x47, 0xdf, 0xbd, 0x6d, 0x00, 0x44, 0x29, 0xac, 0xdc, 0xd9, 0x2f, 0xbc, 0xb3, 0x5f, 0xd8, 0xb3, 0xdf, - 0x6e, 0x02, 0xe5, 0xc3, 0x0a, 0x2d, 0x7b, 0x21, 0x45, 0x65, 0x9a, 0x3c, 0x6e, 0xea, 0xb2, 0x90, 0x16, 0xf3, 0x43, - 0x4b, 0xbb, 0x1e, 0x8f, 0xa9, 0x44, 0xf5, 0xc8, 0x4b, 0x6c, 0xd5, 0x61, 0x49, 0xee, 0xbf, 0x67, 0xfe, 0xcf, 0xde, - 0x20, 0xef, 0xba, 0xdb, 0xfd, 0xdf, 0x5c, 0xe8, 0xe0, 0xb6, 0xb6, 0x16, 0x9e, 0xba, 0x3a, 0x2e, 0xf0, 0xae, 0xb6, - 0xbe, 0xff, 0xae, 0xf6, 0x36, 0xd3, 0xcb, 0xae, 0x02, 0xd4, 0x20, 0xb1, 0xbe, 0xe2, 0x45, 0x96, 0xd4, 0x56, 0xa1, - 0xf1, 0x80, 0x43, 0x68, 0x0f, 0xef, 0xe0, 0x02, 0x39, 0x2c, 0x21, 0xf4, 0x53, 0x65, 0x04, 0x80, 0x3e, 0x8b, 0xfd, - 0x80, 0x87, 0x19, 0x19, 0xf8, 0x12, 0x3f, 0x29, 0x7d, 0x71, 0xf1, 0xe1, 0x5e, 0x66, 0x82, 0x5e, 0x25, 0x36, 0x7b, - 0x21, 0xdb, 0x31, 0x3f, 0xfc, 0x2f, 0x30, 0x1a, 0x84, 0xd7, 0x96, 0xec, 0x50, 0x74, 0xcc, 0x72, 0x05, 0x47, 0x6d, - 0xe9, 0x95, 0xd9, 0xba, 0x7e, 0x56, 0xc3, 0x4c, 0x9f, 0x29, 0x0f, 0x40, 0xf6, 0x85, 0xdc, 0xfd, 0x54, 0x57, 0x2c, - 0xc8, 0xc9, 0x64, 0x3c, 0x25, 0x62, 0x30, 0x68, 0x25, 0x1f, 0x63, 0xf2, 0x70, 0xb8, 0xc7, 0x5c, 0x0a, 0xdd, 0x0f, - 0x2f, 0xf2, 0x2f, 0xd4, 0xd7, 0xd8, 0x92, 0x64, 0x5b, 0xb1, 0xbf, 0xc0, 0x2c, 0x16, 0x88, 0xa3, 0x83, 0x5f, 0x9c, - 0x2f, 0x68, 0x09, 0x6d, 0xa8, 0x0c, 0x7a, 0x72, 0x91, 0x2a, 0x1f, 0xd9, 0x82, 0xc9, 0xe3, 0xf1, 0xcc, 0xef, 0xb9, - 0x63, 0x70, 0x08, 0x89, 0x26, 0xd6, 0xf8, 0xc5, 0xcf, 0x82, 0x71, 0x1c, 0xca, 0x13, 0xd9, 0xf8, 0xae, 0x24, 0xd1, - 0xd8, 0x98, 0x2a, 0xeb, 0xab, 0x44, 0x35, 0x4c, 0xc8, 0xc3, 0x82, 0x1c, 0x16, 0x74, 0xe9, 0x8f, 0x25, 0xa6, 0x1f, - 0xc6, 0x87, 0x93, 0x31, 0x79, 0x18, 0x3f, 0x9c, 0x18, 0xb8, 0x61, 0x3f, 0x47, 0x3e, 0x5c, 0x92, 0xc3, 0x66, 0x95, - 0x60, 0x8a, 0x6a, 0x7a, 0xe6, 0x57, 0x92, 0x0c, 0x96, 0x83, 0xf4, 0x61, 0x2b, 0x2f, 0xd6, 0xaa, 0xc7, 0x7b, 0x7d, - 0xcc, 0xa7, 0x44, 0x34, 0x6e, 0x0c, 0x6b, 0x7a, 0x15, 0xff, 0x29, 0x8b, 0x48, 0x4a, 0x40, 0x24, 0x04, 0xf5, 0x76, - 0x76, 0x91, 0x25, 0xb1, 0x48, 0xa3, 0xb4, 0x26, 0x34, 0x3d, 0x61, 0x93, 0xf1, 0x2c, 0x65, 0xe9, 0xf1, 0xe4, 0xc9, - 0x6c, 0xf2, 0x24, 0x3a, 0x1a, 0x47, 0xe9, 0x60, 0x00, 0xc9, 0x47, 0x63, 0x70, 0xb1, 0x83, 0xdf, 0xec, 0x08, 0x86, - 0xee, 0x04, 0x59, 0xc2, 0x02, 0x9a, 0xf6, 0x75, 0x4d, 0xd2, 0xc3, 0x79, 0xa1, 0x7a, 0x12, 0xdf, 0xd2, 0xb5, 0xe7, - 0xe0, 0xe2, 0xb7, 0xf0, 0xc2, 0xb5, 0xf0, 0x62, 0xbf, 0x85, 0x42, 0x93, 0xed, 0x58, 0xfe, 0xff, 0x71, 0xc3, 0xb8, - 0xeb, 0x2e, 0x61, 0x16, 0xd7, 0x75, 0x36, 0x5a, 0x15, 0xb2, 0x92, 0x70, 0x9b, 0x50, 0xa2, 0xb0, 0x51, 0xbc, 0x5a, - 0xe5, 0xda, 0x45, 0x6c, 0x5e, 0x51, 0x00, 0x77, 0x81, 0x38, 0xc5, 0xc0, 0x42, 0x1b, 0x03, 0xb9, 0xcf, 0xbc, 0x90, - 0xcc, 0xaa, 0x7d, 0xcc, 0x3d, 0xf2, 0xcf, 0x10, 0x8c, 0x51, 0xc5, 0xc9, 0x78, 0xa6, 0xb0, 0x2e, 0xbe, 0x24, 0xef, - 0xfd, 0x0f, 0x8e, 0x22, 0x7b, 0x34, 0x83, 0x9e, 0x20, 0x72, 0x1e, 0x71, 0xf6, 0x64, 0xf2, 0x32, 0x70, 0x3f, 0x83, - 0x95, 0xfe, 0xba, 0xdb, 0x8c, 0xb5, 0xed, 0xd1, 0xbd, 0x30, 0x42, 0xd1, 0xcf, 0xf8, 0xce, 0xd4, 0x0b, 0xb8, 0x84, - 0x6a, 0x60, 0xd7, 0x97, 0x97, 0xbc, 0x04, 0x10, 0xa1, 0x4c, 0xf4, 0xfb, 0xbd, 0x3f, 0x0d, 0x34, 0x69, 0xc9, 0x8b, - 0xd7, 0x99, 0xb0, 0xce, 0x38, 0xd0, 0x54, 0xa0, 0xfe, 0x9f, 0x2a, 0xfb, 0x4c, 0xc7, 0x64, 0xe6, 0x3f, 0x0e, 0x27, - 0x24, 0x6a, 0xbe, 0x26, 0x5f, 0x38, 0x4d, 0xbf, 0x70, 0x45, 0xfb, 0x6f, 0xc8, 0xcc, 0x0d, 0x87, 0x0c, 0xf5, 0x97, - 0x8e, 0x79, 0x32, 0x7a, 0x9d, 0x98, 0x9d, 0x08, 0x56, 0xcd, 0x20, 0x0a, 0x7b, 0x01, 0x0f, 0xea, 0x5a, 0x16, 0x4f, - 0x61, 0xf6, 0x41, 0x8d, 0x28, 0x8e, 0xd9, 0x78, 0x16, 0xca, 0x70, 0x02, 0xf6, 0xbd, 0x93, 0x31, 0xdc, 0x07, 0x64, - 0xf8, 0xa9, 0x0a, 0xb1, 0x73, 0x90, 0xf6, 0xa9, 0x42, 0xc5, 0x04, 0x40, 0x04, 0x42, 0xde, 0x7e, 0x5f, 0xaa, 0x24, - 0x7c, 0x5d, 0x62, 0x4a, 0xa1, 0x3e, 0xf8, 0xef, 0x48, 0xd5, 0x1d, 0xd3, 0xaf, 0xd6, 0x8f, 0x3f, 0x13, 0x8a, 0x4f, - 0x77, 0x29, 0xf1, 0x2d, 0x04, 0x77, 0x8e, 0x41, 0x07, 0x51, 0xa1, 0x19, 0xdb, 0xfd, 0xfc, 0xae, 0xb8, 0x9b, 0xdf, - 0x15, 0xff, 0xef, 0xf8, 0x5d, 0x71, 0x1f, 0x63, 0x58, 0x59, 0x68, 0xf8, 0x59, 0x30, 0x0e, 0xa2, 0xff, 0x3e, 0x9f, - 0x78, 0x27, 0x4f, 0x7d, 0x95, 0x89, 0xe9, 0x1d, 0x4c, 0xb3, 0x4f, 0x50, 0x10, 0x56, 0x71, 0x9f, 0x9e, 0xac, 0x2b, - 0x7b, 0x6b, 0x25, 0x43, 0xcc, 0x73, 0x0f, 0x6b, 0x14, 0x56, 0x1e, 0xd0, 0x3d, 0xaa, 0x36, 0x88, 0x13, 0xc1, 0xc3, - 0x98, 0x59, 0xe9, 0xfb, 0x6e, 0x67, 0x54, 0x98, 0xf7, 0x72, 0x51, 0x90, 0xdd, 0x7c, 0x3c, 0x1b, 0x47, 0x21, 0x36, - 0xe0, 0xbf, 0xcd, 0x58, 0x35, 0x64, 0xf3, 0x9d, 0x8c, 0xd4, 0x9e, 0xc9, 0xd3, 0x64, 0x9f, 0xf4, 0x0e, 0x78, 0x87, - 0xfc, 0xbc, 0xfe, 0x14, 0xc6, 0xd2, 0xf0, 0x5b, 0xf2, 0x32, 0x2e, 0xb2, 0x6a, 0x79, 0x95, 0x25, 0xc8, 0x74, 0xc1, - 0x8b, 0xaf, 0x66, 0xba, 0xbc, 0x8f, 0xf5, 0x01, 0xe3, 0x29, 0xc5, 0xeb, 0x86, 0x28, 0xfd, 0xa2, 0xe5, 0x59, 0xa1, - 0x2e, 0x4f, 0x2a, 0x66, 0x7b, 0x56, 0x82, 0xd3, 0x29, 0x98, 0xe0, 0xeb, 0x9f, 0xae, 0xf7, 0x09, 0xe0, 0x82, 0x42, - 0xcd, 0x69, 0x21, 0x57, 0x06, 0xcb, 0xc9, 0x42, 0x77, 0x02, 0x66, 0xa8, 0x14, 0x78, 0x81, 0x82, 0xbf, 0x68, 0x60, - 0x44, 0x5f, 0xb8, 0xdf, 0x64, 0x60, 0x90, 0x2e, 0xcd, 0x89, 0x30, 0x76, 0xdc, 0x4e, 0x92, 0xb6, 0xa2, 0x9c, 0x71, - 0xf6, 0x5e, 0x5d, 0x29, 0xc0, 0x00, 0x6f, 0x7b, 0x13, 0x6d, 0x12, 0xf4, 0x5a, 0x50, 0x3a, 0x6f, 0xe0, 0x6e, 0x96, - 0x91, 0x11, 0x2e, 0x3e, 0xac, 0x3c, 0x16, 0xdc, 0xb3, 0x5f, 0x48, 0xac, 0xad, 0x1f, 0x18, 0xb3, 0x79, 0xc1, 0x02, - 0x85, 0x0a, 0x14, 0x58, 0xce, 0xb4, 0xa5, 0x69, 0x35, 0xe4, 0x87, 0x47, 0x68, 0x6d, 0x5a, 0x0d, 0xf8, 0xe1, 0x51, - 0x1d, 0x65, 0xc7, 0x90, 0xe5, 0xc4, 0xcf, 0xa0, 0x5e, 0xd7, 0x91, 0x49, 0x31, 0xd9, 0xbd, 0xfa, 0xf2, 0xd4, 0x1f, - 0xd5, 0x2d, 0xb8, 0x7e, 0x00, 0x02, 0xd8, 0x00, 0x1c, 0x02, 0xd5, 0x60, 0x69, 0x44, 0xb0, 0x28, 0x53, 0x68, 0x5f, - 0x43, 0xef, 0x8d, 0x86, 0xff, 0x02, 0x77, 0x11, 0xb9, 0xf2, 0x3f, 0x41, 0xe0, 0xaf, 0x28, 0xd3, 0xca, 0x14, 0xff, - 0x13, 0xad, 0x5e, 0xa1, 0x9c, 0x35, 0xad, 0xf9, 0x20, 0x5a, 0x13, 0xa1, 0x9a, 0x31, 0x04, 0xff, 0x56, 0x96, 0x69, - 0x4b, 0x55, 0xa5, 0x3e, 0x34, 0x5e, 0x6b, 0x85, 0xb3, 0x7c, 0x1c, 0x79, 0xaf, 0x31, 0x74, 0x6c, 0xe2, 0x2c, 0xe5, - 0x54, 0xea, 0xec, 0xcd, 0xa1, 0x8c, 0x1c, 0xe0, 0x74, 0xc2, 0xc6, 0xd3, 0xe4, 0x58, 0x4e, 0x13, 0x07, 0x99, 0x9f, - 0x33, 0x8c, 0xac, 0x6a, 0x40, 0x58, 0x94, 0x0d, 0xa5, 0x2d, 0xc0, 0x24, 0x27, 0x84, 0x4c, 0x31, 0x14, 0x45, 0x3e, - 0xd2, 0xfd, 0xb0, 0xde, 0xac, 0xee, 0x8b, 0x77, 0x1a, 0xe0, 0x34, 0x4c, 0x20, 0x10, 0x78, 0x11, 0xdf, 0x64, 0xe2, - 0x12, 0x3c, 0x86, 0x07, 0xf0, 0x25, 0xb8, 0xc9, 0xa5, 0xec, 0x5f, 0x55, 0x98, 0xe3, 0xda, 0x02, 0x06, 0x0d, 0x56, - 0x0f, 0xa2, 0xc3, 0xa5, 0xb4, 0xd9, 0x55, 0x80, 0xd8, 0x98, 0x42, 0x2c, 0x0b, 0xb6, 0xb6, 0xec, 0xd9, 0xcf, 0xaa, - 0x69, 0x68, 0x9d, 0x70, 0x2a, 0x2e, 0x73, 0x88, 0xa2, 0x32, 0x88, 0xc1, 0x1d, 0xc9, 0xe3, 0xf3, 0x4e, 0x45, 0x78, - 0x41, 0xc0, 0xad, 0x2c, 0x91, 0xe1, 0x8a, 0x2e, 0x47, 0xb7, 0x74, 0x3d, 0xba, 0xa1, 0x63, 0x3a, 0xf9, 0xfb, 0x18, - 0x2d, 0xb2, 0x55, 0xea, 0x86, 0xae, 0x47, 0x4b, 0xfa, 0xfd, 0x98, 0x1e, 0xfd, 0x6d, 0x4c, 0xa6, 0x4b, 0x3c, 0x4c, - 0xe8, 0x05, 0x38, 0x76, 0x91, 0x1a, 0x3d, 0x35, 0x7d, 0x83, 0xc3, 0x6a, 0x94, 0x0f, 0xf9, 0x28, 0xa7, 0x7c, 0x54, - 0x0c, 0xab, 0x11, 0x78, 0x3a, 0x56, 0x43, 0x3e, 0xaa, 0x28, 0x1f, 0x9d, 0x0f, 0xab, 0xd1, 0x39, 0x69, 0x36, 0xfd, - 0x55, 0xc5, 0xaf, 0x4a, 0x76, 0x01, 0xdb, 0x02, 0x96, 0xaf, 0x5b, 0x65, 0xcb, 0xd4, 0x5f, 0xd5, 0xe6, 0x64, 0xb6, - 0x9c, 0xbd, 0xbd, 0xee, 0x72, 0x62, 0xf1, 0xb8, 0x6d, 0x3a, 0x5c, 0x7d, 0x39, 0x51, 0x27, 0xbd, 0x42, 0x7e, 0x18, - 0x4f, 0x85, 0x3a, 0x87, 0xc0, 0x4c, 0x62, 0x16, 0xc6, 0x0c, 0x9b, 0xa9, 0xd3, 0x40, 0x81, 0x93, 0x8d, 0x3c, 0x17, - 0xc5, 0x6c, 0x94, 0x53, 0x78, 0x1f, 0x13, 0x12, 0x09, 0x38, 0xab, 0x4e, 0xaa, 0x51, 0x01, 0x31, 0x47, 0x58, 0x88, - 0x8f, 0xd0, 0x2f, 0xf5, 0x91, 0x87, 0x04, 0x9e, 0x61, 0x5f, 0x8b, 0x41, 0x0c, 0x47, 0xbc, 0xad, 0xac, 0x9a, 0x85, - 0x09, 0x54, 0x56, 0x0d, 0x4b, 0x53, 0x59, 0x41, 0xb3, 0x51, 0xe5, 0x57, 0x56, 0xe1, 0x18, 0x25, 0x84, 0x44, 0xa5, - 0xae, 0x0c, 0xd4, 0x27, 0x09, 0x0b, 0x4b, 0x5d, 0xd9, 0xb9, 0xfa, 0xe8, 0xdc, 0xaf, 0xec, 0x1c, 0x5c, 0x48, 0x07, - 0x89, 0x7f, 0x95, 0x4a, 0xd3, 0xf6, 0x75, 0xb0, 0xb1, 0xaa, 0xe8, 0x96, 0xdf, 0x56, 0x45, 0x1c, 0x95, 0xd4, 0xc5, - 0x80, 0xc6, 0x85, 0x11, 0x49, 0xaa, 0xd7, 0x28, 0xf8, 0x43, 0x82, 0xa8, 0x34, 0x06, 0xaf, 0xce, 0xa4, 0x6b, 0xa5, - 0x56, 0x54, 0x0c, 0xca, 0x41, 0x01, 0xf7, 0xa7, 0xbc, 0xb5, 0x90, 0x7e, 0x86, 0x88, 0xca, 0x50, 0xde, 0xe0, 0x17, - 0x0c, 0x9e, 0xcc, 0xae, 0xd2, 0x30, 0x19, 0x6d, 0x68, 0x3c, 0x5a, 0x22, 0x1c, 0x0c, 0x5b, 0xa5, 0x0a, 0x6f, 0xfd, - 0x12, 0xd2, 0x6f, 0x69, 0x3c, 0xba, 0xa1, 0xa9, 0xb5, 0x39, 0x35, 0x50, 0x57, 0xbd, 0x31, 0xbd, 0x8d, 0xe0, 0xf5, - 0x26, 0x5a, 0x52, 0xd8, 0x4a, 0xa7, 0x79, 0x76, 0x29, 0xa2, 0x94, 0x22, 0x02, 0xe1, 0x1a, 0x91, 0x03, 0x97, 0x1a, - 0x6d, 0x70, 0x3d, 0x80, 0x32, 0x34, 0x5c, 0xe0, 0x72, 0x10, 0x8f, 0x96, 0x1e, 0x99, 0x5a, 0xeb, 0x8b, 0x2c, 0xc2, - 0x47, 0x3b, 0x1b, 0x2d, 0xc5, 0x33, 0x62, 0x61, 0x5c, 0xc1, 0x10, 0xea, 0xc2, 0x4a, 0x53, 0x90, 0x74, 0x81, 0x23, - 0x7b, 0x61, 0x5c, 0x85, 0x5b, 0x30, 0x2d, 0xda, 0x80, 0x79, 0x14, 0x28, 0x1c, 0x5c, 0x82, 0xf4, 0x13, 0xca, 0x76, - 0x8e, 0xd2, 0xe4, 0xf0, 0x26, 0xe8, 0x62, 0x6f, 0x82, 0x90, 0x76, 0x75, 0x93, 0x2d, 0xe9, 0x1b, 0x6c, 0xef, 0xd1, - 0xa9, 0xa8, 0xa0, 0xfa, 0xdc, 0x82, 0xc9, 0x92, 0x0d, 0xc2, 0x96, 0x30, 0x3d, 0xd3, 0x17, 0x80, 0x3d, 0x7d, 0x78, - 0xb4, 0x37, 0xdf, 0xc5, 0xec, 0xcd, 0x61, 0x19, 0x8d, 0x95, 0x05, 0x6f, 0x6e, 0x89, 0xdd, 0x92, 0x8d, 0xa7, 0xcb, - 0xe3, 0x72, 0xba, 0x44, 0x62, 0x67, 0xe8, 0x16, 0xe3, 0xf3, 0xe5, 0x82, 0x26, 0x78, 0xb6, 0xb1, 0x6a, 0xbe, 0x34, - 0x68, 0x29, 0x29, 0xc3, 0xf5, 0xb6, 0x44, 0xff, 0x7f, 0x75, 0xf1, 0x4b, 0x01, 0x5e, 0x82, 0xb1, 0x00, 0x10, 0xee, - 0xc1, 0xb4, 0x20, 0xb5, 0x51, 0x36, 0xd6, 0x69, 0x98, 0xe2, 0x22, 0x30, 0x29, 0xfd, 0x7e, 0x98, 0xb3, 0x94, 0x78, - 0xd0, 0xa1, 0x76, 0x94, 0x56, 0x0d, 0x9b, 0x39, 0xe0, 0x91, 0xd4, 0x39, 0x36, 0xf9, 0xfb, 0x78, 0x16, 0xa8, 0x81, - 0x08, 0xa2, 0xec, 0x18, 0x1f, 0x31, 0x70, 0x51, 0xa4, 0xe3, 0x76, 0xba, 0x22, 0x2e, 0xf7, 0x8f, 0x59, 0x88, 0x93, - 0x84, 0xb9, 0x66, 0xd9, 0x90, 0x55, 0x11, 0x26, 0xe8, 0xc2, 0xc0, 0x7e, 0x6d, 0xc8, 0xaa, 0xc3, 0x23, 0x88, 0xd4, - 0x6a, 0xcb, 0xb8, 0xea, 0x2a, 0xe3, 0x7b, 0x00, 0xb2, 0x66, 0x8c, 0x1d, 0xfd, 0x6d, 0x3c, 0x53, 0xdf, 0x44, 0x21, - 0x3f, 0x39, 0xfa, 0x1b, 0x24, 0x1f, 0x7f, 0x8f, 0xcc, 0x1c, 0x24, 0x37, 0x0a, 0x3a, 0x6f, 0xce, 0xba, 0x86, 0xd2, - 0xc4, 0xb5, 0x57, 0xea, 0xb5, 0x27, 0xcd, 0xda, 0x2b, 0xd0, 0x9d, 0xda, 0xf0, 0x1e, 0xca, 0x76, 0x16, 0x4c, 0xd0, - 0xd1, 0xec, 0x0e, 0x74, 0xf0, 0x4e, 0x11, 0xf4, 0x2c, 0x09, 0x8d, 0x47, 0xa8, 0x32, 0xea, 0xc5, 0x78, 0x50, 0x9d, - 0xac, 0x4b, 0xe6, 0x19, 0x30, 0xc7, 0xf6, 0x1c, 0x12, 0xc3, 0x5c, 0x1d, 0xd4, 0x29, 0x2b, 0x87, 0x39, 0x1e, 0xc0, - 0x6b, 0x26, 0x87, 0x62, 0x90, 0x6b, 0x94, 0xef, 0x0b, 0x56, 0x0c, 0xcb, 0x41, 0xae, 0xb9, 0x99, 0x69, 0x33, 0x36, - 0x6d, 0xa2, 0xc3, 0x33, 0xaf, 0xd8, 0xc9, 0xaa, 0x07, 0x7c, 0x2c, 0x78, 0x32, 0xfb, 0x9e, 0x8f, 0x0f, 0x80, 0x93, - 0xd9, 0xde, 0x46, 0x4b, 0xba, 0x89, 0x52, 0x7a, 0x13, 0xad, 0xe9, 0x32, 0xba, 0x30, 0x26, 0xc6, 0x49, 0x0d, 0xe7, - 0x00, 0xb4, 0x0a, 0x20, 0xf1, 0xd4, 0xaf, 0xf7, 0x3c, 0xa9, 0xc2, 0x25, 0x4d, 0xc1, 0x6d, 0xd8, 0xb7, 0xcf, 0x3c, - 0xf3, 0x25, 0x52, 0x5b, 0xc4, 0x58, 0xb3, 0x86, 0x8a, 0x5b, 0x6f, 0xdd, 0x47, 0xa2, 0x86, 0x9d, 0xeb, 0x62, 0x13, - 0x55, 0xc3, 0xc9, 0xb4, 0x04, 0xc4, 0xd6, 0x72, 0x38, 0x74, 0x47, 0xc8, 0xfe, 0xf1, 0xa3, 0x03, 0x3d, 0xf7, 0xa4, - 0xc5, 0xb6, 0x6d, 0xf9, 0x03, 0x43, 0x98, 0xd2, 0x2f, 0x1f, 0xf9, 0x80, 0x58, 0x71, 0x0e, 0x67, 0x23, 0x50, 0x47, - 0x2b, 0x74, 0xfa, 0x57, 0x15, 0x16, 0xfa, 0x00, 0xdf, 0xde, 0x46, 0x09, 0xdd, 0x44, 0xb9, 0x47, 0xd6, 0x96, 0x35, - 0x93, 0xd3, 0xb3, 0x2c, 0xe4, 0xed, 0x03, 0xbd, 0x5c, 0x00, 0x88, 0xd6, 0x20, 0xf6, 0xa5, 0xae, 0x47, 0xe0, 0x34, - 0x84, 0x26, 0xa1, 0x11, 0x5c, 0x55, 0x10, 0x46, 0xc0, 0x95, 0x84, 0xbf, 0xc1, 0x44, 0x05, 0xbe, 0x00, 0x17, 0x99, - 0x34, 0xcd, 0x79, 0x50, 0xfb, 0x23, 0xf9, 0xba, 0x68, 0x7b, 0xbb, 0xc2, 0x68, 0x82, 0xb1, 0x27, 0xda, 0xe7, 0x91, - 0x72, 0x14, 0x17, 0x49, 0x98, 0x8d, 0x6e, 0xd5, 0x79, 0x4e, 0xb3, 0xd1, 0x46, 0xff, 0xaa, 0xe8, 0x98, 0xfe, 0xaa, - 0x03, 0xda, 0x28, 0xe9, 0x5b, 0xc7, 0xd9, 0x80, 0xd6, 0x8b, 0xa5, 0xf1, 0xbf, 0x96, 0xa3, 0x5b, 0x2a, 0x47, 0x1b, - 0xdf, 0x92, 0x6a, 0x32, 0x2d, 0x8e, 0x05, 0x1a, 0x52, 0x75, 0x7e, 0x5f, 0x00, 0x3f, 0x57, 0x1a, 0xdf, 0x69, 0xf3, - 0xbd, 0xd7, 0xfe, 0x4d, 0x27, 0x4f, 0xa0, 0x58, 0xa2, 0x82, 0x55, 0x23, 0xb0, 0x63, 0x5f, 0xe7, 0x71, 0x61, 0x46, - 0x29, 0xa6, 0xd6, 0xa4, 0x1f, 0x03, 0x57, 0x4c, 0x7b, 0x05, 0xb8, 0x5a, 0x82, 0x93, 0x00, 0xc4, 0xd0, 0x84, 0x3d, - 0x3b, 0x86, 0xa8, 0xe7, 0xc6, 0x31, 0x4a, 0x36, 0xdc, 0x03, 0x62, 0x2d, 0xf3, 0x56, 0x2e, 0x01, 0x09, 0xbc, 0xf5, - 0x30, 0x29, 0x00, 0x63, 0xb0, 0x5c, 0x12, 0x9d, 0xc7, 0x43, 0x9f, 0x50, 0x2f, 0x34, 0xea, 0x84, 0x6c, 0x6c, 0x09, - 0x1c, 0x7f, 0x58, 0x1f, 0x02, 0xc1, 0xab, 0x3c, 0xd7, 0x5f, 0x69, 0x5d, 0x7f, 0xa9, 0xf4, 0xdc, 0xb1, 0xbc, 0xa8, - 0xd5, 0x6d, 0x6a, 0xf4, 0x02, 0x2c, 0x7c, 0xb7, 0xca, 0x3c, 0x92, 0x5b, 0x84, 0x54, 0x05, 0x56, 0xea, 0x16, 0x12, - 0xcc, 0xbf, 0x92, 0xb3, 0x55, 0x99, 0xaf, 0x1e, 0xb9, 0x57, 0xce, 0xa6, 0xa7, 0xbf, 0x21, 0x41, 0xdb, 0x74, 0xa4, - 0x79, 0xbc, 0x45, 0x87, 0xcf, 0xae, 0xb5, 0xc4, 0xdc, 0x4b, 0x54, 0x3c, 0x9f, 0x02, 0xb6, 0x7a, 0x96, 0x5d, 0x29, - 0x1f, 0xab, 0x7d, 0x1c, 0x3f, 0x73, 0xfe, 0x24, 0x55, 0x78, 0x21, 0x1a, 0x4a, 0x10, 0xf0, 0xe6, 0x30, 0x76, 0x85, - 0x2a, 0xa0, 0xa1, 0xb9, 0x81, 0xe3, 0x5c, 0x0d, 0x2b, 0x4d, 0xc0, 0xb4, 0x94, 0x47, 0x07, 0x38, 0x34, 0x79, 0xd4, - 0x6e, 0x1a, 0x56, 0x86, 0xae, 0x35, 0xfa, 0xdc, 0x56, 0x3a, 0xe3, 0xcd, 0x86, 0x1f, 0x1e, 0x0d, 0x2a, 0xfc, 0x49, - 0x9a, 0xa3, 0xd1, 0xce, 0x0d, 0x77, 0x1a, 0x81, 0x99, 0x2b, 0xb9, 0x22, 0xfb, 0xa3, 0xe4, 0xe5, 0xf7, 0xf4, 0xc2, - 0x02, 0xfa, 0xf3, 0xdf, 0x17, 0x13, 0x4e, 0x5a, 0x62, 0x42, 0xb4, 0x74, 0xd0, 0xa2, 0x83, 0x3d, 0xe5, 0x95, 0x7d, - 0x89, 0x97, 0xce, 0xf1, 0x7f, 0xae, 0xc7, 0xda, 0x57, 0x20, 0xb4, 0x3a, 0x79, 0xd8, 0x9e, 0x2c, 0x10, 0x35, 0xa0, - 0x9a, 0x5d, 0x95, 0xa3, 0x4c, 0x3b, 0x2b, 0xb2, 0x6d, 0xc8, 0x5c, 0xf7, 0xb3, 0x34, 0x6c, 0x26, 0x3b, 0x16, 0x96, - 0x19, 0x06, 0x6b, 0xa7, 0x8a, 0x3e, 0x07, 0x2d, 0x3f, 0x82, 0x67, 0x4d, 0xe5, 0x99, 0xcf, 0x66, 0x19, 0xf1, 0x02, - 0x9d, 0x73, 0x2a, 0x16, 0x4d, 0xe9, 0x58, 0xb9, 0xdb, 0x95, 0x68, 0x2c, 0x51, 0x46, 0x41, 0x50, 0xdb, 0x20, 0xec, - 0xba, 0x74, 0x4f, 0xfa, 0xb4, 0x8f, 0x4f, 0x2b, 0xd0, 0xf7, 0xf8, 0x2e, 0x03, 0x89, 0xa9, 0x27, 0x79, 0xa8, 0x1a, - 0xcd, 0xd1, 0xc9, 0xb3, 0x3c, 0xd5, 0xf8, 0xfc, 0x4a, 0x76, 0xd6, 0xbc, 0x5b, 0x8d, 0x29, 0xfe, 0x23, 0x75, 0xfb, - 0xce, 0x65, 0x68, 0xa2, 0xbf, 0x96, 0x07, 0x2d, 0x85, 0x05, 0xc7, 0x6d, 0xe3, 0xaf, 0xdf, 0x66, 0x0e, 0x31, 0x2c, - 0x5d, 0x0e, 0x6f, 0x42, 0x87, 0xee, 0xae, 0xb2, 0x37, 0xd7, 0x47, 0xd4, 0xa9, 0x8b, 0x75, 0x1b, 0x50, 0xb2, 0xe4, - 0xdd, 0x3a, 0x3d, 0xb1, 0xd2, 0xaf, 0x87, 0xe1, 0xde, 0x3c, 0x6a, 0x76, 0x77, 0xb7, 0x9b, 0x90, 0xb6, 0x7d, 0x30, - 0xde, 0x97, 0xb0, 0x10, 0xe7, 0x1d, 0x76, 0xf0, 0x73, 0x58, 0x3d, 0xe4, 0x83, 0xdf, 0x71, 0x9c, 0x61, 0xf4, 0x33, - 0x65, 0xe8, 0xf3, 0xa2, 0x90, 0x57, 0xaa, 0x53, 0xbe, 0xd0, 0xad, 0x65, 0xea, 0xfd, 0x26, 0x7e, 0xd3, 0x0a, 0x10, - 0xe3, 0x75, 0xc5, 0x4a, 0xf1, 0x86, 0x56, 0x18, 0xd7, 0xc0, 0x6d, 0x72, 0xa8, 0xa5, 0x5a, 0x20, 0xea, 0xf2, 0x93, - 0x87, 0x3c, 0x32, 0xea, 0x4c, 0xf8, 0xee, 0x21, 0xf7, 0xa5, 0x6b, 0xfb, 0x4d, 0xfc, 0x52, 0xd3, 0x0e, 0xf7, 0x07, - 0xba, 0xa3, 0x75, 0xf7, 0x37, 0xcf, 0xe6, 0xe7, 0x91, 0xf9, 0x62, 0x80, 0xcd, 0xda, 0x67, 0x5c, 0xf6, 0x0c, 0xf7, - 0xbd, 0xe9, 0xc1, 0x58, 0x40, 0x20, 0x31, 0x43, 0x2f, 0x03, 0x17, 0xb8, 0xc0, 0x5d, 0x61, 0xc0, 0x10, 0xd7, 0xb4, - 0xe4, 0x56, 0x5b, 0xd9, 0xfa, 0xc8, 0xdb, 0xa8, 0x10, 0xac, 0xeb, 0x8e, 0x9b, 0x24, 0x87, 0xe0, 0x84, 0x2d, 0xf7, - 0xbe, 0xf6, 0xda, 0x19, 0xfe, 0x32, 0x10, 0xce, 0x2d, 0xd1, 0x33, 0x6a, 0x7b, 0xa8, 0xd5, 0xbd, 0x86, 0x57, 0xd9, - 0x44, 0x9e, 0xf5, 0x9b, 0x79, 0x69, 0xd8, 0x17, 0xbc, 0x96, 0x82, 0x43, 0x63, 0xbb, 0x15, 0x6e, 0xb1, 0x78, 0x47, - 0xab, 0x95, 0xb5, 0xb6, 0xda, 0x6b, 0xa5, 0xa2, 0x77, 0xaf, 0x39, 0x4e, 0x9c, 0xa5, 0xb0, 0xfd, 0xf0, 0xfe, 0x82, - 0x5d, 0x13, 0xc0, 0xa0, 0xc5, 0x64, 0x81, 0x12, 0x54, 0xb2, 0x56, 0xb5, 0xdb, 0x29, 0xf1, 0xcb, 0xfd, 0xaa, 0xcb, - 0x6c, 0xe7, 0xf1, 0xeb, 0x26, 0xed, 0x0b, 0x9f, 0xa3, 0x1f, 0xe6, 0x0f, 0xd6, 0x49, 0xc9, 0x19, 0xc6, 0xb5, 0xfc, - 0xff, 0x2a, 0x7a, 0x59, 0x64, 0x69, 0xb4, 0x35, 0x3c, 0x98, 0x0d, 0xb5, 0xe9, 0x43, 0x63, 0x54, 0x6e, 0xd9, 0x28, - 0x22, 0x5a, 0xdd, 0x82, 0x60, 0x46, 0x71, 0x5f, 0xa2, 0xcd, 0x2b, 0x55, 0x16, 0xde, 0xe1, 0x0b, 0x1b, 0xbd, 0x61, - 0x7b, 0x42, 0x28, 0xdf, 0x3f, 0x2d, 0xcc, 0xaa, 0xa5, 0xa2, 0xc1, 0x76, 0x09, 0xef, 0x62, 0x54, 0xe9, 0x27, 0x4c, - 0xb6, 0x2c, 0x98, 0xea, 0xff, 0x8f, 0x45, 0x96, 0xb6, 0x29, 0x3a, 0x30, 0x9d, 0x4d, 0x9f, 0x4e, 0xba, 0xc5, 0x75, - 0x06, 0x2c, 0x22, 0xd8, 0x52, 0xe1, 0x78, 0x94, 0xda, 0x0d, 0x12, 0x26, 0x82, 0x9b, 0xa8, 0x97, 0x1d, 0x2d, 0x53, - 0xb2, 0x2a, 0xe0, 0xf9, 0x95, 0xab, 0x4c, 0xc7, 0xd1, 0xd0, 0xef, 0x9f, 0xa5, 0x26, 0xf4, 0x2b, 0xf5, 0x52, 0x15, - 0xe7, 0x61, 0x54, 0x1d, 0x2a, 0x8c, 0xd1, 0x92, 0xa6, 0x70, 0x0c, 0x66, 0x17, 0x61, 0x8a, 0x97, 0xb3, 0x6d, 0xc2, - 0xbe, 0x62, 0x20, 0x97, 0xda, 0xa0, 0x5e, 0x53, 0xa2, 0x35, 0x6b, 0x6f, 0xe6, 0x94, 0xd0, 0x0b, 0x56, 0xfa, 0x77, - 0xa1, 0x35, 0x08, 0x14, 0x65, 0x33, 0x65, 0xba, 0xd1, 0xed, 0xbc, 0xa0, 0x09, 0x2d, 0xe8, 0x8a, 0xd4, 0xa0, 0xef, - 0x75, 0x72, 0x76, 0x74, 0xb2, 0x33, 0xb3, 0x1e, 0xb3, 0x62, 0x38, 0x99, 0xc6, 0x70, 0x4d, 0x8b, 0xdd, 0x35, 0x6d, - 0xd9, 0xbc, 0x71, 0x35, 0x36, 0x4e, 0x83, 0x76, 0x81, 0xb4, 0x4d, 0x73, 0xfb, 0xa9, 0xc7, 0xed, 0xaf, 0x6b, 0xb6, - 0x9c, 0xf6, 0xd6, 0xbb, 0x5d, 0x2f, 0x05, 0x1b, 0x51, 0x8f, 0x8f, 0x5f, 0x2b, 0xe9, 0xba, 0xe5, 0xf2, 0x53, 0x78, - 0xf6, 0xf8, 0xfa, 0xa5, 0x0f, 0x2e, 0x47, 0xab, 0x36, 0x77, 0xbf, 0xdc, 0x47, 0x96, 0xfb, 0xaa, 0xa1, 0xe5, 0x7a, - 0x86, 0x9a, 0xe4, 0xd9, 0x68, 0xef, 0x50, 0x0b, 0x96, 0xb3, 0x6e, 0xc2, 0x13, 0x83, 0x1d, 0x7b, 0xd5, 0xd8, 0x1c, - 0x95, 0xb9, 0x64, 0x35, 0x48, 0xa0, 0x4f, 0xf2, 0x4c, 0xd3, 0x3f, 0xca, 0x30, 0x1f, 0xdd, 0xd2, 0x1c, 0x70, 0xc5, - 0x2a, 0x7b, 0xc9, 0x20, 0x75, 0xd5, 0x5e, 0xe2, 0xca, 0x57, 0x38, 0x24, 0x5b, 0x7c, 0x32, 0x4c, 0xd5, 0x17, 0x97, - 0x3c, 0xf8, 0x7f, 0x5b, 0xb5, 0x4a, 0xcf, 0x4d, 0x72, 0xc3, 0xf1, 0xaf, 0x93, 0xb6, 0x8f, 0x89, 0x41, 0x02, 0x9e, - 0xda, 0xc5, 0x50, 0x8d, 0xaa, 0x22, 0x16, 0x65, 0x6e, 0x62, 0x8e, 0xdd, 0xd9, 0x35, 0x74, 0x50, 0x06, 0xbf, 0x6e, - 0xf8, 0xc4, 0xdc, 0x81, 0xad, 0x40, 0x47, 0x27, 0x9a, 0xcb, 0x30, 0x33, 0x97, 0x61, 0xda, 0xb5, 0x55, 0x60, 0x78, - 0xd5, 0x56, 0x49, 0x94, 0xab, 0x51, 0x8f, 0x9b, 0x59, 0x6a, 0xf6, 0x22, 0xef, 0x5e, 0x93, 0x9e, 0xc4, 0x9f, 0x2e, - 0x3d, 0x79, 0x3d, 0x0c, 0x88, 0xfc, 0x9a, 0xa5, 0xe1, 0x1a, 0x05, 0xc1, 0xa9, 0xd5, 0x0e, 0xa4, 0xf9, 0x08, 0x90, - 0xf9, 0x71, 0x1a, 0x7e, 0xd0, 0xe2, 0x1c, 0xb2, 0x55, 0x1a, 0x27, 0xb6, 0x34, 0xea, 0x21, 0xb8, 0xf3, 0x5e, 0xf1, - 0x18, 0x02, 0x1f, 0x7e, 0xc4, 0xcd, 0xa0, 0xa2, 0xdb, 0x12, 0x13, 0xa5, 0xcd, 0xa3, 0x6e, 0xf9, 0xa8, 0x21, 0x54, - 0xb2, 0x32, 0xbc, 0x04, 0xda, 0xbb, 0x27, 0x30, 0xaa, 0x9c, 0x40, 0x66, 0x58, 0x1c, 0x1e, 0x0d, 0x53, 0x25, 0x28, - 0x1a, 0xca, 0xe1, 0x12, 0xe5, 0x80, 0x98, 0x04, 0x02, 0xa3, 0x62, 0x90, 0xea, 0xca, 0xd4, 0x8b, 0x41, 0xaa, 0x6f, - 0x55, 0xa4, 0x3e, 0xcb, 0xc2, 0x8a, 0xea, 0x16, 0xd1, 0x31, 0x1d, 0x4a, 0xba, 0x34, 0x3b, 0x35, 0xd7, 0xd2, 0x0b, - 0xb5, 0x1c, 0x9f, 0xea, 0x34, 0x18, 0xc5, 0x0f, 0x2e, 0x45, 0xbf, 0x55, 0xfb, 0xd9, 0x7f, 0x8b, 0x29, 0x35, 0x62, - 0x53, 0x7b, 0x8b, 0x18, 0x56, 0xed, 0xc7, 0xac, 0xca, 0x41, 0xbb, 0x0b, 0xca, 0xc6, 0xca, 0x38, 0xcf, 0x37, 0x82, - 0x99, 0x83, 0xb6, 0xb1, 0x6a, 0xfa, 0xd0, 0x1b, 0x31, 0x6a, 0x6f, 0x4c, 0x35, 0xee, 0x09, 0xfc, 0xb4, 0x41, 0xd3, - 0xbd, 0xc8, 0x73, 0xd4, 0x23, 0xef, 0xfe, 0x67, 0x8e, 0xec, 0x4c, 0xbe, 0x88, 0x65, 0x52, 0xb7, 0x8f, 0x49, 0xb0, - 0x50, 0x75, 0x8c, 0x2e, 0xdc, 0xc8, 0x94, 0xf6, 0x73, 0x6f, 0xfa, 0x11, 0xcf, 0xe4, 0x7e, 0x3b, 0x34, 0xea, 0x4b, - 0xc3, 0x5a, 0x52, 0x44, 0x7d, 0x41, 0x6f, 0x4d, 0x75, 0x74, 0x44, 0xbd, 0x8e, 0xc0, 0xea, 0x8a, 0xb6, 0xa8, 0x01, - 0x98, 0x8c, 0x6b, 0x5b, 0x9b, 0xcf, 0xc1, 0xd4, 0x56, 0x55, 0xf0, 0x84, 0xee, 0x0b, 0xa5, 0x7b, 0x93, 0xba, 0x6e, - 0x0d, 0xb1, 0x05, 0x0c, 0x08, 0xdc, 0xe8, 0xa9, 0xe9, 0x0f, 0x9a, 0xa8, 0x00, 0x34, 0x68, 0xdc, 0xce, 0x74, 0x8e, - 0x44, 0xbf, 0x53, 0x9b, 0xb6, 0x99, 0xea, 0x55, 0xe5, 0x03, 0xa8, 0xf8, 0xb3, 0x74, 0x76, 0x61, 0x46, 0x2c, 0x80, - 0x71, 0x0f, 0x9c, 0xa9, 0xde, 0x69, 0x06, 0xd6, 0x13, 0x79, 0x9e, 0x95, 0x3c, 0x91, 0x02, 0x66, 0x44, 0x5e, 0x5d, - 0x49, 0x01, 0xc3, 0xa0, 0x06, 0x00, 0x2d, 0x9a, 0xcb, 0x68, 0xc2, 0x1f, 0xd5, 0xf4, 0xae, 0x3c, 0xfc, 0x91, 0xce, - 0xf5, 0xdd, 0xb8, 0x06, 0x43, 0xe5, 0x75, 0xc5, 0xf7, 0x32, 0x7d, 0xc7, 0x1f, 0x7b, 0x99, 0x96, 0x72, 0x5d, 0xec, - 0x65, 0x79, 0xf4, 0x1d, 0x7f, 0xa2, 0xf3, 0x1c, 0x3d, 0xae, 0x69, 0x1a, 0x6f, 0xf6, 0xb2, 0xfc, 0xfd, 0xbb, 0xc7, - 0x36, 0xcf, 0xa3, 0x71, 0x4d, 0x6f, 0x38, 0xff, 0xe4, 0x32, 0x4d, 0x74, 0x55, 0xe3, 0xc7, 0x7f, 0xb7, 0xb9, 0x1e, - 0xd7, 0xf4, 0x4a, 0x8a, 0x6a, 0xb9, 0x57, 0xd4, 0xd1, 0x77, 0x47, 0x7f, 0xe7, 0xdf, 0x99, 0xee, 0x1d, 0xd5, 0xf4, - 0xaf, 0x75, 0x5c, 0x54, 0xbc, 0xd8, 0x2b, 0xee, 0x6f, 0x7f, 0xff, 0xfb, 0x63, 0x9b, 0xf1, 0x71, 0x4d, 0x37, 0x3c, - 0xee, 0x68, 0xfb, 0xe4, 0xc9, 0x63, 0xfe, 0xb7, 0xba, 0xa6, 0xbf, 0x31, 0x3f, 0x38, 0xea, 0x69, 0xe6, 0xe9, 0xe1, - 0x73, 0xd9, 0x44, 0x0d, 0x18, 0x7a, 0x68, 0x00, 0x4b, 0x69, 0xd5, 0x34, 0x77, 0x78, 0xe5, 0x82, 0xdb, 0xf7, 0x59, - 0x9c, 0xc6, 0x2b, 0x38, 0x08, 0xb6, 0x68, 0x9c, 0x55, 0x00, 0xa7, 0x0a, 0xbc, 0x67, 0x54, 0xd2, 0xac, 0x94, 0xbf, - 0x71, 0xfe, 0x09, 0x06, 0x0d, 0x21, 0x6d, 0x54, 0x64, 0xa0, 0xb7, 0x2b, 0x1d, 0xd9, 0x08, 0xfd, 0x37, 0x9b, 0x71, - 0x70, 0x7c, 0x18, 0xbd, 0x7e, 0x3f, 0x2c, 0x98, 0x08, 0x0b, 0x42, 0xe8, 0x9f, 0x61, 0x01, 0x0e, 0x25, 0x05, 0xf3, - 0xf2, 0x19, 0xdf, 0x73, 0x6d, 0x14, 0x16, 0x82, 0xe8, 0x2e, 0xb2, 0x0f, 0xa8, 0x7a, 0xf4, 0x1d, 0xba, 0x21, 0x5e, - 0x56, 0x58, 0x30, 0xb4, 0xaa, 0x81, 0x19, 0x82, 0xe2, 0x5f, 0xf3, 0x50, 0x82, 0x4f, 0x3c, 0xc0, 0x47, 0x8f, 0xc9, - 0x8c, 0xab, 0x6b, 0xed, 0xdb, 0x8b, 0xb0, 0xa0, 0x81, 0x6e, 0x3b, 0x04, 0x1d, 0x88, 0xfc, 0x17, 0xe0, 0x29, 0x30, - 0xf0, 0x61, 0x61, 0xd7, 0x1d, 0x78, 0x3e, 0xbf, 0x19, 0xd6, 0xd1, 0x85, 0x1f, 0xfd, 0xcd, 0xba, 0xb0, 0x67, 0x64, - 0x2a, 0x8f, 0xcb, 0xe1, 0x64, 0x3a, 0x18, 0x48, 0x17, 0xc7, 0xed, 0x34, 0x9b, 0xff, 0x36, 0x97, 0x8b, 0x05, 0xea, - 0xbe, 0x71, 0x5e, 0x67, 0xfa, 0x6f, 0xa4, 0x9d, 0x0f, 0x5e, 0x9f, 0xfe, 0xeb, 0xec, 0xc3, 0xe9, 0x0b, 0x70, 0x3e, - 0xf8, 0xf8, 0xfc, 0xc7, 0xe7, 0xef, 0x55, 0x70, 0x77, 0x35, 0xe7, 0xfd, 0xbe, 0x93, 0xfa, 0x84, 0x7c, 0x58, 0x91, - 0xc3, 0x30, 0x7e, 0x58, 0x28, 0xa3, 0x07, 0x72, 0xcc, 0x2c, 0x14, 0x32, 0x54, 0x51, 0xdb, 0xdf, 0xe5, 0x70, 0xe2, - 0x81, 0x59, 0x5c, 0x37, 0x44, 0xb8, 0x7e, 0xcb, 0x6d, 0x90, 0x35, 0x79, 0xe2, 0xf5, 0x83, 0x93, 0xa9, 0x74, 0x6c, - 0x61, 0xc1, 0xa0, 0x6c, 0x68, 0xd3, 0x69, 0x36, 0x2f, 0x16, 0xb6, 0x5d, 0x6e, 0x81, 0x8c, 0xd2, 0xec, 0xe2, 0x22, - 0x54, 0xd0, 0xd5, 0x27, 0xa0, 0x01, 0x30, 0x8d, 0x2a, 0x5c, 0x8b, 0xf8, 0xcc, 0x2f, 0x3f, 0x1a, 0x7b, 0xcd, 0xbb, - 0x41, 0xdd, 0x93, 0x69, 0x56, 0xd5, 0x18, 0xd0, 0xc1, 0x84, 0x72, 0x37, 0xe8, 0x26, 0x98, 0x8c, 0x6a, 0xcb, 0x6f, - 0xf3, 0x6a, 0x61, 0x9a, 0xe3, 0x86, 0xa1, 0xf2, 0x4a, 0xbe, 0x90, 0x0d, 0x44, 0x06, 0x92, 0x61, 0xd8, 0xa3, 0x31, - 0x8a, 0xd4, 0x0f, 0xf6, 0xbd, 0xe3, 0xb7, 0xb9, 0x84, 0x68, 0x8a, 0x19, 0x48, 0xe7, 0x9f, 0x0b, 0xe5, 0x5c, 0x2e, - 0x19, 0x9f, 0x8b, 0xc5, 0x09, 0xb8, 0x9d, 0xcf, 0xc5, 0x22, 0xc2, 0xa0, 0x7c, 0x19, 0xc4, 0x2a, 0x01, 0xbb, 0x17, - 0x07, 0x3d, 0xd2, 0x09, 0x6d, 0x60, 0x37, 0x90, 0x64, 0x83, 0xd2, 0xae, 0x34, 0x44, 0xb9, 0x53, 0x1e, 0x6d, 0x10, - 0x79, 0x88, 0x55, 0xf3, 0xaa, 0xed, 0xc9, 0x66, 0x2e, 0x26, 0xb8, 0xca, 0x62, 0x26, 0xa7, 0xf1, 0x31, 0x2b, 0xa6, - 0x31, 0x94, 0x12, 0xa7, 0x69, 0x18, 0xd3, 0x09, 0x15, 0x84, 0x24, 0x8c, 0xcf, 0xe3, 0x05, 0x4d, 0x50, 0x4a, 0x10, - 0x42, 0xc8, 0x8f, 0x11, 0xda, 0xe6, 0xc0, 0x92, 0xb7, 0xdb, 0xcf, 0x53, 0xf1, 0xed, 0x19, 0x2e, 0xa3, 0x22, 0x74, - 0x8b, 0xce, 0x1a, 0xfe, 0x8d, 0xa8, 0xa0, 0x31, 0x56, 0x0c, 0x41, 0xc0, 0x0b, 0x8c, 0x4a, 0x58, 0x90, 0x98, 0x55, - 0x10, 0x45, 0xa0, 0x9c, 0xc7, 0x0b, 0x56, 0xd0, 0xa6, 0xcd, 0x69, 0xac, 0x4d, 0x82, 0x7a, 0x0e, 0x4b, 0xed, 0x40, - 0x2a, 0x15, 0x62, 0x8f, 0xcf, 0x44, 0xf4, 0x49, 0x1b, 0x1a, 0x00, 0x0a, 0x94, 0x92, 0x8b, 0xdf, 0x7c, 0xbd, 0x87, - 0x9b, 0x82, 0xfe, 0x67, 0x5b, 0x13, 0xed, 0x2c, 0x57, 0x87, 0xde, 0x7c, 0x41, 0xe3, 0x3c, 0x87, 0x50, 0x6c, 0x06, - 0x81, 0x5c, 0x64, 0x15, 0x44, 0xb4, 0xd8, 0x04, 0x26, 0x24, 0x1c, 0xb4, 0xe9, 0x17, 0x48, 0x6d, 0x88, 0xc9, 0x95, - 0x27, 0x06, 0x76, 0x5b, 0x25, 0x08, 0x38, 0xd2, 0xf3, 0xec, 0x73, 0x13, 0x63, 0x4d, 0x53, 0x33, 0x13, 0x6f, 0x43, - 0x21, 0x1a, 0xb4, 0x20, 0x9a, 0xc1, 0xfb, 0xe7, 0x8a, 0xe3, 0x55, 0x07, 0x7e, 0xc0, 0x3b, 0x17, 0x67, 0x5e, 0xcd, - 0x3c, 0x22, 0xa7, 0x3e, 0xcf, 0x11, 0xfd, 0x92, 0x87, 0xd5, 0x48, 0x27, 0x63, 0xac, 0x24, 0x0e, 0x7a, 0x1b, 0x2c, - 0x98, 0x13, 0xba, 0xe2, 0xa1, 0xe5, 0xe3, 0x5f, 0x20, 0x93, 0x51, 0x52, 0x63, 0x45, 0x57, 0x5a, 0x8c, 0x38, 0xaf, - 0x61, 0x96, 0x26, 0x2b, 0xba, 0x58, 0x68, 0xd2, 0x2c, 0x94, 0x69, 0x80, 0x4f, 0xa0, 0xc5, 0xc8, 0x3d, 0xd4, 0xb4, - 0x81, 0xd0, 0xb0, 0x3f, 0x04, 0x7c, 0xe4, 0x1e, 0x3a, 0xfc, 0xff, 0x3c, 0xbb, 0x40, 0xa4, 0xbd, 0x4b, 0x13, 0x19, - 0x8f, 0xd4, 0x0d, 0x1c, 0x14, 0xe3, 0x63, 0xdf, 0x4c, 0xfc, 0xca, 0x19, 0xbd, 0x4f, 0x2a, 0xdf, 0xe1, 0x83, 0xe5, - 0x8f, 0x37, 0x35, 0xb3, 0x32, 0x82, 0xf5, 0xb0, 0xdb, 0xe1, 0x82, 0x68, 0xbb, 0x00, 0x52, 0xcf, 0x78, 0xb5, 0xf0, - 0x8d, 0x57, 0xe3, 0x3b, 0x8c, 0x57, 0x9d, 0xd5, 0x57, 0x98, 0x93, 0x2d, 0xea, 0xb3, 0x94, 0x3c, 0x3f, 0x47, 0x99, - 0x60, 0xd3, 0xe5, 0xac, 0xa4, 0x2a, 0x95, 0xd0, 0x5e, 0xec, 0x67, 0x8c, 0x6f, 0x09, 0xc6, 0x59, 0x71, 0x18, 0x09, - 0x54, 0xa5, 0x92, 0x3a, 0xec, 0x15, 0xa0, 0x1e, 0x83, 0xf7, 0x06, 0x43, 0xd4, 0xc8, 0xd8, 0x4d, 0x1b, 0x08, 0x0d, - 0x8d, 0xf5, 0x68, 0xcf, 0x5a, 0x8f, 0xee, 0x76, 0x95, 0xf1, 0xb7, 0x93, 0xeb, 0x22, 0x41, 0x54, 0x61, 0x35, 0x9a, - 0x00, 0x6f, 0x9a, 0xd8, 0xdb, 0x92, 0x53, 0x5a, 0x60, 0xf8, 0xec, 0x3f, 0xc3, 0xd2, 0xa9, 0x24, 0x4a, 0x32, 0x2b, - 0xa3, 0x81, 0x3b, 0x07, 0x9f, 0xc5, 0x15, 0xac, 0x01, 0x88, 0xe4, 0x88, 0x1e, 0xae, 0x7f, 0x86, 0xd2, 0x65, 0x96, - 0x64, 0x26, 0x21, 0x33, 0x17, 0x69, 0x3b, 0xeb, 0x60, 0xe2, 0x4c, 0x6a, 0xbd, 0xb1, 0x90, 0x43, 0x83, 0xfc, 0x00, - 0xca, 0x10, 0x87, 0x4f, 0x3e, 0x98, 0x50, 0xa9, 0x42, 0xa9, 0x36, 0xba, 0xd9, 0x0d, 0xbc, 0xf2, 0x31, 0xbb, 0xe2, - 0x65, 0x15, 0x5f, 0xad, 0x8c, 0x25, 0x31, 0x67, 0x77, 0xb9, 0xed, 0x51, 0x61, 0x5e, 0xbd, 0x79, 0xfe, 0xe3, 0x69, - 0xe3, 0xd5, 0x3e, 0xe2, 0x68, 0x08, 0xb6, 0x15, 0x63, 0x8c, 0xde, 0xe2, 0xd3, 0x60, 0xa2, 0x5c, 0x23, 0xd0, 0xbb, - 0x14, 0xf4, 0xdb, 0x5f, 0xeb, 0x09, 0x78, 0xc5, 0xf5, 0xf2, 0x4b, 0x3e, 0x01, 0x96, 0xa8, 0xd0, 0xb3, 0xc2, 0xdc, - 0xac, 0xcc, 0xee, 0xec, 0x56, 0x64, 0xa6, 0x5d, 0x69, 0x64, 0x20, 0x5e, 0x6d, 0x87, 0xb1, 0x70, 0xe9, 0x9a, 0x6e, - 0x07, 0xbb, 0x5a, 0x7a, 0x96, 0xc8, 0xbb, 0x5d, 0x09, 0x1d, 0xb2, 0x03, 0xee, 0xbd, 0x8c, 0x6f, 0xe1, 0x65, 0xe9, - 0x75, 0xb3, 0x19, 0x3c, 0x01, 0xcc, 0x84, 0x0b, 0x67, 0x59, 0x1c, 0x33, 0x91, 0x84, 0x2a, 0x36, 0x57, 0x43, 0xe4, - 0xad, 0x08, 0xad, 0xd9, 0x5f, 0xa1, 0x18, 0x81, 0xdd, 0xc9, 0x87, 0x4f, 0xd9, 0x6a, 0xb6, 0x06, 0xd4, 0xfc, 0xab, - 0x4c, 0x00, 0xcd, 0xb5, 0x6b, 0xc1, 0x36, 0x85, 0x36, 0xd7, 0xf5, 0xd3, 0x78, 0x15, 0x27, 0xa0, 0xba, 0x01, 0x6f, - 0x91, 0x6b, 0x2d, 0xba, 0x32, 0xe8, 0xa2, 0xf4, 0x9e, 0x72, 0x2c, 0x29, 0x74, 0xf4, 0xbd, 0x27, 0xd4, 0xb9, 0x67, - 0x00, 0x97, 0x34, 0x6a, 0x9e, 0x6a, 0x29, 0x63, 0x01, 0xb0, 0xd0, 0xc1, 0x4c, 0x91, 0xad, 0xe8, 0xc6, 0x60, 0x52, - 0xc0, 0x5b, 0x03, 0xfc, 0x21, 0xb2, 0x4a, 0xdd, 0x15, 0xcb, 0xb0, 0xf4, 0xec, 0xaf, 0xfb, 0xfd, 0xd8, 0xb3, 0xbf, - 0x5e, 0x69, 0x5a, 0x17, 0xb7, 0x1b, 0x40, 0x6a, 0x0c, 0x20, 0x72, 0xaa, 0x07, 0xc2, 0x44, 0x14, 0x6b, 0xfa, 0xfe, - 0x9d, 0x9a, 0x2c, 0x0a, 0x84, 0x7e, 0xaf, 0x5e, 0x4f, 0x4a, 0x02, 0x3a, 0xb5, 0x8a, 0x9d, 0x0c, 0xb4, 0xd9, 0x07, - 0x04, 0x44, 0xf5, 0x33, 0xb2, 0xf9, 0x42, 0x39, 0x17, 0xab, 0xf0, 0xe1, 0x63, 0x0a, 0x01, 0x85, 0x3b, 0x6a, 0x74, - 0xde, 0x86, 0x48, 0xa0, 0xac, 0x50, 0xc4, 0x9a, 0x17, 0x6b, 0x49, 0xc8, 0x7c, 0xbc, 0x40, 0xc1, 0x95, 0x03, 0x76, - 0xe5, 0x6c, 0x32, 0x2c, 0x23, 0xce, 0xc2, 0xbb, 0xbf, 0x99, 0x2c, 0x08, 0x6a, 0xae, 0xfc, 0x40, 0x8e, 0x7b, 0x99, - 0x1a, 0x7b, 0xaa, 0x51, 0x83, 0x60, 0x32, 0x82, 0xc0, 0x70, 0xc3, 0xaf, 0xf8, 0xf8, 0x68, 0x41, 0x40, 0x45, 0x66, - 0xcd, 0x42, 0xcc, 0x8b, 0xe3, 0x47, 0x80, 0x1a, 0x33, 0x3a, 0x7a, 0x32, 0xe5, 0x0c, 0x0e, 0x51, 0x3a, 0x06, 0x19, - 0xad, 0x80, 0xdf, 0x42, 0xfd, 0x6e, 0x9d, 0xf8, 0x3e, 0xf4, 0xab, 0xa0, 0x17, 0x31, 0x30, 0x1c, 0xd1, 0xe4, 0x30, - 0xe4, 0x83, 0xc9, 0x00, 0xb4, 0x25, 0xde, 0xee, 0x6b, 0x69, 0xc5, 0xcd, 0xe9, 0xd2, 0xe9, 0xfe, 0x49, 0x9b, 0x20, - 0x89, 0x54, 0xb2, 0x52, 0x11, 0x03, 0x08, 0x65, 0xa9, 0xb6, 0xc9, 0x1a, 0x2c, 0x2b, 0xcc, 0x92, 0xe6, 0x06, 0x25, - 0x71, 0x7f, 0x33, 0x70, 0x8c, 0x9a, 0x75, 0x1a, 0x96, 0x2d, 0x37, 0x6a, 0x80, 0xcf, 0x49, 0x58, 0x61, 0x6f, 0x38, - 0x33, 0xe9, 0x9d, 0xe9, 0x70, 0x75, 0xcc, 0xd9, 0x6b, 0x8e, 0x60, 0x1c, 0x09, 0xde, 0x78, 0xe8, 0x92, 0x69, 0xa8, - 0xc8, 0x94, 0x71, 0x30, 0xed, 0x01, 0xee, 0x3d, 0x07, 0xe3, 0x30, 0x36, 0xa8, 0x2c, 0xa9, 0x4f, 0xbd, 0xbb, 0x10, - 0x08, 0xd2, 0x5a, 0x2f, 0xf3, 0x19, 0x9e, 0x9e, 0x11, 0xca, 0xfe, 0x90, 0xc3, 0x17, 0x60, 0x47, 0x41, 0x4e, 0x26, - 0xfc, 0xc9, 0xc3, 0xfd, 0x40, 0x55, 0x7c, 0x10, 0x1c, 0xc4, 0x22, 0x3d, 0x08, 0x06, 0x02, 0x7e, 0x15, 0xfc, 0xa0, - 0x92, 0xf2, 0xe0, 0x22, 0x2e, 0x0e, 0xe2, 0x55, 0x5c, 0x54, 0x07, 0x37, 0x59, 0xb5, 0x3c, 0x30, 0x1d, 0x02, 0x68, - 0xde, 0x60, 0x10, 0x0f, 0x82, 0x83, 0x60, 0x50, 0x98, 0xa9, 0x5d, 0xb1, 0xb2, 0x71, 0x9c, 0x99, 0x10, 0x65, 0x41, - 0x33, 0x40, 0x58, 0xe3, 0x34, 0x00, 0x3e, 0x75, 0xcd, 0x52, 0x7a, 0x81, 0xe1, 0x06, 0xc4, 0x74, 0x0d, 0x7d, 0x00, - 0x1e, 0x79, 0x4d, 0x63, 0x58, 0x02, 0x17, 0x83, 0x01, 0xb9, 0x80, 0xc8, 0x05, 0x6b, 0x6a, 0x83, 0x38, 0x84, 0x6b, - 0x65, 0xa7, 0xbd, 0x0f, 0xcc, 0xb4, 0xdb, 0x01, 0xa2, 0xf2, 0x84, 0xf4, 0xfb, 0xf6, 0x1b, 0xea, 0x5f, 0xb0, 0x97, - 0x60, 0x7f, 0x55, 0x54, 0x61, 0x2e, 0x95, 0xe6, 0xfb, 0x92, 0x9d, 0x0c, 0x54, 0xc4, 0xe1, 0x3d, 0x47, 0x8a, 0x36, - 0x2a, 0x97, 0x65, 0x4f, 0x96, 0x0d, 0x5f, 0x89, 0x2b, 0xee, 0xfc, 0xb8, 0x2a, 0x29, 0xf3, 0x2a, 0x5b, 0x29, 0xf6, - 0x6f, 0xc6, 0x35, 0xf7, 0x07, 0xd6, 0x9f, 0xcd, 0x57, 0x70, 0x6d, 0xf5, 0xde, 0x35, 0xb9, 0x46, 0xe4, 0x2c, 0xa1, - 0x5c, 0x52, 0xdb, 0x3c, 0xbc, 0xa5, 0xef, 0xf3, 0xab, 0x6f, 0x33, 0x9d, 0xc6, 0x67, 0x15, 0x16, 0x2e, 0x44, 0x2b, - 0x82, 0x43, 0x43, 0x2e, 0x9a, 0x47, 0x80, 0xb9, 0xf6, 0xd9, 0x0a, 0x0a, 0x52, 0x9f, 0x55, 0xe8, 0xdd, 0x0a, 0x09, - 0x2f, 0x34, 0xbb, 0x74, 0x3f, 0x90, 0x32, 0x6e, 0x0f, 0x2d, 0x61, 0xd2, 0xf2, 0x22, 0xbc, 0xf7, 0x9a, 0x9b, 0xdc, - 0xb3, 0x10, 0xa3, 0x17, 0x79, 0x76, 0x02, 0xc6, 0xba, 0x4b, 0x76, 0x36, 0x3c, 0xf1, 0x1b, 0x9e, 0xb3, 0x16, 0x8d, - 0xa6, 0x4b, 0x96, 0xf4, 0xfb, 0x31, 0x98, 0x78, 0xa7, 0x2c, 0x87, 0x5f, 0xf9, 0x82, 0xae, 0x19, 0x60, 0x8a, 0xd1, - 0x0b, 0x48, 0x48, 0x11, 0x89, 0x64, 0xad, 0x4e, 0x92, 0x2f, 0x74, 0x17, 0x80, 0xd1, 0x2f, 0x66, 0x69, 0xb4, 0xbc, - 0xd3, 0xcc, 0x02, 0xc9, 0x33, 0xf4, 0x5d, 0x07, 0xdb, 0x1b, 0xfb, 0x20, 0xe5, 0xfc, 0x58, 0x4c, 0x07, 0x03, 0x4e, - 0x34, 0xdc, 0x78, 0xa9, 0xc4, 0xb5, 0xba, 0xc5, 0x1d, 0xc3, 0x58, 0xea, 0xdb, 0x22, 0x06, 0x07, 0xec, 0xa2, 0x95, - 0xdd, 0x3e, 0xc0, 0xbe, 0x72, 0xbc, 0x4b, 0x95, 0xdd, 0xe9, 0x31, 0xd3, 0x5c, 0xb6, 0x9a, 0x74, 0x52, 0x71, 0x37, - 0x91, 0x6f, 0x72, 0x07, 0x5d, 0x2e, 0xc7, 0x9a, 0xb7, 0x1c, 0x80, 0x8a, 0x7e, 0xa4, 0xa8, 0xee, 0x57, 0x38, 0xc2, - 0xdc, 0x5b, 0xb7, 0xf9, 0xe4, 0xd0, 0x14, 0x38, 0x44, 0x9e, 0xb4, 0xd1, 0x14, 0xd0, 0xbd, 0x8b, 0x87, 0x5d, 0xfd, - 0xb6, 0x74, 0x17, 0x28, 0xd1, 0x5e, 0xc5, 0x0d, 0x3f, 0x26, 0xea, 0x74, 0xa6, 0x0d, 0xa1, 0x7f, 0x65, 0xc4, 0xfd, - 0xa5, 0x71, 0x15, 0x6f, 0x7a, 0x97, 0xcf, 0x38, 0xd4, 0xd9, 0x0d, 0xa1, 0x00, 0x5c, 0xb5, 0xa7, 0x53, 0x37, 0x86, - 0xf4, 0x4a, 0x89, 0x6e, 0x83, 0x83, 0xdd, 0xe9, 0x33, 0x8e, 0xa2, 0x1f, 0xa3, 0x46, 0xbe, 0x89, 0xc4, 0x43, 0x39, - 0x88, 0x1f, 0x16, 0x74, 0x19, 0x89, 0x87, 0xc5, 0x20, 0x7e, 0x28, 0xeb, 0x7a, 0xff, 0x5c, 0xb9, 0xbb, 0x8f, 0xc8, - 0xb3, 0xee, 0xed, 0xa5, 0x12, 0x36, 0x06, 0x9e, 0x5d, 0x0b, 0x08, 0xa7, 0xe0, 0x89, 0x6c, 0x2d, 0x7d, 0xe8, 0xdc, - 0xee, 0x63, 0xcb, 0x24, 0x41, 0xd0, 0xf3, 0x36, 0x9b, 0x44, 0xb1, 0xb3, 0xcd, 0xa3, 0x0f, 0xa7, 0x40, 0x42, 0xb7, - 0xdb, 0x66, 0x5d, 0xad, 0x01, 0xc5, 0x34, 0x1c, 0xf3, 0xc3, 0x62, 0x74, 0xe3, 0xbb, 0xeb, 0x1f, 0x16, 0xa3, 0x25, - 0x19, 0x4e, 0xcc, 0xe4, 0xc7, 0x27, 0xe3, 0x59, 0x1c, 0x4d, 0xea, 0x8e, 0xd3, 0x42, 0xe3, 0x9f, 0x7a, 0xb7, 0x50, - 0x04, 0x4e, 0xc5, 0x08, 0x8e, 0x9c, 0x0a, 0xe5, 0xa4, 0xd4, 0xc0, 0xf0, 0x3f, 0xa8, 0xf6, 0xb4, 0x69, 0xaf, 0xe3, - 0x2a, 0x59, 0x66, 0xe2, 0x52, 0x87, 0x0f, 0xd7, 0xd1, 0xc5, 0x6d, 0x40, 0x3b, 0xef, 0x32, 0xed, 0xf8, 0x75, 0xd2, - 0xa0, 0x27, 0xae, 0x66, 0x06, 0xdc, 0xba, 0x1f, 0xa1, 0x19, 0x02, 0xa3, 0xe5, 0xf9, 0x3b, 0xc4, 0xdc, 0xfe, 0x55, - 0xd9, 0xfc, 0x2a, 0xda, 0xe7, 0xc8, 0x48, 0xd9, 0x26, 0x23, 0x15, 0x18, 0x61, 0x4a, 0x91, 0xc4, 0x55, 0x08, 0x81, - 0xec, 0xbf, 0xa6, 0xb8, 0x16, 0x4b, 0xef, 0x35, 0x08, 0x13, 0x6c, 0x17, 0xb4, 0x5f, 0xdd, 0xde, 0x6d, 0xa5, 0xc5, - 0x1e, 0xa9, 0xef, 0x73, 0x67, 0xbb, 0xa2, 0xc9, 0xdf, 0xd7, 0x0d, 0x68, 0x03, 0x88, 0xf2, 0xae, 0x3e, 0x2a, 0x81, - 0x93, 0x11, 0x37, 0x94, 0x18, 0xbd, 0xa0, 0xab, 0x13, 0xb9, 0x67, 0xa7, 0xe6, 0x4d, 0xc5, 0x4c, 0xc5, 0x95, 0x6f, - 0xf6, 0xcc, 0x7f, 0x30, 0x14, 0x54, 0x82, 0x81, 0xb7, 0x39, 0xe3, 0xd1, 0x81, 0xee, 0xc6, 0xe8, 0xb4, 0x60, 0xb3, - 0xa0, 0x2e, 0xeb, 0xa6, 0x8d, 0x07, 0x8d, 0x38, 0x28, 0x8a, 0x55, 0xa1, 0x46, 0xc2, 0x13, 0x81, 0x80, 0x29, 0xbb, - 0xe2, 0x91, 0x11, 0xd4, 0xf4, 0x26, 0x14, 0x36, 0x14, 0xfc, 0x55, 0xa2, 0x9a, 0xde, 0x84, 0x36, 0x99, 0x38, 0xcd, - 0x20, 0x82, 0x19, 0xb1, 0xdd, 0x6f, 0x01, 0x6d, 0x6e, 0xcd, 0x68, 0x5b, 0xd7, 0x56, 0x5b, 0x85, 0x5c, 0x52, 0xa4, - 0x2c, 0xff, 0x9d, 0x9a, 0x0a, 0x4a, 0x6a, 0xb9, 0xe8, 0x4d, 0x9a, 0x2e, 0x7a, 0x3c, 0x33, 0x92, 0x40, 0xe5, 0x96, - 0x3b, 0x46, 0x7f, 0x08, 0x0b, 0x3c, 0x62, 0xe2, 0xc4, 0x82, 0xb9, 0xd5, 0x09, 0xcb, 0xe6, 0x62, 0x31, 0x5a, 0x49, - 0x08, 0x1b, 0x7c, 0xcc, 0xb2, 0x79, 0xa9, 0x1f, 0x42, 0x5f, 0x58, 0xfa, 0x00, 0xec, 0x62, 0x83, 0x95, 0x2c, 0x03, - 0xf0, 0xbd, 0xa0, 0xdb, 0x95, 0x2c, 0x23, 0xa9, 0xba, 0x1f, 0xd7, 0x58, 0x82, 0x4a, 0x2b, 0x54, 0x5a, 0x52, 0x63, - 0x41, 0xe0, 0xab, 0xaa, 0xcb, 0x87, 0x64, 0x57, 0x81, 0x7a, 0xea, 0xa8, 0x01, 0xa7, 0x40, 0x55, 0x81, 0x05, 0x49, - 0x50, 0x19, 0xba, 0x2a, 0x30, 0xad, 0xc0, 0x34, 0x53, 0x85, 0x8b, 0x32, 0x3b, 0x94, 0x66, 0xbd, 0xe4, 0xb3, 0x78, - 0x10, 0x26, 0xc3, 0x98, 0x3c, 0x44, 0xa8, 0xfd, 0xc3, 0x3c, 0x8a, 0xb5, 0x5c, 0xf2, 0xd2, 0xf9, 0xc5, 0xdf, 0x7c, - 0xc1, 0x5e, 0xf7, 0x0c, 0x83, 0x05, 0x38, 0x4b, 0xdb, 0xab, 0x4c, 0xbc, 0x93, 0xad, 0xe0, 0x38, 0x98, 0x45, 0x39, - 0xac, 0x7a, 0x72, 0x44, 0x73, 0x91, 0x6b, 0xef, 0x22, 0x44, 0x0e, 0x32, 0x7b, 0x0c, 0xb0, 0x1b, 0xe1, 0xeb, 0xd0, - 0xda, 0xdc, 0xea, 0x0a, 0xf1, 0x37, 0x4a, 0x24, 0x7e, 0x92, 0xf2, 0xd3, 0x7a, 0xa5, 0x72, 0x55, 0x06, 0x8f, 0x55, - 0x37, 0x83, 0x67, 0xda, 0xf7, 0x58, 0xfb, 0xb7, 0xb6, 0x9b, 0xe3, 0xbd, 0x07, 0x0f, 0x5a, 0xff, 0x5b, 0x4f, 0x42, - 0x68, 0xaf, 0x9c, 0xa4, 0xee, 0xa8, 0xd1, 0x33, 0x93, 0x35, 0xa2, 0x12, 0xa6, 0x76, 0xa7, 0x72, 0x0c, 0xd4, 0x74, - 0x00, 0xd7, 0x12, 0x35, 0x41, 0x4f, 0x0a, 0x36, 0x86, 0x23, 0xce, 0xe2, 0xa0, 0x1d, 0xc7, 0x28, 0x5e, 0xce, 0x95, - 0x78, 0x39, 0x3f, 0x61, 0x1c, 0xa0, 0xb5, 0x00, 0xa9, 0x5e, 0xc3, 0x7e, 0xe6, 0x0a, 0x16, 0xd8, 0xdc, 0xf9, 0x8e, - 0x2c, 0x90, 0x21, 0x4e, 0x36, 0xc7, 0xc9, 0x1e, 0xd7, 0x7a, 0xee, 0x05, 0x3e, 0x4e, 0xea, 0x85, 0x57, 0x57, 0xd9, - 0xae, 0x6b, 0xc9, 0xca, 0x79, 0x31, 0x98, 0x40, 0x50, 0x96, 0x72, 0x5e, 0x0c, 0x27, 0x0b, 0x9a, 0xc3, 0x8f, 0x45, - 0x03, 0x1d, 0x62, 0x39, 0x48, 0xe0, 0xd2, 0xd9, 0x63, 0xc0, 0x1b, 0x4a, 0x2d, 0xee, 0xc6, 0x3a, 0x72, 0xac, 0xa3, - 0x38, 0x0c, 0x63, 0xc0, 0x95, 0x75, 0x02, 0xef, 0xbb, 0xaf, 0x8f, 0x4d, 0x40, 0x56, 0xed, 0x0a, 0xaf, 0x46, 0xb9, - 0xeb, 0x4a, 0xa3, 0x2f, 0x29, 0x3d, 0xe1, 0x05, 0x4f, 0x25, 0xbb, 0x5d, 0xcf, 0xc0, 0xd9, 0x12, 0x0f, 0x89, 0x77, - 0x8c, 0xe8, 0xc5, 0xb4, 0x91, 0x99, 0x13, 0x38, 0xb3, 0xdd, 0x65, 0x1b, 0xf3, 0x63, 0x07, 0x38, 0x58, 0x04, 0x21, - 0x71, 0x43, 0x18, 0x26, 0x76, 0x52, 0x0e, 0xb5, 0x10, 0xae, 0x6b, 0xe1, 0x75, 0x9c, 0x96, 0x31, 0xb8, 0x48, 0x6b, - 0xdb, 0xc4, 0x3b, 0xe8, 0xba, 0xe7, 0xc7, 0xdc, 0xea, 0x18, 0x6d, 0x21, 0xfd, 0x76, 0x74, 0xfa, 0xc0, 0x61, 0x00, - 0x9a, 0x1e, 0xcc, 0xaa, 0xf6, 0x99, 0xc4, 0xcd, 0x69, 0x27, 0x08, 0x89, 0x40, 0x14, 0xa5, 0x33, 0xc2, 0xf4, 0xef, - 0x35, 0x97, 0x55, 0xb4, 0xba, 0x97, 0x67, 0x0e, 0x79, 0x16, 0x7a, 0xdb, 0x83, 0x56, 0xcd, 0xdd, 0x60, 0x9c, 0xb8, - 0xdd, 0xde, 0xf9, 0x7f, 0xcb, 0xba, 0xb6, 0x5a, 0x23, 0x1e, 0xb6, 0xab, 0x1f, 0x34, 0xf6, 0x6a, 0x4f, 0xc5, 0x80, - 0xb9, 0x94, 0xde, 0x19, 0x55, 0xf2, 0x22, 0xe3, 0x25, 0x9e, 0x54, 0x97, 0x0d, 0x1f, 0xef, 0x9b, 0x6c, 0x64, 0x1e, - 0xc8, 0x14, 0x10, 0xcf, 0x3f, 0xa4, 0x46, 0x7d, 0x9c, 0xa2, 0x04, 0xfc, 0x9d, 0x8e, 0x6f, 0x44, 0x5f, 0xdb, 0x17, - 0x97, 0xbc, 0x7a, 0x7b, 0x23, 0xcc, 0x8b, 0x67, 0x56, 0xe7, 0x4f, 0x9f, 0x16, 0x3e, 0x74, 0x38, 0x6a, 0xef, 0xa0, - 0xc8, 0x92, 0x89, 0x93, 0x89, 0x91, 0xb5, 0x89, 0xd9, 0x6b, 0x05, 0x17, 0x13, 0x55, 0xe8, 0x59, 0x67, 0x4f, 0x98, - 0x02, 0xf4, 0x8d, 0x63, 0x54, 0x32, 0x86, 0x05, 0x03, 0x75, 0x9a, 0x12, 0xa2, 0x87, 0x62, 0x86, 0xf1, 0x8a, 0x01, - 0x14, 0xa6, 0x50, 0x20, 0x8a, 0xce, 0x3e, 0x1c, 0x68, 0x42, 0xbf, 0xff, 0x21, 0xd5, 0x19, 0x68, 0x59, 0x4f, 0x0b, - 0x10, 0xd5, 0x41, 0xb4, 0x55, 0x88, 0x0a, 0x9d, 0xd2, 0x32, 0xa3, 0xa9, 0xa0, 0x6b, 0x41, 0x93, 0x8c, 0x5e, 0x70, - 0x25, 0x2a, 0x5e, 0x09, 0xa6, 0x68, 0xbb, 0x21, 0xec, 0xff, 0x68, 0xd0, 0xf5, 0x56, 0xac, 0x35, 0xb4, 0x3b, 0x41, - 0x46, 0x68, 0xbe, 0xd0, 0x41, 0xc8, 0x50, 0x39, 0x09, 0x5d, 0xab, 0x34, 0x5e, 0x81, 0x4b, 0xa6, 0xd9, 0x68, 0x19, - 0x97, 0x61, 0x60, 0xbf, 0x0a, 0x2c, 0x26, 0x07, 0x26, 0x7d, 0x58, 0x9f, 0x3f, 0x95, 0x57, 0x2b, 0x29, 0xb8, 0xa8, - 0x14, 0x44, 0xbf, 0xc1, 0x7d, 0x37, 0x71, 0xd5, 0x59, 0xb3, 0x56, 0x7a, 0xdf, 0xb7, 0x3e, 0x6b, 0xe3, 0xbe, 0x30, - 0x38, 0x06, 0x7b, 0x1f, 0x11, 0x03, 0x69, 0x50, 0xe9, 0x16, 0x87, 0x26, 0x40, 0x97, 0x0e, 0x29, 0x64, 0xc9, 0x54, - 0xa6, 0x4a, 0x50, 0xf1, 0x8d, 0xdf, 0x4b, 0x59, 0x8d, 0xfe, 0x5a, 0xf3, 0x62, 0xf3, 0x81, 0xe7, 0x1c, 0xc7, 0x28, - 0x48, 0x62, 0x71, 0x1d, 0x97, 0x01, 0xf1, 0x2d, 0xaf, 0x82, 0xa3, 0xd4, 0x84, 0x8d, 0xd9, 0xab, 0x1a, 0xb5, 0x5e, - 0x05, 0xfa, 0xca, 0x28, 0xdf, 0x18, 0x0c, 0x4d, 0x44, 0x15, 0xf4, 0xbd, 0x56, 0xf7, 0xb4, 0xba, 0x61, 0x01, 0xf1, - 0xe7, 0x4a, 0x2f, 0xd4, 0x7a, 0xdd, 0x8c, 0xb9, 0x61, 0x22, 0x04, 0x8d, 0x1e, 0xd5, 0x0b, 0x87, 0x9f, 0xbf, 0x55, - 0x96, 0x44, 0xf0, 0x62, 0x9b, 0xae, 0x0b, 0x13, 0x4b, 0x83, 0xea, 0x80, 0xb9, 0xd1, 0x36, 0xe7, 0x97, 0x20, 0xfa, - 0x73, 0x56, 0x44, 0x93, 0xba, 0xa6, 0x0a, 0xc1, 0x30, 0xda, 0xde, 0x36, 0xd2, 0xe9, 0x06, 0xbc, 0xdc, 0x8c, 0x35, - 0x92, 0xf6, 0x74, 0xac, 0x69, 0xc1, 0xcb, 0x95, 0x14, 0x25, 0x44, 0x77, 0xee, 0x8d, 0xe9, 0x55, 0x9c, 0x89, 0x2a, - 0xce, 0xc4, 0x69, 0xb9, 0xe2, 0x49, 0xf5, 0x1e, 0x2a, 0xd4, 0xc6, 0x38, 0xd8, 0x7a, 0x35, 0xea, 0x2a, 0x1c, 0xf2, - 0xab, 0x8b, 0xe7, 0xb7, 0xab, 0x58, 0xa4, 0x30, 0xea, 0xf5, 0x5d, 0x2f, 0x9a, 0xd3, 0xb1, 0x8a, 0x0b, 0x2e, 0x4c, - 0xd4, 0x62, 0x5a, 0xb1, 0x80, 0xeb, 0x8c, 0x01, 0xe5, 0x2a, 0x76, 0x67, 0xa6, 0x62, 0x19, 0xc6, 0x65, 0xf9, 0x53, - 0x56, 0xe2, 0x1d, 0x00, 0x5a, 0x03, 0xa7, 0xc5, 0xcc, 0x80, 0x80, 0x6c, 0x72, 0x83, 0x8b, 0xc0, 0x82, 0xa3, 0xc7, - 0xe3, 0xd5, 0x6d, 0x40, 0xbd, 0x37, 0x52, 0x5d, 0x0f, 0x59, 0x30, 0x1e, 0x3d, 0x09, 0x1c, 0x72, 0x88, 0xff, 0xd1, - 0xe3, 0xa3, 0xbb, 0xbf, 0x99, 0x04, 0xa4, 0x9e, 0x82, 0xaa, 0xc2, 0x28, 0x44, 0x61, 0xda, 0x5f, 0xaf, 0xd5, 0x2d, - 0xf7, 0xed, 0x79, 0xc9, 0x8b, 0x6b, 0xd8, 0x97, 0x64, 0x9a, 0x01, 0x39, 0x97, 0x2a, 0x01, 0x16, 0x45, 0x5c, 0x55, - 0x45, 0x76, 0x0e, 0x26, 0x4a, 0x68, 0x00, 0x66, 0x9e, 0x5e, 0xa0, 0xc3, 0x47, 0x34, 0x0f, 0xb0, 0x4f, 0xc1, 0xa2, - 0x26, 0x75, 0x09, 0x85, 0x25, 0x07, 0x18, 0xac, 0x4e, 0xc5, 0x95, 0x76, 0x00, 0xdf, 0xd5, 0x1f, 0xd1, 0x52, 0x62, - 0xac, 0x59, 0x3d, 0x4f, 0xf1, 0x79, 0x29, 0xf3, 0x75, 0x05, 0xda, 0xf3, 0x8b, 0x2a, 0x3a, 0x7a, 0xbc, 0xba, 0x9d, - 0xaa, 0x6e, 0x44, 0xd0, 0x8b, 0xa9, 0xc2, 0x79, 0x4b, 0xe2, 0x3c, 0x09, 0x27, 0xe3, 0xf1, 0x37, 0x07, 0xc3, 0x03, - 0x48, 0x26, 0xd3, 0xcf, 0x43, 0xe5, 0xc8, 0x35, 0x9c, 0x8c, 0xc7, 0xf5, 0x1f, 0xb5, 0x09, 0xf3, 0x6d, 0xea, 0xf9, - 0xf0, 0xc7, 0xb1, 0x5a, 0xff, 0x27, 0xc7, 0x87, 0xfa, 0xc7, 0x1f, 0x75, 0x3d, 0x7d, 0x5a, 0x84, 0xf3, 0x7f, 0x87, - 0x6a, 0x7d, 0x9f, 0x16, 0x45, 0xbc, 0xa9, 0xc9, 0x82, 0xae, 0x84, 0xf3, 0xae, 0xa1, 0x1e, 0x59, 0xa0, 0x47, 0x64, - 0xba, 0x12, 0x0c, 0xbe, 0x79, 0x5f, 0x85, 0x01, 0x2f, 0x57, 0x43, 0x2e, 0xaa, 0xac, 0xda, 0x0c, 0x31, 0x4f, 0x80, - 0x9f, 0x5a, 0x3c, 0xb3, 0xc2, 0x10, 0xdf, 0x8b, 0x82, 0xf3, 0xcf, 0x3c, 0x54, 0xc6, 0xe2, 0x63, 0x34, 0x16, 0x1f, - 0x53, 0xd5, 0x8d, 0xc9, 0x77, 0x54, 0xf7, 0x6d, 0xf2, 0x1d, 0x98, 0x64, 0x65, 0xed, 0x6f, 0x94, 0xb1, 0x66, 0x34, - 0xa6, 0xd7, 0x2f, 0xf2, 0x6c, 0x05, 0x97, 0x82, 0xa5, 0xfe, 0x51, 0x13, 0xfa, 0x9e, 0xb7, 0xb3, 0x8f, 0x46, 0xa3, - 0x07, 0x05, 0x1d, 0x8d, 0x46, 0x9f, 0xb2, 0x9a, 0xd0, 0x4b, 0xd1, 0xf1, 0xfe, 0x3d, 0xa7, 0xe7, 0x32, 0xdd, 0x44, - 0x41, 0x40, 0x97, 0x59, 0x9a, 0x72, 0xa1, 0xca, 0x7a, 0x9a, 0xb6, 0xf3, 0xaa, 0x16, 0x22, 0x10, 0x92, 0x6e, 0x23, - 0x42, 0x32, 0x11, 0xfa, 0x76, 0xaf, 0x67, 0xa3, 0xd1, 0xe8, 0x69, 0x6a, 0xaa, 0x75, 0x17, 0x94, 0x07, 0x68, 0x4e, - 0xe1, 0xfc, 0x14, 0xc0, 0x1a, 0xc9, 0x44, 0x7f, 0x39, 0xfc, 0xaf, 0xe1, 0x6c, 0x3e, 0x1e, 0x7e, 0x3f, 0x5a, 0x3c, - 0x3c, 0xa4, 0x41, 0xe0, 0x87, 0x6e, 0x08, 0xb5, 0x75, 0xcb, 0xb4, 0x3c, 0x1e, 0x4f, 0x49, 0x39, 0x60, 0x8f, 0xad, - 0x6f, 0xd1, 0x37, 0x8f, 0x01, 0x99, 0x15, 0x45, 0xca, 0x81, 0x93, 0x86, 0xe2, 0xd5, 0xec, 0x95, 0x00, 0xbc, 0x38, - 0x1b, 0xd9, 0xc1, 0x68, 0x45, 0xc7, 0x11, 0x94, 0x57, 0x5b, 0x53, 0x91, 0x1e, 0x63, 0x99, 0x89, 0x92, 0x3a, 0x9e, - 0x96, 0x37, 0x59, 0x95, 0x2c, 0x31, 0xd0, 0x53, 0x5c, 0xf2, 0xe0, 0x9b, 0x20, 0x2a, 0xd9, 0xd1, 0x93, 0xa9, 0x82, - 0x3b, 0xc6, 0xa4, 0x94, 0x5f, 0x42, 0xe2, 0xf7, 0x63, 0x84, 0x84, 0x25, 0xda, 0x83, 0x13, 0x6b, 0x7c, 0x91, 0xcb, - 0x18, 0x3c, 0x5a, 0x4b, 0xcd, 0xc3, 0xd9, 0x93, 0xd1, 0xda, 0xa3, 0xb4, 0x9a, 0x23, 0xa1, 0x39, 0xa1, 0x64, 0xf2, - 0xb0, 0xa4, 0xf2, 0x9b, 0x09, 0x7a, 0x49, 0x81, 0x9b, 0x79, 0x04, 0xc7, 0xbf, 0xb5, 0xf4, 0x50, 0xbd, 0x7a, 0x9b, - 0xb2, 0xc3, 0xf9, 0xff, 0x29, 0xe9, 0x62, 0x70, 0xe8, 0x86, 0xe6, 0x9d, 0x76, 0xe7, 0xad, 0x90, 0x71, 0xac, 0xc2, - 0xb7, 0x29, 0xb1, 0xc6, 0xb8, 0x9c, 0x9d, 0x6c, 0x4d, 0x77, 0x46, 0x55, 0x91, 0x5d, 0x85, 0x44, 0xf7, 0xca, 0x81, - 0x84, 0x06, 0x51, 0x36, 0xc2, 0xf5, 0x03, 0xd6, 0x33, 0x5e, 0x27, 0xaf, 0x79, 0x51, 0x65, 0x89, 0x7a, 0x7f, 0xdd, - 0x78, 0x5f, 0xd7, 0x26, 0xa0, 0xea, 0xbb, 0x82, 0xc1, 0x3c, 0xbf, 0x2d, 0x00, 0xc4, 0x14, 0x69, 0x80, 0x4f, 0x30, - 0x83, 0xa0, 0x76, 0xcd, 0xbc, 0x6a, 0x04, 0xdf, 0x80, 0xaf, 0xde, 0x15, 0x80, 0x41, 0x12, 0x82, 0x14, 0x19, 0x42, - 0x03, 0x81, 0x40, 0xc3, 0x90, 0x0b, 0x0c, 0x7e, 0xe2, 0xc5, 0x91, 0x54, 0x4e, 0x89, 0x3c, 0x0c, 0xf0, 0x47, 0x40, - 0x55, 0x00, 0x12, 0xe3, 0x71, 0x08, 0x2f, 0xd4, 0x2f, 0xf7, 0x46, 0xed, 0x11, 0xf6, 0x20, 0x0d, 0x21, 0xd8, 0x10, - 0x3e, 0x04, 0xb0, 0xa4, 0x08, 0x7d, 0x87, 0x5c, 0x46, 0x18, 0x5c, 0xe4, 0xd9, 0x4a, 0x27, 0x55, 0xa3, 0x8e, 0xe6, - 0x43, 0xa9, 0x1d, 0xc9, 0x01, 0xf5, 0xd2, 0x63, 0x4c, 0x2f, 0x54, 0xba, 0x2a, 0xca, 0x19, 0xe5, 0x9c, 0xea, 0x89, - 0x71, 0x61, 0x0b, 0x39, 0x44, 0xc2, 0x79, 0x57, 0xa8, 0x50, 0x38, 0x7c, 0x01, 0x60, 0x60, 0x20, 0xed, 0xd8, 0x8f, - 0x77, 0xa3, 0xb2, 0x9f, 0x71, 0x76, 0xf8, 0x5f, 0xf3, 0x78, 0xf8, 0x79, 0x3c, 0xfc, 0x7e, 0x31, 0x08, 0x87, 0xf6, - 0x27, 0x79, 0xf8, 0xe0, 0x90, 0xbe, 0xe0, 0x96, 0x4b, 0x83, 0x85, 0xdf, 0x08, 0xf6, 0xa3, 0x56, 0x42, 0x10, 0x05, - 0x78, 0xc3, 0x72, 0xab, 0x71, 0x02, 0x80, 0x87, 0xc1, 0xff, 0x0e, 0xd0, 0x68, 0xca, 0x5d, 0xbc, 0x40, 0x5f, 0xa2, - 0x7e, 0x9f, 0x3c, 0x6a, 0x18, 0x0c, 0x82, 0xb8, 0x46, 0xc5, 0x84, 0x21, 0xba, 0x8c, 0x89, 0x82, 0x41, 0xb6, 0xd9, - 0x77, 0xbb, 0x5e, 0x5b, 0x12, 0x86, 0x5f, 0xfa, 0x99, 0x26, 0x66, 0xde, 0xe1, 0xc6, 0xb6, 0x92, 0xab, 0x10, 0xb1, - 0x02, 0xf5, 0xaf, 0x9c, 0x41, 0xec, 0xcd, 0xeb, 0x0c, 0x7c, 0x3a, 0xec, 0x17, 0xe3, 0x19, 0xb0, 0x51, 0x70, 0xe7, - 0x2b, 0xf8, 0x45, 0x06, 0x6e, 0xde, 0x22, 0x46, 0x81, 0x83, 0x5d, 0x12, 0xfd, 0x7e, 0x2f, 0xcf, 0xc2, 0x5c, 0xe3, - 0x4e, 0xe7, 0xb5, 0x51, 0x43, 0xa0, 0x8e, 0x1c, 0xd4, 0x0f, 0x7a, 0x08, 0x86, 0x6a, 0x08, 0x8a, 0x8e, 0xb6, 0xb8, - 0x7a, 0x6d, 0x3d, 0x85, 0xe9, 0xad, 0xaa, 0xaf, 0x18, 0xfd, 0x29, 0x33, 0x81, 0x85, 0xb4, 0x6b, 0x8e, 0x75, 0xcd, - 0x31, 0xd2, 0x9e, 0x7e, 0x5f, 0x34, 0xc8, 0x4f, 0x67, 0xe1, 0x41, 0xa0, 0x4a, 0x95, 0x7b, 0x65, 0x51, 0x6e, 0x4b, - 0xf3, 0xc6, 0xb0, 0xa6, 0x79, 0x66, 0xe3, 0xdc, 0xcc, 0x7a, 0xbd, 0x30, 0x44, 0x07, 0x4f, 0x2c, 0x15, 0x6b, 0x83, - 0x70, 0x47, 0x26, 0x61, 0x74, 0x05, 0xb2, 0xcb, 0xf0, 0x8c, 0x13, 0xe4, 0x53, 0x81, 0x7d, 0x50, 0xd5, 0x7a, 0x39, - 0xe1, 0xb1, 0x91, 0x2f, 0x1b, 0x41, 0x83, 0xbc, 0xa4, 0xa8, 0x37, 0x71, 0x3b, 0xf6, 0x79, 0x0b, 0xb9, 0x72, 0x5b, - 0x4f, 0x7b, 0x9a, 0x54, 0xf4, 0x58, 0xaf, 0x52, 0xbf, 0xc0, 0xd2, 0xc2, 0x92, 0x0f, 0x42, 0x7b, 0x9a, 0x56, 0x60, - 0x86, 0x6b, 0x9b, 0xc1, 0xd0, 0x0f, 0xc7, 0x4f, 0x40, 0x67, 0xd4, 0xb6, 0x84, 0x30, 0x76, 0x83, 0xb0, 0xf2, 0x9e, - 0xc8, 0x37, 0x8f, 0xbd, 0x8b, 0x41, 0xc8, 0xcd, 0x66, 0x16, 0x0d, 0x4c, 0xf7, 0x73, 0xd9, 0x6c, 0x9e, 0x6e, 0xae, - 0x17, 0x25, 0x54, 0xc0, 0x76, 0xbb, 0x14, 0x04, 0xff, 0x7e, 0xca, 0x66, 0xf8, 0x37, 0xeb, 0xf7, 0x7b, 0x21, 0xfe, - 0xe2, 0x18, 0xcc, 0x68, 0x2e, 0x16, 0xec, 0x13, 0xc8, 0x98, 0x48, 0x84, 0xa9, 0xca, 0x18, 0x90, 0x55, 0x60, 0x11, - 0x68, 0x3e, 0x50, 0xb9, 0x30, 0x93, 0xbd, 0xcc, 0xb9, 0x86, 0xbc, 0x6a, 0x8d, 0x53, 0x36, 0xca, 0x12, 0xe5, 0xca, - 0x91, 0x8d, 0xe2, 0x3c, 0x8b, 0x4b, 0x5e, 0xee, 0x76, 0xfa, 0x70, 0x4c, 0x0a, 0x0e, 0xec, 0xba, 0xa2, 0x52, 0x25, - 0xeb, 0x48, 0xf5, 0xc0, 0x4b, 0xc3, 0x02, 0xf7, 0x29, 0x9f, 0x17, 0x86, 0x46, 0x1c, 0x80, 0x30, 0x83, 0xa9, 0x5b, - 0x7a, 0x2f, 0x2c, 0xa0, 0x79, 0x25, 0x21, 0x5b, 0x4c, 0xf5, 0x2c, 0x7c, 0x63, 0x26, 0xe6, 0xc5, 0x02, 0xc2, 0xea, - 0x14, 0x0b, 0xcd, 0x6c, 0xd2, 0x84, 0xc5, 0x00, 0x9b, 0x17, 0x93, 0x29, 0xc4, 0x77, 0x57, 0xe5, 0xc4, 0x0b, 0x73, - 0xdf, 0x4e, 0x1c, 0x72, 0x08, 0xbc, 0xaa, 0x0d, 0xba, 0x9a, 0x6d, 0x38, 0xea, 0x48, 0x39, 0x31, 0xf9, 0xfd, 0x54, - 0x41, 0x88, 0x3b, 0x71, 0x24, 0x5c, 0xde, 0x6c, 0x17, 0x9e, 0x75, 0x20, 0xe8, 0xa8, 0xc1, 0x29, 0xbf, 0x30, 0x38, - 0x1a, 0x93, 0x74, 0xeb, 0x9d, 0x20, 0x45, 0x18, 0x93, 0xad, 0x64, 0xe7, 0x32, 0x14, 0xf3, 0x78, 0x01, 0xca, 0xcb, - 0x78, 0x01, 0x96, 0x46, 0xc6, 0x20, 0x15, 0xe4, 0x77, 0xdc, 0x0b, 0x85, 0x45, 0x71, 0x85, 0x48, 0xcf, 0xea, 0xf7, - 0xb4, 0x68, 0x87, 0x02, 0x41, 0x71, 0x87, 0x32, 0x4f, 0xce, 0x7a, 0x2c, 0x90, 0xd8, 0x10, 0x30, 0xbe, 0xd2, 0x69, - 0xaa, 0xb5, 0xee, 0x8d, 0x99, 0x07, 0x3e, 0xcd, 0x46, 0x42, 0x56, 0x67, 0x17, 0x20, 0x52, 0xf2, 0xd1, 0xf1, 0x91, - 0x5f, 0xc4, 0x9d, 0x65, 0xde, 0xda, 0x16, 0x95, 0xec, 0x64, 0x0b, 0xa0, 0x85, 0x3a, 0x7a, 0x96, 0x92, 0xdb, 0x94, - 0xa4, 0x76, 0x9b, 0x02, 0x56, 0x92, 0xbf, 0x80, 0x21, 0xf8, 0xda, 0x81, 0x70, 0x3a, 0x56, 0x88, 0xd7, 0x34, 0x45, - 0xa4, 0xc9, 0xb0, 0xa4, 0x38, 0xb6, 0x25, 0xa2, 0xa0, 0xda, 0xb2, 0xec, 0x60, 0x98, 0x28, 0xc1, 0x1f, 0x53, 0x8f, - 0x12, 0x05, 0x01, 0xd5, 0x43, 0x0e, 0x12, 0x6c, 0xdb, 0x40, 0x78, 0x40, 0x1e, 0xd1, 0x1b, 0xeb, 0x9f, 0xb3, 0xce, - 0xb3, 0x0b, 0xcd, 0x73, 0xb9, 0xde, 0x15, 0x66, 0x8c, 0xf0, 0x24, 0x33, 0x61, 0x03, 0xbc, 0xf3, 0xcc, 0xa8, 0x6d, - 0x7a, 0x1e, 0x5e, 0xdb, 0x73, 0x8c, 0xd0, 0x77, 0xc7, 0xa0, 0x9b, 0x60, 0x5e, 0x1d, 0x36, 0xeb, 0x95, 0x82, 0xd4, - 0x30, 0xb5, 0x68, 0x62, 0xd6, 0xb3, 0x06, 0xe5, 0xbb, 0x5d, 0x4f, 0xcf, 0xd5, 0xdd, 0x73, 0xb7, 0xdb, 0xf5, 0xb0, - 0x5b, 0x1f, 0xd3, 0x6e, 0xab, 0xf8, 0x4a, 0x7d, 0xd0, 0x1e, 0x7f, 0xee, 0xc6, 0x9f, 0x1b, 0x64, 0x93, 0xd2, 0xd1, - 0x4c, 0x5b, 0x1f, 0x84, 0x07, 0x4e, 0x37, 0x8d, 0x26, 0xfd, 0x9c, 0x85, 0x92, 0x5e, 0x8a, 0x46, 0x75, 0xb5, 0x33, - 0x31, 0xbd, 0x77, 0xfd, 0xdf, 0xbf, 0x0a, 0xf0, 0x88, 0x53, 0x3b, 0xfb, 0xce, 0x06, 0x15, 0x8d, 0xb6, 0x70, 0xa4, - 0x08, 0x3d, 0x20, 0x09, 0x77, 0xb5, 0xac, 0xc5, 0x6d, 0x7e, 0xc8, 0xee, 0xa7, 0x4f, 0x3f, 0xa5, 0xbe, 0x17, 0x82, - 0x5b, 0x66, 0x99, 0x39, 0xf0, 0x2a, 0x8a, 0x03, 0x1a, 0x75, 0xd1, 0xbe, 0xab, 0xac, 0x2c, 0xc1, 0xeb, 0x05, 0xee, - 0x95, 0x1f, 0xb8, 0x0f, 0xbf, 0x77, 0x59, 0x35, 0x37, 0xe9, 0x87, 0x6c, 0x9e, 0x2d, 0x76, 0xbb, 0x10, 0xff, 0x76, - 0xb5, 0xc8, 0xd1, 0xe4, 0x39, 0xe8, 0x34, 0x31, 0x92, 0x11, 0xd3, 0x8d, 0xf3, 0x36, 0xff, 0x67, 0xd1, 0x70, 0x9a, - 0x78, 0x0e, 0xf4, 0x62, 0x76, 0x0a, 0x32, 0x29, 0x03, 0x72, 0x20, 0x66, 0x7a, 0xcd, 0x40, 0x34, 0x32, 0x11, 0x01, - 0xae, 0x30, 0x36, 0x12, 0x8d, 0x4e, 0x38, 0xa9, 0x09, 0x58, 0xb0, 0xda, 0xf2, 0xde, 0x5b, 0xda, 0x56, 0x15, 0x1b, - 0x6f, 0x49, 0x73, 0x5c, 0x07, 0xce, 0xd7, 0xc1, 0x06, 0xbc, 0xd3, 0x65, 0x57, 0x0b, 0xe4, 0x7e, 0x79, 0x4d, 0x7b, - 0xe3, 0x3a, 0x81, 0x59, 0xdb, 0xd6, 0x96, 0xf1, 0xb3, 0xa5, 0xbf, 0xd0, 0x83, 0xab, 0x8c, 0xc1, 0xe6, 0xc6, 0x4a, - 0xc3, 0xee, 0x1b, 0xcf, 0x97, 0x02, 0xc2, 0xd3, 0xf9, 0xf4, 0xf8, 0x43, 0xe6, 0xd1, 0x63, 0x20, 0x3a, 0xe6, 0xa3, - 0xd2, 0x7d, 0x64, 0x77, 0xaf, 0x1f, 0x10, 0x70, 0x5e, 0xb5, 0x0b, 0x9a, 0x97, 0x0b, 0x08, 0xac, 0xea, 0x95, 0x57, - 0x58, 0x3e, 0x33, 0x66, 0x97, 0x40, 0x86, 0x0a, 0x02, 0x81, 0xbb, 0xbb, 0xce, 0x85, 0x58, 0x75, 0x58, 0x99, 0xd3, - 0x24, 0xec, 0x24, 0x44, 0xf3, 0xd6, 0x60, 0x16, 0xfc, 0xef, 0x60, 0x50, 0x0e, 0x82, 0x28, 0x88, 0x82, 0x80, 0x0c, - 0x0a, 0xf8, 0x85, 0xb8, 0x6b, 0x04, 0x63, 0xb6, 0x40, 0x87, 0xdf, 0x72, 0xe6, 0x33, 0x22, 0xaf, 0xfc, 0xb0, 0x9e, - 0xde, 0x00, 0x9c, 0x4b, 0x99, 0xf3, 0x18, 0x7d, 0x4e, 0xde, 0x72, 0x96, 0x11, 0xfa, 0xd6, 0x3b, 0x95, 0xdf, 0xf1, - 0x46, 0xb0, 0xbf, 0xfd, 0x61, 0x7b, 0x01, 0xf2, 0x8a, 0xde, 0x98, 0xbe, 0xe5, 0x24, 0xca, 0x1a, 0xce, 0xd4, 0x1c, - 0x7a, 0x56, 0x59, 0xd6, 0x8a, 0x1a, 0x72, 0x83, 0x62, 0x6e, 0x64, 0x99, 0x9c, 0x4c, 0x5b, 0xcd, 0xa9, 0xc0, 0x75, - 0x67, 0xd7, 0x0b, 0x48, 0x0e, 0x85, 0x66, 0xe9, 0x6c, 0x38, 0x6f, 0x77, 0x28, 0xb6, 0x4e, 0x21, 0xaf, 0x21, 0x2a, - 0x1a, 0xa4, 0x23, 0xa0, 0x86, 0x56, 0x5c, 0x56, 0xe0, 0xc2, 0x6c, 0xda, 0xc3, 0x4d, 0x7b, 0x4c, 0x33, 0xde, 0x43, - 0xcc, 0x3c, 0x8e, 0x2d, 0x03, 0x3b, 0x12, 0x87, 0xf4, 0xe4, 0x7c, 0x81, 0xf6, 0xe9, 0xad, 0xab, 0xc5, 0x23, 0xac, - 0x3d, 0x6f, 0x85, 0x84, 0x00, 0xf1, 0x69, 0x2a, 0xdd, 0xed, 0x82, 0x00, 0x06, 0xb8, 0xdf, 0xef, 0x01, 0xd7, 0x6a, - 0xd8, 0x49, 0x73, 0x6b, 0xb6, 0xc4, 0x5e, 0x51, 0x78, 0x0c, 0xcc, 0xa9, 0xf9, 0xcf, 0x20, 0xa0, 0x78, 0xee, 0x86, - 0x60, 0x6f, 0xca, 0x4e, 0xb6, 0x45, 0xbf, 0xff, 0xac, 0xc0, 0x07, 0x94, 0x0b, 0x83, 0x98, 0x5b, 0xc7, 0xf1, 0x30, - 0xec, 0x93, 0xfa, 0x10, 0xc7, 0x22, 0xcf, 0x42, 0x47, 0x58, 0x2a, 0x43, 0x58, 0xb8, 0x62, 0xa4, 0x83, 0x38, 0xa8, - 0x49, 0xe7, 0x60, 0x55, 0x2e, 0xf8, 0x72, 0xaf, 0xf7, 0x19, 0x60, 0xd2, 0x33, 0x6f, 0x58, 0xde, 0x78, 0x80, 0x68, - 0xbd, 0x1e, 0x2e, 0x14, 0x8f, 0x4c, 0x34, 0xd0, 0x38, 0xf1, 0xa5, 0x65, 0xd7, 0x67, 0x5a, 0x56, 0x32, 0x1a, 0x8d, - 0xaa, 0x5a, 0x49, 0x3e, 0xec, 0x77, 0x7f, 0xb6, 0x50, 0x3c, 0x65, 0x9c, 0xf2, 0x14, 0x2c, 0xdf, 0x0d, 0xa5, 0x9b, - 0x2f, 0xe8, 0x8a, 0x8b, 0x54, 0xfd, 0xf4, 0xd0, 0x37, 0x1b, 0xc4, 0x35, 0x6b, 0xea, 0x70, 0xec, 0xf0, 0x43, 0x00, - 0x4c, 0xfb, 0x30, 0x73, 0xe9, 0x1a, 0xa6, 0x17, 0xc4, 0xb3, 0x71, 0xc1, 0x43, 0x97, 0x07, 0xb0, 0x0f, 0xcd, 0x21, - 0x89, 0x9f, 0xc2, 0xcf, 0x99, 0x49, 0xeb, 0xf8, 0x0c, 0x67, 0x33, 0x2a, 0xd5, 0x8d, 0xa0, 0xfd, 0x1a, 0x12, 0x89, - 0x41, 0x7a, 0x6e, 0x30, 0x14, 0xad, 0xbb, 0x0d, 0x5c, 0xf9, 0x2d, 0xbd, 0xf3, 0x69, 0x10, 0x60, 0x7d, 0x63, 0x31, - 0x00, 0xa0, 0x8a, 0x3f, 0x50, 0x75, 0x65, 0xae, 0x28, 0xa6, 0x61, 0x2a, 0xd1, 0xde, 0x71, 0x5c, 0x47, 0x8d, 0xeb, - 0xb0, 0x60, 0xa5, 0xb5, 0x6d, 0x76, 0x6f, 0x69, 0x61, 0x4b, 0x40, 0xb5, 0x20, 0xee, 0x04, 0xf0, 0xa1, 0x91, 0xea, - 0x40, 0x90, 0xdd, 0x07, 0x07, 0x00, 0xbc, 0xe1, 0x79, 0x18, 0xc2, 0x1f, 0x58, 0x38, 0xb0, 0x2c, 0x55, 0x3f, 0x97, - 0xd3, 0x18, 0xce, 0xdd, 0x5c, 0xed, 0xf0, 0xd9, 0x12, 0x14, 0x9b, 0x6a, 0x4e, 0xcd, 0xe5, 0x2b, 0x6f, 0xec, 0xf7, - 0x98, 0x60, 0x1e, 0x33, 0xdb, 0xf0, 0x5b, 0x4f, 0xb7, 0xf5, 0x0d, 0x76, 0x03, 0x27, 0xed, 0x85, 0xd3, 0x5e, 0x6c, - 0x97, 0x06, 0xf2, 0xaf, 0x6e, 0x08, 0x11, 0x3e, 0x6a, 0x62, 0x91, 0x35, 0x64, 0x3a, 0x16, 0x2b, 0x44, 0xb5, 0xa9, - 0x78, 0xaa, 0x0d, 0x04, 0xca, 0xa9, 0xba, 0x30, 0xb5, 0x52, 0x99, 0x30, 0x88, 0x3b, 0x25, 0x2c, 0xaa, 0x0c, 0x30, - 0x0c, 0x2a, 0xa4, 0xb8, 0xb6, 0x9e, 0x1f, 0x70, 0xf9, 0x66, 0xa6, 0xcd, 0xf6, 0xd3, 0x17, 0x79, 0x7c, 0xb9, 0xdb, - 0x85, 0xdd, 0x2f, 0xc0, 0x1c, 0xb5, 0x54, 0x1a, 0x46, 0x70, 0x02, 0x51, 0x92, 0xeb, 0x3b, 0x72, 0x4e, 0x1c, 0x27, - 0xd7, 0x6e, 0xde, 0x6c, 0x2f, 0xc5, 0x08, 0x2c, 0xe0, 0xc4, 0x45, 0x3a, 0xd0, 0x52, 0x49, 0x6a, 0x4f, 0x01, 0x6f, - 0xd3, 0x3b, 0x4a, 0x85, 0x57, 0x0b, 0x4d, 0x42, 0x2a, 0x77, 0x2f, 0xb1, 0xa3, 0x06, 0x9c, 0x93, 0xba, 0x83, 0x80, - 0xd3, 0x9e, 0x6e, 0xac, 0x55, 0x24, 0x9b, 0x04, 0xef, 0x95, 0x1e, 0xba, 0x44, 0x3b, 0xb5, 0xbb, 0x6d, 0x55, 0xb6, - 0x50, 0x30, 0x0f, 0x72, 0x96, 0xa8, 0xe3, 0x01, 0x85, 0x2e, 0xea, 0x68, 0xc8, 0x17, 0xa4, 0xd0, 0x2b, 0x47, 0xab, - 0x9a, 0xf7, 0x25, 0x03, 0xa5, 0x5a, 0x05, 0x79, 0x4d, 0xac, 0xfb, 0x5a, 0xd6, 0x58, 0x5c, 0x39, 0x21, 0x85, 0x4d, - 0xf8, 0xda, 0x52, 0x2c, 0xcc, 0x62, 0x6f, 0x4c, 0x7d, 0xe1, 0x12, 0xa1, 0xed, 0x6e, 0x43, 0x8c, 0x36, 0x58, 0x37, - 0xbb, 0xdd, 0xc7, 0x22, 0x9c, 0x67, 0x0b, 0x2a, 0x47, 0x59, 0x8a, 0x90, 0x6a, 0xc6, 0x63, 0xd9, 0x76, 0xc1, 0x4c, - 0x0c, 0x75, 0xed, 0xf1, 0x92, 0x4c, 0xb1, 0x36, 0x49, 0x8e, 0xe2, 0x73, 0x59, 0xa8, 0xb5, 0x46, 0x08, 0x1e, 0xee, - 0xbf, 0xa6, 0x10, 0xd3, 0xce, 0xac, 0xbb, 0x97, 0x7b, 0x37, 0xc4, 0x5f, 0x21, 0xb0, 0x42, 0xc9, 0x3e, 0x16, 0xa3, - 0xf3, 0x0c, 0x82, 0xc1, 0x82, 0xac, 0x19, 0xa3, 0x04, 0xab, 0x75, 0xd0, 0x6c, 0xb9, 0xbd, 0x17, 0x5b, 0xa2, 0x00, - 0x71, 0x9e, 0x85, 0x66, 0x3c, 0x2b, 0x67, 0x39, 0x93, 0x51, 0x6c, 0x48, 0x54, 0x7a, 0x51, 0xe2, 0x7d, 0x9e, 0xc6, - 0xf4, 0xd0, 0xad, 0x41, 0x70, 0x5d, 0xdd, 0xdb, 0x48, 0xf3, 0x05, 0x21, 0x6a, 0x02, 0x24, 0x6c, 0x54, 0x73, 0x6a, - 0x5d, 0x89, 0xfb, 0x59, 0xe5, 0x8d, 0x3e, 0x88, 0xaf, 0x04, 0xf0, 0xb0, 0xde, 0xf6, 0x3e, 0x17, 0x1e, 0x6b, 0x83, - 0x6f, 0x77, 0xbb, 0x2b, 0x31, 0x0f, 0x02, 0x8f, 0xd1, 0xfc, 0x45, 0x49, 0xcc, 0x7b, 0x63, 0x0a, 0x2b, 0xde, 0x77, - 0xf1, 0xeb, 0x26, 0xb5, 0xd6, 0x22, 0x77, 0x8f, 0xeb, 0x03, 0x9e, 0xa7, 0xc4, 0xd1, 0x8e, 0xca, 0xa9, 0xb4, 0xb6, - 0x03, 0xd8, 0x15, 0x81, 0x81, 0xb2, 0x7f, 0x4b, 0xd9, 0x16, 0xcc, 0x13, 0xc1, 0xfa, 0x08, 0xfd, 0xb6, 0x94, 0xfe, - 0x64, 0x8c, 0xc6, 0x3d, 0x72, 0x5d, 0x45, 0x47, 0x5c, 0x47, 0xb3, 0xe7, 0xd1, 0xdf, 0x9e, 0x8c, 0x69, 0x11, 0x8b, - 0x54, 0x5e, 0x81, 0x0a, 0x02, 0x94, 0x21, 0xe8, 0x08, 0xa1, 0xa9, 0x01, 0x68, 0x10, 0xdc, 0x00, 0xfc, 0xbb, 0xd3, - 0x89, 0xd2, 0xd6, 0xe4, 0x63, 0xb4, 0xaa, 0x22, 0x67, 0x6d, 0x68, 0x37, 0x95, 0x1c, 0x92, 0x87, 0x25, 0xe0, 0x5b, - 0x62, 0xb3, 0x94, 0x0d, 0x8a, 0xda, 0x6c, 0xea, 0xb5, 0x62, 0x47, 0x6e, 0x1b, 0x45, 0x9b, 0xb5, 0xa8, 0xed, 0x46, - 0xe6, 0x8b, 0xe9, 0xad, 0x15, 0x06, 0x4e, 0x4d, 0x6b, 0x6e, 0xf6, 0xa0, 0xe4, 0x6c, 0x7d, 0x26, 0x37, 0x01, 0xe2, - 0x00, 0xc3, 0x75, 0x3b, 0xbf, 0x59, 0x10, 0x7a, 0xcb, 0x6e, 0xad, 0x58, 0xf5, 0xc6, 0xca, 0x45, 0x4c, 0xda, 0xcd, - 0x60, 0x02, 0x97, 0x71, 0x56, 0xd8, 0x17, 0x5a, 0xdd, 0x50, 0x74, 0xb4, 0x4d, 0xda, 0xcf, 0x3b, 0xda, 0x0d, 0x17, - 0x7c, 0x2b, 0xd6, 0x71, 0x6e, 0x59, 0x53, 0x85, 0xa6, 0x1d, 0xe8, 0xed, 0x10, 0xd0, 0x9c, 0x8d, 0xe9, 0x92, 0xa6, - 0x78, 0x81, 0xa6, 0x6b, 0x30, 0xd3, 0xb9, 0x80, 0xbe, 0x76, 0xfb, 0x68, 0x5f, 0xa8, 0x9e, 0x08, 0x6f, 0x89, 0x82, - 0x6f, 0x4b, 0x0a, 0x5e, 0x6a, 0x39, 0x8f, 0xcd, 0x1c, 0x02, 0x3e, 0x8d, 0x2a, 0xd1, 0x3b, 0x29, 0x2e, 0x41, 0x9b, - 0x09, 0x47, 0xa0, 0xa9, 0x1a, 0xb1, 0x95, 0x03, 0xdc, 0x5e, 0x3c, 0x0d, 0x08, 0x05, 0xa9, 0xee, 0xda, 0xae, 0xc8, - 0x5b, 0x76, 0xb2, 0xbd, 0x05, 0x33, 0xe1, 0x6a, 0x5d, 0xb6, 0xbe, 0xb2, 0xc9, 0xee, 0xe3, 0x9a, 0x60, 0xdb, 0x3d, - 0xd4, 0xd8, 0xf0, 0x96, 0xde, 0x90, 0xed, 0x4d, 0xbf, 0x1f, 0x42, 0x7f, 0x08, 0xd5, 0x1d, 0xba, 0xed, 0xec, 0xd0, - 0xad, 0xd7, 0xce, 0x73, 0xab, 0xe7, 0x53, 0xde, 0x21, 0x1f, 0xd1, 0x64, 0x8d, 0xae, 0xe2, 0x0d, 0x6c, 0xea, 0xa8, - 0xa2, 0xaa, 0xf2, 0x28, 0xa1, 0xa0, 0x12, 0xcf, 0x78, 0xf9, 0x81, 0x63, 0xac, 0x57, 0xfd, 0xf4, 0x4e, 0xf3, 0x6a, - 0x6b, 0xb3, 0x36, 0xcb, 0xf5, 0x39, 0x58, 0x48, 0x9c, 0xf3, 0xe8, 0x4a, 0xd3, 0x92, 0x4b, 0x1f, 0x54, 0x15, 0x47, - 0x25, 0xb8, 0x88, 0xb3, 0x1c, 0xd4, 0xb8, 0x17, 0xcd, 0xfe, 0x87, 0xda, 0x76, 0x6c, 0xd9, 0x38, 0x73, 0xaf, 0x43, - 0xb2, 0xfd, 0x1f, 0x1b, 0xa8, 0xa7, 0x21, 0x46, 0x88, 0x35, 0x0b, 0xfa, 0x01, 0x83, 0x58, 0xa1, 0x41, 0xb9, 0x4e, - 0x12, 0x5e, 0x96, 0x81, 0x51, 0x6a, 0xad, 0xd9, 0xda, 0x9c, 0x67, 0xef, 0xd8, 0xc9, 0xbb, 0x1e, 0x63, 0xb7, 0x84, - 0x26, 0x5a, 0x27, 0x64, 0x6a, 0x8c, 0x3c, 0x2d, 0x90, 0xee, 0x50, 0x94, 0x5d, 0x84, 0x0f, 0x50, 0xc8, 0xd2, 0xde, - 0xe7, 0xe6, 0x44, 0x56, 0xdf, 0x68, 0x23, 0x94, 0x48, 0x25, 0x82, 0x6c, 0xfc, 0x06, 0x01, 0x8c, 0xa1, 0xd9, 0x01, - 0xd9, 0x2e, 0xd9, 0x6b, 0x7a, 0x66, 0x4d, 0x82, 0xe0, 0xf5, 0x03, 0x95, 0x68, 0x46, 0x59, 0x11, 0x5d, 0x65, 0xf4, - 0xb3, 0x09, 0x49, 0x74, 0x16, 0x12, 0x3f, 0x37, 0x2c, 0xad, 0xeb, 0x10, 0xc5, 0xcc, 0x66, 0xc3, 0x6b, 0x45, 0x54, - 0x63, 0x5b, 0x19, 0x1f, 0xf3, 0x5b, 0x9b, 0x46, 0xa6, 0xd0, 0xd7, 0xe1, 0xa4, 0xdf, 0x87, 0xbf, 0x9a, 0x7e, 0xe0, - 0x2d, 0x05, 0x7f, 0xb1, 0x77, 0xa4, 0x4e, 0x58, 0x00, 0xf0, 0x8c, 0x39, 0xaf, 0x9a, 0x13, 0xf8, 0x8e, 0x9d, 0x6c, - 0xdf, 0x85, 0xaf, 0x1b, 0x33, 0xb7, 0x09, 0xf1, 0x52, 0x95, 0xf4, 0xbc, 0x79, 0x32, 0x03, 0xb1, 0xb2, 0x5a, 0xf3, - 0x5b, 0x66, 0xf5, 0x09, 0x40, 0xa4, 0x6e, 0xad, 0x83, 0x2d, 0x7e, 0x6c, 0xba, 0x4c, 0xb6, 0x29, 0x6b, 0x33, 0x51, - 0x4a, 0x45, 0xd2, 0x5c, 0x04, 0xd0, 0x6f, 0x18, 0x8e, 0x1a, 0xe0, 0xce, 0xf5, 0xd8, 0x9b, 0xa1, 0xf1, 0xc6, 0xd4, - 0xd0, 0xb3, 0xad, 0x5e, 0xde, 0x8e, 0x42, 0x98, 0xb1, 0x88, 0x6e, 0xdd, 0xb1, 0x18, 0xbe, 0xa6, 0x0f, 0xa0, 0xc2, - 0xa7, 0x21, 0x46, 0x17, 0x26, 0x75, 0x3d, 0x5d, 0xab, 0xad, 0x74, 0x43, 0x68, 0x8e, 0x51, 0x8d, 0xbc, 0xb6, 0x6d, - 0xa8, 0x11, 0xda, 0x13, 0xca, 0xc3, 0x5b, 0x5a, 0xd1, 0x1b, 0xcb, 0x22, 0x38, 0xf9, 0xb1, 0x97, 0x9f, 0xd0, 0x73, - 0x37, 0x68, 0x3f, 0x15, 0x6d, 0x0d, 0xe0, 0x6f, 0xa8, 0x1f, 0xce, 0xea, 0xa9, 0x95, 0x72, 0x78, 0x0a, 0x5f, 0xb2, - 0x05, 0xb9, 0x82, 0x5e, 0xac, 0x31, 0x3b, 0x89, 0x41, 0x07, 0xb5, 0xb7, 0x3b, 0xbc, 0x49, 0x29, 0x43, 0xb4, 0x46, - 0x74, 0x90, 0x57, 0xff, 0x06, 0x4d, 0x1f, 0xa4, 0x85, 0x29, 0x5d, 0xa3, 0x80, 0x07, 0xf4, 0x4d, 0xfd, 0x7e, 0x8e, - 0xcf, 0xb5, 0x67, 0x99, 0xa6, 0x2c, 0x90, 0x09, 0x5d, 0xba, 0xd2, 0x40, 0x54, 0xbe, 0x75, 0xac, 0x02, 0xb0, 0x22, - 0x09, 0x34, 0x22, 0x01, 0xcb, 0x25, 0x4f, 0x5c, 0xb6, 0x45, 0x83, 0x9a, 0xa8, 0xa4, 0x90, 0x25, 0x92, 0xc0, 0x0f, - 0x23, 0x28, 0x53, 0x14, 0x83, 0xb8, 0x57, 0x2f, 0xaf, 0xb8, 0xa6, 0x06, 0xac, 0x29, 0x82, 0x09, 0xd6, 0xe9, 0x14, - 0x88, 0xad, 0x58, 0xaf, 0xc0, 0x13, 0xd5, 0x5d, 0x24, 0x91, 0x25, 0x40, 0x03, 0x3d, 0x5f, 0x3a, 0xed, 0x96, 0xb7, - 0x27, 0x5a, 0xaa, 0xd8, 0xdc, 0x7b, 0xb1, 0xb0, 0xdc, 0x63, 0xe5, 0x6f, 0x07, 0xda, 0x0b, 0xab, 0x3d, 0x11, 0x35, - 0x58, 0x1d, 0xb6, 0xed, 0xfc, 0x50, 0x1a, 0xaa, 0x7b, 0xe5, 0x98, 0x80, 0x8a, 0xae, 0xe2, 0x6a, 0x19, 0x65, 0x23, - 0xf8, 0xb3, 0xdb, 0x05, 0x87, 0x01, 0x58, 0x84, 0xfe, 0xf2, 0xfe, 0xa7, 0x08, 0xc3, 0x55, 0xfd, 0xf2, 0xfe, 0xa7, - 0xdd, 0xee, 0xc9, 0x78, 0x6c, 0xb8, 0x02, 0xa7, 0xd6, 0x01, 0xfe, 0xc0, 0xb0, 0x0d, 0x76, 0xc9, 0xee, 0x76, 0x4f, - 0x80, 0x83, 0x50, 0x6c, 0x83, 0xd9, 0xc5, 0xca, 0xb1, 0x4d, 0xb1, 0x1a, 0x7a, 0x47, 0x02, 0x76, 0xdf, 0x1e, 0x4b, - 0xb1, 0x4f, 0x7d, 0x54, 0x48, 0x4a, 0xbd, 0xe8, 0x9f, 0x77, 0x0a, 0x2c, 0x29, 0x98, 0xf2, 0x06, 0xcb, 0xaa, 0x5a, - 0x95, 0xd1, 0xe1, 0x61, 0xbc, 0xca, 0x46, 0x65, 0x06, 0xdb, 0xbc, 0xbc, 0xbe, 0x04, 0x80, 0x89, 0x80, 0x36, 0xde, - 0xad, 0x45, 0x66, 0x5e, 0x2c, 0xe8, 0x32, 0xc3, 0x35, 0x09, 0x66, 0x07, 0x39, 0xb7, 0xba, 0xc9, 0x29, 0xb1, 0x0f, - 0x60, 0x83, 0xb9, 0xdb, 0x35, 0xf8, 0x85, 0x93, 0xd1, 0x93, 0xd9, 0x32, 0xd3, 0x06, 0xae, 0xdc, 0xec, 0x7f, 0x12, - 0x79, 0x69, 0xa8, 0xf8, 0x24, 0xd3, 0xe7, 0x19, 0xf0, 0x79, 0xec, 0x4f, 0x11, 0xfa, 0x2c, 0x57, 0xa3, 0x35, 0xc0, - 0xc6, 0x66, 0x17, 0x9b, 0x51, 0xca, 0x21, 0x42, 0x47, 0x60, 0xd5, 0x35, 0xcb, 0x8c, 0xf8, 0x36, 0x15, 0xb7, 0x2d, - 0x55, 0xd8, 0x9f, 0xc2, 0x73, 0xde, 0xe1, 0xc6, 0x71, 0xa8, 0x37, 0x89, 0xc2, 0xe7, 0x28, 0x44, 0xe5, 0x68, 0x5c, - 0xe8, 0xe4, 0x6b, 0x99, 0xc7, 0x84, 0x62, 0x0e, 0xf7, 0xee, 0xaf, 0xd4, 0x99, 0xcb, 0xf8, 0xc2, 0xbd, 0xe7, 0xbe, - 0xcc, 0xe4, 0x5a, 0x02, 0x48, 0x94, 0xaa, 0xfd, 0xf7, 0x2f, 0x48, 0x8d, 0xff, 0x95, 0x6a, 0x0d, 0x40, 0xef, 0x77, - 0xa8, 0xc9, 0x11, 0x04, 0x6c, 0xc5, 0xd4, 0x8f, 0x2e, 0x60, 0x25, 0xf3, 0x3f, 0xa1, 0x6e, 0x47, 0xb0, 0xad, 0x8a, - 0x27, 0x14, 0x55, 0xb4, 0xe0, 0xe9, 0x5a, 0xa4, 0xb1, 0x48, 0x36, 0x11, 0xaf, 0xa7, 0x58, 0x12, 0xb3, 0x11, 0xc3, - 0x7e, 0x6f, 0x76, 0xe1, 0x7d, 0xd1, 0x30, 0x89, 0xa7, 0xa5, 0xbf, 0xad, 0xbc, 0xcd, 0x64, 0x19, 0x67, 0x64, 0xca, - 0x15, 0x82, 0xb9, 0xd5, 0xf7, 0x98, 0x13, 0xfc, 0xf1, 0xd1, 0x63, 0x42, 0xaf, 0xe5, 0xb4, 0x44, 0x90, 0x3e, 0x91, - 0x5a, 0xd7, 0x55, 0xec, 0xd7, 0x14, 0xa2, 0x5a, 0x08, 0x06, 0xa1, 0x4c, 0x4d, 0xfb, 0x14, 0xdf, 0x67, 0xcb, 0xfe, - 0xd3, 0x94, 0x2d, 0xc9, 0x56, 0x40, 0xc7, 0xa4, 0xf3, 0x7e, 0xf5, 0xf6, 0xec, 0xcc, 0xfb, 0x0d, 0x9a, 0x70, 0x50, - 0xdd, 0x40, 0xbb, 0x0a, 0x32, 0x8d, 0x51, 0x6c, 0x16, 0x63, 0xed, 0xd6, 0x44, 0x04, 0x41, 0xb8, 0xcb, 0x59, 0xd8, - 0x6e, 0x27, 0xc4, 0xdb, 0x40, 0x02, 0x05, 0xae, 0x6d, 0x94, 0x93, 0x90, 0xa8, 0x0b, 0x99, 0x39, 0x26, 0x24, 0x0b, - 0xf4, 0x1a, 0x3b, 0x0a, 0xe8, 0x29, 0xb7, 0x4f, 0x01, 0x7d, 0x51, 0xb0, 0x53, 0x3e, 0x08, 0x86, 0x18, 0x6f, 0x36, - 0xa0, 0x9f, 0xa4, 0x7a, 0x04, 0x8f, 0x69, 0x60, 0xb9, 0xe8, 0x9b, 0x82, 0x21, 0xcc, 0xd2, 0x3f, 0x53, 0x36, 0xf9, - 0xee, 0xef, 0x6e, 0x7e, 0xcf, 0xb4, 0x98, 0x1d, 0x84, 0xe2, 0xf6, 0x7a, 0x02, 0xc4, 0xaf, 0xe2, 0x57, 0x60, 0x6d, - 0xae, 0x25, 0xde, 0x9e, 0xe4, 0x41, 0xf8, 0x72, 0x74, 0xfb, 0x49, 0x69, 0x3e, 0x81, 0xa0, 0x3d, 0x4e, 0x52, 0xee, - 0xbe, 0xfb, 0x20, 0x5d, 0x45, 0x30, 0x5a, 0x80, 0xe0, 0x77, 0x67, 0x25, 0x9b, 0xa6, 0xf0, 0x1f, 0xeb, 0x7c, 0x81, - 0xb1, 0x54, 0xe4, 0x07, 0x9c, 0xfe, 0x26, 0x38, 0xb8, 0x7f, 0x2b, 0xb3, 0x86, 0x44, 0x67, 0xea, 0x23, 0xa0, 0xff, - 0x63, 0x3d, 0x7e, 0xa7, 0x28, 0xe9, 0x4b, 0xe2, 0x1c, 0xe1, 0x9b, 0x78, 0x89, 0xa6, 0x8b, 0xbd, 0x71, 0x4d, 0x3f, - 0x17, 0xe6, 0x85, 0x56, 0x70, 0xd8, 0xb7, 0x46, 0xe1, 0x81, 0x67, 0xde, 0xaf, 0xa2, 0x21, 0xe8, 0xfe, 0x11, 0xf7, - 0xc6, 0xaf, 0x82, 0x65, 0x78, 0x53, 0xce, 0x32, 0x73, 0x87, 0xbb, 0xc9, 0x44, 0x2a, 0x6f, 0x18, 0x0b, 0xd6, 0x42, - 0x99, 0xf3, 0xa6, 0xc1, 0x6c, 0x5b, 0x47, 0x2a, 0xd9, 0x7d, 0xff, 0x67, 0xe3, 0x84, 0xcd, 0x06, 0xc1, 0x87, 0x4a, - 0x16, 0xf1, 0x25, 0x0f, 0xa6, 0x5a, 0x45, 0x91, 0x81, 0x5d, 0x21, 0x20, 0xe5, 0x38, 0xed, 0x1d, 0x3c, 0x59, 0x6a, - 0x66, 0x42, 0x7e, 0x5b, 0x9d, 0x05, 0xbc, 0x35, 0xa3, 0x79, 0x5a, 0xc1, 0x2e, 0xf3, 0x95, 0x14, 0x3f, 0xb4, 0x24, - 0xd9, 0x58, 0x7f, 0x43, 0x86, 0x6d, 0xe5, 0x33, 0x67, 0x80, 0xb9, 0xf3, 0x49, 0xaa, 0xa0, 0x7f, 0x3d, 0xc6, 0x6e, - 0x24, 0x12, 0x01, 0xe1, 0x2c, 0x26, 0x6e, 0x85, 0x09, 0x87, 0xe9, 0x02, 0x05, 0xc5, 0x18, 0x28, 0xe8, 0x83, 0x0c, - 0x39, 0x3d, 0xe5, 0x83, 0xa4, 0x31, 0x5b, 0x3f, 0xa8, 0x12, 0xe9, 0x8d, 0x24, 0x74, 0x03, 0xbf, 0xc7, 0x2d, 0x1e, - 0xa8, 0x11, 0xac, 0xd3, 0xdd, 0x9c, 0x0e, 0xdf, 0x14, 0x64, 0xf8, 0x4f, 0xf0, 0x76, 0x8b, 0xed, 0x65, 0x39, 0x81, - 0xc5, 0x1d, 0x7b, 0xc5, 0xd3, 0x5c, 0xb5, 0x38, 0x21, 0x1e, 0xb1, 0xc8, 0x7d, 0x62, 0x01, 0x23, 0x6a, 0x18, 0x8d, - 0x7f, 0x7c, 0x78, 0xfb, 0x46, 0x63, 0x58, 0xe5, 0xfe, 0x07, 0x30, 0xa2, 0x5a, 0xda, 0x6e, 0x07, 0x7c, 0x39, 0x42, - 0x03, 0xf6, 0xd4, 0x0d, 0x76, 0xbf, 0x6f, 0xd2, 0x4e, 0x4a, 0x2f, 0x9b, 0x13, 0x83, 0xee, 0x29, 0x6d, 0x96, 0xca, - 0xc0, 0xb8, 0xab, 0x70, 0x34, 0x27, 0x36, 0x62, 0x55, 0xef, 0xc3, 0x70, 0x49, 0x63, 0x2b, 0x2b, 0xb7, 0xbb, 0x09, - 0x47, 0x36, 0x01, 0xae, 0x4f, 0x41, 0x7b, 0x35, 0xe7, 0xa0, 0x05, 0x25, 0x0a, 0x1c, 0xd1, 0x6e, 0x17, 0x42, 0x44, - 0x92, 0x62, 0x38, 0x99, 0x85, 0xc5, 0x70, 0xa8, 0x06, 0xbe, 0x20, 0x24, 0xfa, 0x5c, 0xcc, 0xb3, 0x85, 0x42, 0x30, - 0xf2, 0x77, 0xd2, 0xaf, 0x85, 0xe2, 0x94, 0x7b, 0xbf, 0x0a, 0xb2, 0xfd, 0x31, 0xc5, 0x18, 0x8c, 0x4e, 0xb3, 0x99, - 0x81, 0x84, 0xf5, 0xb4, 0x22, 0x6a, 0x1d, 0xd9, 0xd9, 0x00, 0x55, 0x2c, 0x9a, 0x06, 0x83, 0xba, 0xc5, 0x13, 0xeb, - 0x19, 0xbd, 0x07, 0x95, 0x20, 0xaa, 0x05, 0xbb, 0x31, 0x5c, 0x6b, 0x9f, 0x45, 0x28, 0x29, 0x27, 0x4d, 0x66, 0xc6, - 0x8a, 0x06, 0x0b, 0x10, 0x92, 0xc6, 0x65, 0xf5, 0x5a, 0xa6, 0xd9, 0x45, 0x06, 0x08, 0x12, 0xce, 0x9f, 0x50, 0x36, - 0xde, 0x3c, 0x55, 0xf3, 0xd2, 0x95, 0x38, 0xb3, 0xb0, 0x27, 0x5d, 0x6f, 0x69, 0x41, 0xa2, 0x02, 0x68, 0x94, 0xaf, - 0xe5, 0xf9, 0x79, 0xcf, 0x2a, 0x64, 0xff, 0xc3, 0xa9, 0xb2, 0x1d, 0xe2, 0x27, 0xac, 0x22, 0xde, 0x69, 0x5d, 0x29, - 0x91, 0x46, 0x47, 0xdb, 0x80, 0x18, 0xb6, 0xec, 0x5b, 0xd4, 0xf0, 0x41, 0xd8, 0x45, 0x27, 0xf9, 0x41, 0x4f, 0xf1, - 0xd8, 0x1a, 0x48, 0xfa, 0x5a, 0x04, 0x5f, 0xa3, 0x23, 0x9d, 0x28, 0xd3, 0x48, 0x4c, 0x21, 0xd1, 0xaf, 0x17, 0x5a, - 0x63, 0x19, 0x65, 0x5f, 0x91, 0xff, 0xbb, 0xee, 0xde, 0xaf, 0x62, 0xb7, 0x83, 0x49, 0xf6, 0x3c, 0xd0, 0x60, 0x53, - 0xa3, 0x56, 0x08, 0x67, 0xe7, 0xb4, 0x42, 0xed, 0x58, 0x2f, 0x2c, 0x81, 0x3c, 0x80, 0xad, 0x48, 0x83, 0x32, 0x48, - 0xf6, 0xb9, 0x98, 0x8b, 0x85, 0x13, 0xe5, 0x48, 0x85, 0x7f, 0x26, 0x47, 0x29, 0x87, 0xab, 0x58, 0x58, 0x30, 0xe4, - 0x57, 0x47, 0x17, 0x85, 0xbc, 0x02, 0x49, 0x89, 0x61, 0xa8, 0x2c, 0xaf, 0x8b, 0xab, 0xb6, 0x24, 0xb4, 0xb7, 0x01, - 0x50, 0x9a, 0x02, 0x04, 0x2f, 0x8d, 0x1a, 0x62, 0xb6, 0x55, 0xbb, 0x2b, 0xba, 0x93, 0x1c, 0x50, 0xa7, 0xbb, 0x76, - 0xeb, 0x4d, 0xd9, 0xaa, 0x5b, 0x71, 0xe1, 0x0f, 0x50, 0xfa, 0x29, 0x1f, 0x14, 0x3e, 0x95, 0xc0, 0x8d, 0xaf, 0x36, - 0x59, 0x76, 0xb1, 0xc1, 0xa5, 0x5f, 0x35, 0xc6, 0xaf, 0xdf, 0xef, 0xa9, 0x85, 0xd0, 0x48, 0x05, 0xe6, 0xdb, 0x67, - 0xa6, 0x2a, 0xa3, 0x29, 0xb5, 0x97, 0xe0, 0xca, 0xd9, 0x8f, 0xa0, 0x22, 0xae, 0x2b, 0x52, 0x9b, 0x1a, 0xa0, 0x03, - 0x2f, 0x2b, 0xdc, 0xca, 0x02, 0x3c, 0x76, 0x02, 0xb2, 0xdb, 0xf1, 0x30, 0xd0, 0x87, 0x4e, 0xe0, 0x6f, 0xc9, 0xd7, - 0xc8, 0xac, 0xd9, 0xc7, 0x7f, 0x68, 0xc1, 0x3f, 0xb6, 0xe0, 0x27, 0x14, 0x77, 0x5a, 0x99, 0x7f, 0x2b, 0xad, 0x5b, - 0xdc, 0xbf, 0x97, 0x69, 0x42, 0x51, 0x99, 0x50, 0xfb, 0x95, 0x56, 0x6b, 0xa3, 0xc6, 0xc0, 0xec, 0x1f, 0x25, 0x7c, - 0x30, 0x6b, 0x3c, 0xb1, 0xc6, 0x93, 0xe1, 0x74, 0x2b, 0x0d, 0xcb, 0x80, 0x42, 0x3f, 0x2f, 0x73, 0x45, 0xf5, 0xf3, - 0xcf, 0x6b, 0xbe, 0xe6, 0xcd, 0x16, 0xdb, 0xa4, 0x7b, 0x1a, 0xec, 0xe5, 0xd1, 0x94, 0xc2, 0x49, 0xd4, 0xb9, 0x91, - 0xa8, 0x8b, 0x9a, 0x65, 0xa8, 0x4e, 0xf0, 0x6a, 0x9e, 0xea, 0x61, 0x6f, 0x26, 0xa2, 0xb5, 0x92, 0xb2, 0xc4, 0x80, - 0xb5, 0x8e, 0x3c, 0x24, 0x77, 0x6b, 0x1d, 0x77, 0x1a, 0xea, 0xd2, 0x14, 0x6a, 0x82, 0x15, 0x2e, 0xc0, 0x11, 0xf4, - 0xbe, 0x08, 0x39, 0x5c, 0x53, 0x95, 0x7e, 0x41, 0x53, 0xf2, 0xc4, 0x53, 0xd4, 0x6a, 0x45, 0xba, 0xfd, 0x28, 0xc7, - 0x6e, 0xf8, 0xc6, 0x09, 0x39, 0x31, 0x42, 0x7f, 0x77, 0x2c, 0xe5, 0x0c, 0x2d, 0x1e, 0xd4, 0x09, 0xd6, 0xcb, 0x5b, - 0x0a, 0x14, 0x73, 0x74, 0x59, 0x75, 0xcd, 0x2b, 0xb4, 0x7d, 0x59, 0xf6, 0xfb, 0xb9, 0xad, 0x27, 0x65, 0x27, 0xdb, - 0xa5, 0xd9, 0x87, 0xa8, 0x98, 0xc2, 0x5d, 0x9f, 0x68, 0xfe, 0x2a, 0xd4, 0x57, 0x6d, 0x99, 0xf3, 0x11, 0x47, 0x9c, - 0x90, 0x9c, 0xd4, 0xff, 0x50, 0x53, 0xaf, 0xc4, 0xfd, 0xaa, 0x92, 0x97, 0xc2, 0x58, 0x31, 0x5a, 0x62, 0x88, 0x22, - 0xed, 0xde, 0x98, 0xbe, 0x2a, 0x00, 0xfe, 0x4a, 0xb0, 0x3f, 0xd3, 0x50, 0x2b, 0xbf, 0x45, 0x5b, 0xc0, 0xbf, 0x55, - 0xdc, 0x80, 0x55, 0x60, 0x80, 0xd1, 0x64, 0x7b, 0x4e, 0x13, 0x38, 0xe0, 0x84, 0x56, 0x51, 0x50, 0x61, 0x86, 0x86, - 0xda, 0xc2, 0xe8, 0x6b, 0x94, 0x71, 0xab, 0xcc, 0xde, 0x8d, 0xb1, 0xd3, 0x02, 0xaf, 0xe1, 0xdf, 0xe8, 0x85, 0x62, - 0x36, 0xea, 0x20, 0x3d, 0x3a, 0x89, 0xe9, 0x8f, 0x5b, 0x38, 0xb9, 0x59, 0x38, 0xcb, 0x9a, 0x25, 0xd0, 0x1d, 0xb8, - 0x20, 0xc6, 0xfd, 0x7e, 0x0e, 0x47, 0xa6, 0x19, 0xf9, 0x82, 0xe5, 0x34, 0x66, 0x4b, 0xaa, 0x3d, 0x0f, 0x2f, 0xab, - 0x30, 0xa7, 0x4b, 0x2b, 0xe3, 0x4d, 0x19, 0xa8, 0x8c, 0x76, 0xbb, 0x10, 0xfe, 0x74, 0x5b, 0xbb, 0xa4, 0xf3, 0x25, - 0x64, 0x80, 0x3f, 0x20, 0x11, 0x45, 0x2c, 0xf0, 0xff, 0xa8, 0x71, 0x4a, 0x4f, 0x94, 0xd6, 0x2c, 0x81, 0xe0, 0x71, - 0xaa, 0x7e, 0x7a, 0xc1, 0xd6, 0x8d, 0xa5, 0xb0, 0xdb, 0x85, 0xcd, 0x04, 0xa6, 0x39, 0x57, 0x32, 0xbd, 0x40, 0x9d, - 0x14, 0x50, 0xb1, 0xf0, 0x02, 0x97, 0x5f, 0x4a, 0x28, 0x34, 0x77, 0xbe, 0x5c, 0x18, 0x25, 0x26, 0xb4, 0x4a, 0x7e, - 0xfd, 0x50, 0x99, 0xaf, 0x8d, 0x87, 0x60, 0xb5, 0x0e, 0x13, 0x53, 0x24, 0x2a, 0x44, 0x67, 0x2f, 0x41, 0x96, 0x23, - 0x00, 0xd7, 0xf3, 0xb5, 0xac, 0x29, 0x5f, 0x43, 0x5c, 0x78, 0x68, 0xd0, 0xbb, 0x42, 0x5e, 0x65, 0x25, 0x0f, 0xf1, - 0x9e, 0xe0, 0x69, 0x46, 0xef, 0x36, 0xf8, 0xd0, 0xd6, 0x1e, 0x3d, 0x41, 0xb6, 0x9e, 0x72, 0xbf, 0x7e, 0x29, 0xc2, - 0x39, 0x44, 0xef, 0x5c, 0x50, 0xad, 0xae, 0x76, 0x80, 0x5c, 0x9e, 0xed, 0xd5, 0x3b, 0x38, 0xdd, 0xf4, 0xf5, 0xad, - 0x0a, 0x9d, 0x39, 0x80, 0xb4, 0x87, 0x64, 0x5d, 0x73, 0xbd, 0x03, 0xdc, 0x91, 0x98, 0xad, 0x81, 0xc6, 0xba, 0xad, - 0xd9, 0x69, 0x8f, 0xe2, 0x31, 0x91, 0x99, 0xb1, 0x48, 0x31, 0xe6, 0x6e, 0x9d, 0x16, 0x45, 0x5b, 0x34, 0x43, 0xd8, - 0xbf, 0xeb, 0x88, 0x75, 0x2b, 0xe2, 0xfc, 0xdd, 0xb6, 0x2f, 0x30, 0x1a, 0xc6, 0x5c, 0xbb, 0xe7, 0x19, 0xba, 0x61, - 0x83, 0x6d, 0x24, 0x41, 0x44, 0x82, 0xcc, 0xd4, 0x81, 0x28, 0x6b, 0x6b, 0xc0, 0xf6, 0x8e, 0xeb, 0x4d, 0x0b, 0xfc, - 0xbc, 0x89, 0xc1, 0xdb, 0xb3, 0xc6, 0x29, 0xad, 0xaf, 0x71, 0xcd, 0x71, 0x55, 0x88, 0xa8, 0x2d, 0x52, 0x00, 0x0c, - 0x3b, 0x5f, 0xe0, 0xce, 0xac, 0x30, 0x98, 0x13, 0x96, 0x4a, 0xf6, 0x2a, 0xd7, 0x9f, 0xc3, 0x16, 0x07, 0xa9, 0x7c, - 0xe9, 0xf5, 0xf7, 0x1f, 0xbe, 0xf8, 0x02, 0xdd, 0xf6, 0x9c, 0x1f, 0x41, 0x90, 0x09, 0x74, 0x50, 0x53, 0xaa, 0xc7, - 0x97, 0x05, 0x50, 0x7b, 0x98, 0x87, 0x97, 0x05, 0x13, 0xf1, 0x75, 0x76, 0x19, 0x57, 0xb2, 0x18, 0x5d, 0x73, 0x91, - 0xca, 0xc2, 0x4a, 0x8d, 0x83, 0xd3, 0xd5, 0x2a, 0xe7, 0x01, 0x98, 0xca, 0x5b, 0x46, 0xd9, 0x09, 0x19, 0xf5, 0xe0, - 0x6a, 0x79, 0x7a, 0xa5, 0x45, 0xe7, 0xe5, 0xf5, 0x65, 0x10, 0xe1, 0xaf, 0x73, 0xf3, 0xe3, 0x2a, 0x2e, 0x3f, 0x05, - 0x91, 0xb5, 0xa9, 0x33, 0x3f, 0x50, 0x2a, 0x0f, 0xfe, 0x4e, 0x20, 0xd3, 0x7d, 0x59, 0x80, 0x65, 0xb6, 0xad, 0xf8, - 0x38, 0xc6, 0x5a, 0x87, 0x13, 0x32, 0x53, 0x25, 0x7a, 0xef, 0x92, 0x75, 0x01, 0xd6, 0x7e, 0x0a, 0xdb, 0x59, 0xe5, - 0x9a, 0x61, 0x65, 0xaa, 0x22, 0x63, 0x00, 0xbf, 0x66, 0x87, 0xa1, 0x75, 0xa2, 0x99, 0xa3, 0xb7, 0x80, 0x7e, 0x20, - 0x87, 0x97, 0xb4, 0x58, 0x33, 0xcf, 0xc7, 0xa6, 0xf1, 0xfa, 0xc1, 0xe1, 0xa5, 0x5b, 0xb0, 0xd7, 0xf6, 0x4e, 0x8e, - 0xc2, 0x44, 0xf0, 0x34, 0x36, 0xe3, 0x8b, 0x3c, 0x2b, 0x60, 0x07, 0x4d, 0xc6, 0x63, 0xea, 0x2d, 0xad, 0xd6, 0xcd, - 0xd1, 0x21, 0xdb, 0x66, 0x0f, 0xab, 0x87, 0x9c, 0x1c, 0xf2, 0x96, 0xa9, 0x6d, 0xdb, 0x3a, 0xce, 0xd3, 0xe4, 0x2b, - 0xd3, 0x7d, 0xb9, 0xb6, 0x11, 0xe2, 0x95, 0xb3, 0xa3, 0xf3, 0x92, 0x6e, 0x7d, 0x53, 0x1a, 0x7a, 0x2d, 0x01, 0x98, - 0x4f, 0x1b, 0xf0, 0x17, 0xac, 0x58, 0x8f, 0x2a, 0x5e, 0x56, 0x20, 0x61, 0x41, 0x11, 0xde, 0x14, 0x7b, 0x53, 0xb8, - 0x1b, 0xa7, 0xe7, 0xb0, 0x03, 0x17, 0x53, 0x74, 0xc7, 0x89, 0xc9, 0xac, 0x34, 0x5a, 0xd1, 0x48, 0xff, 0x72, 0x7d, - 0x89, 0x75, 0x5f, 0xb4, 0x32, 0xcf, 0xe6, 0x54, 0xd8, 0xf4, 0xae, 0x72, 0xe9, 0x44, 0xfd, 0x96, 0x09, 0x57, 0xae, - 0x04, 0x01, 0x99, 0x16, 0xac, 0x57, 0x98, 0x5d, 0x14, 0x23, 0x21, 0x03, 0xc3, 0xd7, 0x60, 0x2d, 0x4a, 0x6e, 0xac, - 0x60, 0xbd, 0x7b, 0xbe, 0x4e, 0x10, 0x52, 0xf0, 0xc0, 0x4d, 0xd0, 0x2f, 0xad, 0x9b, 0xb7, 0xa3, 0x44, 0x19, 0xc4, - 0x27, 0xd7, 0x4e, 0x39, 0x48, 0x20, 0x00, 0x07, 0x56, 0x85, 0x24, 0x51, 0xa0, 0xf3, 0xe0, 0x6a, 0xc6, 0x11, 0x6c, - 0x5e, 0x39, 0x73, 0x71, 0x03, 0x38, 0xaf, 0xfc, 0xb9, 0x6c, 0xb0, 0x65, 0x3d, 0xa2, 0xca, 0x9c, 0x71, 0x8a, 0x41, - 0x9d, 0x2c, 0x41, 0x5f, 0x59, 0x4a, 0x7b, 0x09, 0x9a, 0xc6, 0x2b, 0xb6, 0x52, 0x3e, 0x00, 0xf4, 0x9c, 0xad, 0x94, - 0xb1, 0x3f, 0x7e, 0x7d, 0xc6, 0x56, 0x5a, 0x1a, 0x3c, 0xbd, 0x9a, 0x9d, 0xcf, 0xce, 0x06, 0xec, 0x28, 0x0a, 0xb5, - 0x01, 0x43, 0xe0, 0x22, 0x13, 0x04, 0x83, 0x50, 0xe3, 0xbf, 0x0c, 0x54, 0x80, 0x30, 0xe2, 0xf1, 0xd8, 0x88, 0x23, - 0x16, 0x8e, 0x87, 0x18, 0x0c, 0xac, 0xf9, 0x82, 0x04, 0x84, 0x9a, 0xd2, 0xd0, 0xd7, 0x33, 0x1c, 0x4e, 0x0e, 0x26, - 0x90, 0x8a, 0x99, 0x99, 0x2a, 0x8c, 0x8d, 0x49, 0x04, 0xf1, 0x5f, 0x3b, 0xeb, 0x85, 0x72, 0xbb, 0x6b, 0x34, 0x10, - 0x34, 0x83, 0xaf, 0xaa, 0x78, 0x72, 0x30, 0xec, 0xaa, 0x18, 0x47, 0xe1, 0xda, 0x28, 0xdf, 0xce, 0x8e, 0x01, 0xcc, - 0xf7, 0x6c, 0xe8, 0xcb, 0x25, 0xce, 0x0e, 0x1f, 0x93, 0x87, 0x8f, 0x09, 0x3d, 0x63, 0x67, 0xdf, 0x3c, 0xa6, 0x67, - 0x8a, 0x9c, 0x1c, 0x4c, 0xa2, 0x6b, 0x66, 0x31, 0x70, 0x8e, 0x54, 0x13, 0xe8, 0xe5, 0x68, 0x2d, 0xd4, 0x02, 0xd3, - 0x0e, 0x4d, 0xe1, 0xf7, 0xe3, 0x83, 0x60, 0x70, 0xdd, 0x6e, 0xfa, 0x75, 0xbb, 0xad, 0x9e, 0x57, 0xd7, 0xc1, 0x51, - 0xb4, 0x5f, 0xcc, 0xe4, 0xef, 0xe3, 0x03, 0x37, 0x07, 0x58, 0xdf, 0xfd, 0x63, 0x62, 0x9a, 0xb4, 0x37, 0x2a, 0x7e, - 0x4d, 0x8f, 0xb0, 0x0f, 0xcd, 0x22, 0x3b, 0xfa, 0x30, 0xfc, 0x8f, 0x3a, 0x51, 0x9f, 0x7d, 0x73, 0x04, 0xe4, 0x08, - 0x64, 0xa0, 0x58, 0x22, 0x98, 0xe1, 0x40, 0x53, 0x40, 0x41, 0xa6, 0xc7, 0x9d, 0xea, 0xe1, 0x57, 0xa3, 0xa6, 0x66, - 0xe4, 0x1a, 0xa6, 0x06, 0xdb, 0x82, 0x1f, 0xa8, 0x6e, 0xe8, 0x6f, 0x34, 0xda, 0x93, 0x76, 0x32, 0x33, 0x2f, 0xa9, - 0x8d, 0x73, 0x77, 0x0d, 0x01, 0x9d, 0x1d, 0xdc, 0xa2, 0x64, 0xdf, 0x1e, 0x5f, 0x1e, 0xe0, 0x2a, 0x02, 0xd4, 0x30, - 0x16, 0x7c, 0x3b, 0xb8, 0xd4, 0x9b, 0xfb, 0x20, 0x20, 0x83, 0x6f, 0x83, 0x93, 0x6f, 0x07, 0x72, 0x10, 0x1c, 0x1f, - 0x5e, 0x9e, 0x04, 0xce, 0xb8, 0x1f, 0x42, 0x5e, 0xaa, 0x8a, 0x62, 0x26, 0x4c, 0x15, 0x89, 0xad, 0x3d, 0xb7, 0xf5, - 0x2a, 0xe3, 0x33, 0x9a, 0x4e, 0x2d, 0x12, 0x7a, 0x98, 0xb2, 0xd8, 0xfc, 0x0e, 0x26, 0xfc, 0x2a, 0x88, 0x5c, 0x50, - 0xd8, 0x59, 0x1e, 0xc5, 0x74, 0xc9, 0xae, 0x45, 0x98, 0xd2, 0xe4, 0x30, 0x27, 0x24, 0x0a, 0x97, 0x0a, 0x4c, 0x50, - 0xbd, 0x4e, 0x20, 0xae, 0xad, 0xfb, 0xfc, 0x5a, 0x84, 0x4b, 0x9a, 0x1f, 0x26, 0xa4, 0x55, 0x84, 0x8b, 0x50, 0xb3, - 0xad, 0xe9, 0x05, 0x0b, 0x57, 0xf4, 0x12, 0x98, 0xa9, 0x78, 0x1d, 0x5e, 0x02, 0x97, 0xb7, 0x9e, 0xaf, 0x16, 0xec, - 0xb2, 0x21, 0x7d, 0x33, 0x7c, 0xf1, 0x85, 0xf5, 0xc9, 0x03, 0x1e, 0xd2, 0xf9, 0xe1, 0xa5, 0x60, 0x03, 0x70, 0x9d, - 0xf1, 0x9b, 0x1f, 0xe4, 0xad, 0x9e, 0x97, 0xf6, 0x14, 0xe3, 0xcc, 0xb4, 0x13, 0x93, 0x76, 0x42, 0xee, 0xdf, 0xb7, - 0x7d, 0xf7, 0xe2, 0xb5, 0x72, 0x59, 0xb5, 0x0c, 0x49, 0xb2, 0x56, 0xae, 0xd3, 0x28, 0x39, 0xb5, 0x02, 0x4f, 0x76, - 0xc1, 0xab, 0x64, 0xe9, 0x1f, 0x54, 0xd6, 0x6a, 0xc0, 0x1e, 0x23, 0x96, 0x85, 0xc2, 0xb1, 0x7f, 0x9d, 0xb1, 0x64, - 0xed, 0x0b, 0x34, 0x72, 0xe4, 0xde, 0x5e, 0x67, 0xcc, 0x8b, 0x41, 0xbb, 0x5c, 0x7b, 0xa1, 0xfb, 0xbc, 0xf4, 0xb4, - 0xc5, 0x7b, 0x39, 0xa5, 0x86, 0x91, 0x88, 0x1e, 0x8c, 0x95, 0x19, 0xa5, 0x4a, 0xd4, 0x1a, 0x34, 0x22, 0xd8, 0xd8, - 0x05, 0x03, 0x05, 0x27, 0x54, 0xee, 0xa9, 0xb3, 0x7d, 0x3b, 0xa5, 0xd2, 0x03, 0xda, 0xa5, 0x46, 0x55, 0xee, 0x96, - 0x99, 0x64, 0xd5, 0x20, 0x18, 0xfd, 0x59, 0x4a, 0x31, 0xc3, 0x3b, 0x23, 0x0b, 0xa6, 0x60, 0x25, 0xa8, 0x6a, 0x19, - 0x96, 0x43, 0x8e, 0x5a, 0x3c, 0xe3, 0x93, 0x2a, 0xf5, 0x8f, 0x8e, 0xa0, 0xc1, 0xeb, 0x75, 0x2b, 0x68, 0xf0, 0xe3, - 0xf1, 0x63, 0x3d, 0xd0, 0x17, 0x6b, 0xed, 0x78, 0xe8, 0xf3, 0xdb, 0x88, 0x37, 0xae, 0x7b, 0x4f, 0xb5, 0x56, 0xa1, - 0x0c, 0xb4, 0x58, 0x51, 0xb9, 0x52, 0x4b, 0x7a, 0xb7, 0x8b, 0x00, 0x58, 0xc4, 0xc6, 0x6c, 0xbc, 0x6f, 0x9b, 0x15, - 0x82, 0x46, 0x17, 0x96, 0xe2, 0x80, 0x25, 0xba, 0xb5, 0x83, 0x09, 0x8d, 0x4f, 0x58, 0xd9, 0xef, 0xe7, 0x27, 0x40, - 0x4f, 0xb5, 0x11, 0x53, 0x01, 0x47, 0xfe, 0xd7, 0x56, 0x64, 0x8a, 0x02, 0x9b, 0x35, 0x75, 0xb7, 0xc6, 0x32, 0x12, - 0x7d, 0x99, 0xd2, 0xe5, 0x09, 0xcf, 0x80, 0x69, 0xb5, 0x6e, 0x39, 0xae, 0xec, 0x2b, 0x8e, 0x3c, 0x15, 0x96, 0x15, - 0xe7, 0x55, 0x38, 0xde, 0x7a, 0x7c, 0x83, 0x43, 0xc3, 0xa6, 0x5d, 0xfa, 0x43, 0x08, 0x0b, 0xe1, 0x75, 0x06, 0xb7, - 0x11, 0x6d, 0x27, 0x81, 0xca, 0x1b, 0x73, 0x9d, 0x50, 0x36, 0xb7, 0xab, 0xb5, 0x67, 0x90, 0x4e, 0xcc, 0x81, 0x52, - 0x8d, 0xa0, 0x35, 0x9a, 0x05, 0x55, 0x23, 0x1e, 0x39, 0xf3, 0x2f, 0x67, 0x10, 0xab, 0xe5, 0x4b, 0x9a, 0x4a, 0xd1, - 0x00, 0x8c, 0x0b, 0xe0, 0xf2, 0xf4, 0xcb, 0xfb, 0x9f, 0x3e, 0xf0, 0xb8, 0x48, 0x96, 0xef, 0xe2, 0x22, 0xbe, 0x2a, - 0xc3, 0xad, 0x1a, 0xa3, 0xb8, 0x26, 0x53, 0x31, 0x60, 0xd2, 0xac, 0xa4, 0xe6, 0xae, 0xd4, 0x84, 0x18, 0xeb, 0x4c, - 0xd6, 0x65, 0x25, 0xaf, 0x1a, 0x95, 0xae, 0x8b, 0x0c, 0x3f, 0x6e, 0xf9, 0x9c, 0x1e, 0x02, 0xb0, 0xa9, 0x71, 0x21, - 0x8d, 0xa4, 0x2e, 0xc4, 0x98, 0x8b, 0x78, 0x5d, 0x1f, 0x8f, 0x1b, 0x5d, 0x2f, 0xd9, 0x93, 0xf1, 0xa3, 0xe9, 0xeb, - 0x2c, 0xcc, 0x06, 0x82, 0x8c, 0xaa, 0x25, 0x17, 0x2d, 0x53, 0x4e, 0x65, 0x12, 0x80, 0x3e, 0x9e, 0x3d, 0xc6, 0x8e, - 0xc6, 0x63, 0xb2, 0x6d, 0x8b, 0x07, 0x78, 0xb8, 0x5e, 0x87, 0x05, 0x99, 0xe9, 0x3a, 0xa2, 0x40, 0xf0, 0xdb, 0x2a, - 0x00, 0x64, 0x4b, 0x5b, 0x95, 0xe1, 0xd2, 0xd8, 0x93, 0xf1, 0x84, 0x4a, 0xec, 0x76, 0x48, 0x6a, 0xaf, 0x42, 0x37, - 0xf3, 0xd2, 0xf7, 0x28, 0x92, 0xc6, 0x65, 0x69, 0xaf, 0x52, 0xa9, 0xf6, 0xcc, 0xcc, 0x75, 0x0d, 0x62, 0x52, 0x84, - 0xba, 0xee, 0xd2, 0xab, 0x7b, 0xbf, 0xb9, 0xd6, 0x6c, 0x07, 0xbc, 0xd7, 0xa0, 0x19, 0x4a, 0xde, 0x62, 0xde, 0xba, - 0x22, 0x6a, 0x7a, 0xb5, 0x06, 0xb3, 0x62, 0x94, 0x2d, 0x45, 0x17, 0x6b, 0x0a, 0x4a, 0xc1, 0xe8, 0x72, 0xed, 0x2d, - 0xdc, 0xa7, 0xb2, 0x71, 0x61, 0xc9, 0xf4, 0x6a, 0x51, 0x52, 0x42, 0x75, 0x53, 0x31, 0x52, 0xc2, 0x48, 0x69, 0x78, - 0x2a, 0xdf, 0x0b, 0x3c, 0xce, 0xf3, 0x20, 0x6a, 0x79, 0x81, 0x9d, 0x56, 0xe4, 0x14, 0x1c, 0xbd, 0x4c, 0x4e, 0x43, - 0x81, 0x2b, 0xa1, 0x40, 0x5d, 0x87, 0xea, 0x7e, 0x83, 0x9b, 0xff, 0xb7, 0x82, 0x05, 0x1e, 0xdf, 0x7a, 0x8e, 0xdb, - 0xe8, 0xb7, 0xc2, 0xa7, 0xa5, 0x0f, 0xa4, 0xef, 0xea, 0xe2, 0x49, 0x7b, 0xb3, 0x51, 0xb2, 0xcc, 0xf2, 0xf4, 0x8d, - 0x4c, 0x39, 0x88, 0xcc, 0xd0, 0x1a, 0x94, 0x9d, 0x88, 0xc6, 0x0d, 0x0f, 0x8c, 0x18, 0x1b, 0x37, 0xbe, 0x0a, 0x02, - 0x39, 0x02, 0x72, 0x3f, 0x67, 0xa9, 0x4c, 0xd6, 0x80, 0xb0, 0xa1, 0xe5, 0x27, 0x1a, 0x6f, 0x23, 0xd4, 0xd7, 0x2f, - 0x70, 0x9b, 0x2b, 0x7d, 0x9f, 0xf3, 0x4a, 0xd0, 0x4a, 0x00, 0xf0, 0x4b, 0xbc, 0x02, 0xb9, 0xc7, 0x53, 0xa8, 0x1b, - 0x61, 0x7b, 0x39, 0x06, 0x4b, 0x42, 0x74, 0x14, 0x51, 0xb1, 0x40, 0x41, 0x53, 0x18, 0x44, 0x11, 0x75, 0xc1, 0x1c, - 0x9e, 0xe7, 0x32, 0xf9, 0x34, 0x35, 0x3e, 0xf3, 0xc3, 0x18, 0x63, 0x48, 0x07, 0x83, 0xb0, 0x9a, 0x05, 0xc3, 0xf1, - 0x68, 0x72, 0xf4, 0x04, 0xce, 0xed, 0x60, 0x1c, 0x90, 0x41, 0x50, 0x97, 0xab, 0x58, 0xd0, 0xf2, 0xfa, 0xd2, 0x96, - 0x81, 0x1f, 0xd7, 0xc1, 0xe0, 0xb7, 0xc2, 0x8d, 0xca, 0xbf, 0x41, 0x73, 0xb2, 0x91, 0x61, 0x10, 0xd0, 0xab, 0x35, - 0x01, 0x49, 0x59, 0x4f, 0xf3, 0x93, 0xfa, 0x70, 0x63, 0x4a, 0xfb, 0x67, 0x0e, 0x2f, 0x38, 0xec, 0x90, 0x40, 0x81, - 0x34, 0x9e, 0x66, 0xa3, 0x57, 0x4a, 0x91, 0xfb, 0xae, 0xe0, 0x70, 0x67, 0xee, 0x39, 0xd3, 0x23, 0xa7, 0x90, 0x68, - 0x66, 0x01, 0x37, 0xf2, 0x57, 0xe2, 0x3a, 0xce, 0xb3, 0xf4, 0xa0, 0xf9, 0xe6, 0xa0, 0xdc, 0x88, 0x2a, 0xbe, 0x1d, - 0x05, 0xc6, 0x9a, 0x90, 0xfb, 0xaa, 0x27, 0x40, 0x4f, 0x80, 0x2d, 0x00, 0x06, 0xc4, 0x7b, 0x66, 0x26, 0x33, 0x1e, - 0x81, 0x47, 0x60, 0xd3, 0x07, 0xb2, 0xd8, 0x38, 0x97, 0x24, 0x7f, 0x33, 0x95, 0xf6, 0xaa, 0x57, 0xee, 0x15, 0x64, - 0xbd, 0xda, 0xca, 0x7d, 0xb7, 0x3e, 0xfb, 0xa6, 0xc3, 0x2b, 0xf0, 0x4c, 0x82, 0x5b, 0x64, 0xbf, 0xdf, 0x14, 0x54, - 0x0a, 0xa3, 0x22, 0xde, 0x4b, 0xae, 0xd1, 0xbf, 0xdd, 0x1b, 0x1b, 0x45, 0x72, 0xcb, 0xfb, 0x07, 0x50, 0x67, 0xf2, - 0xae, 0xb8, 0x9d, 0x43, 0xd4, 0xd6, 0xdd, 0x78, 0xe0, 0xbd, 0x41, 0xbb, 0xac, 0x39, 0x82, 0x2d, 0x2f, 0x0e, 0x32, - 0x18, 0x0b, 0x9c, 0x95, 0x91, 0x52, 0xe3, 0x1a, 0x52, 0x0b, 0x3e, 0xc9, 0xd3, 0x3b, 0xc8, 0x52, 0x4f, 0x82, 0x22, - 0xc7, 0xb3, 0x18, 0x32, 0x8d, 0xb7, 0x81, 0xd8, 0x6f, 0x65, 0x08, 0xd2, 0xb4, 0xdd, 0xae, 0x39, 0x02, 0x65, 0xf7, - 0xc0, 0x94, 0xa4, 0xae, 0x8d, 0xa9, 0x81, 0x86, 0x1e, 0x44, 0x8d, 0x54, 0xc4, 0xd9, 0xc9, 0x53, 0xd0, 0x21, 0x82, - 0xef, 0x77, 0x9a, 0x95, 0x1d, 0x2f, 0x26, 0x04, 0x4f, 0xde, 0xe7, 0xb7, 0x59, 0x59, 0x95, 0xd1, 0x9b, 0x14, 0x0d, - 0xa1, 0x12, 0x29, 0xa2, 0xcf, 0x10, 0x5f, 0xb0, 0xc4, 0xdf, 0x65, 0xf4, 0x22, 0xa5, 0x71, 0x9a, 0x62, 0xfa, 0xb3, - 0x02, 0x7e, 0x3e, 0x05, 0x94, 0x4b, 0xdc, 0x09, 0xd1, 0x99, 0x04, 0x7b, 0x35, 0x88, 0xee, 0x55, 0x71, 0xc0, 0x14, - 0x8d, 0xae, 0x05, 0x45, 0xcc, 0x3a, 0xcc, 0xfe, 0x4b, 0x81, 0x42, 0x21, 0x55, 0xcc, 0x4b, 0x61, 0x1f, 0x22, 0xbe, - 0x86, 0x72, 0x4e, 0xdf, 0xbd, 0x32, 0x43, 0x1a, 0xdd, 0x4a, 0xaa, 0xb7, 0x36, 0x1e, 0x5b, 0x88, 0xd2, 0x13, 0x9d, - 0xaf, 0xe9, 0x59, 0xbc, 0xca, 0xa2, 0x2d, 0xe0, 0x4f, 0xbc, 0x7b, 0xf5, 0x54, 0x59, 0x98, 0xbc, 0xca, 0x40, 0x71, - 0x70, 0xfa, 0xee, 0xd5, 0x6b, 0x99, 0xae, 0x73, 0x1e, 0x6d, 0x24, 0x92, 0xd6, 0xd3, 0x77, 0xaf, 0x7e, 0x46, 0x73, - 0xaf, 0xf7, 0x05, 0xbc, 0x7f, 0x01, 0xbc, 0x65, 0x94, 0xaf, 0xa1, 0x4f, 0xea, 0xf7, 0x72, 0x8d, 0x9d, 0xf2, 0x6a, - 0x2d, 0xa3, 0xbf, 0xd2, 0xda, 0x93, 0x56, 0xfd, 0x55, 0xf8, 0xd4, 0xce, 0x13, 0xf0, 0xdc, 0xe6, 0x99, 0xf8, 0x14, - 0x59, 0xd1, 0x4e, 0x10, 0x7d, 0x7b, 0x70, 0x7b, 0x95, 0x8b, 0x32, 0xc2, 0x17, 0x0c, 0xed, 0x82, 0xa2, 0xc3, 0xc3, - 0x9b, 0x9b, 0x9b, 0xd1, 0xcd, 0xa3, 0x91, 0x2c, 0x2e, 0x0f, 0x27, 0xdf, 0x7f, 0xff, 0xfd, 0x21, 0xbe, 0x0d, 0xbe, - 0x6d, 0xbb, 0xbd, 0x57, 0x84, 0x0f, 0x58, 0x80, 0x88, 0xdd, 0xdf, 0xc2, 0x15, 0x05, 0xb4, 0x70, 0x83, 0x6f, 0x83, - 0x6f, 0xf5, 0xa1, 0xf3, 0xed, 0x71, 0x79, 0x7d, 0xa9, 0xca, 0xef, 0x2a, 0xf9, 0x68, 0x3c, 0x1e, 0x1f, 0x82, 0x04, - 0xea, 0xdb, 0x01, 0x1f, 0x04, 0x27, 0xc1, 0x20, 0x83, 0x0b, 0x4d, 0x79, 0x7d, 0x79, 0x12, 0x78, 0x26, 0xaf, 0x0d, - 0x16, 0xd1, 0x81, 0xb8, 0x04, 0x87, 0x97, 0x34, 0xf8, 0x36, 0x20, 0x2e, 0xe5, 0x1b, 0x48, 0xf9, 0xe6, 0xe8, 0x89, - 0x9f, 0xf6, 0xbf, 0x54, 0xda, 0x23, 0x3f, 0xed, 0x18, 0xd3, 0x1e, 0x3d, 0xf5, 0xd3, 0x4e, 0x54, 0xda, 0x73, 0x3f, - 0xed, 0xff, 0x94, 0x03, 0x48, 0x3d, 0xf0, 0xad, 0xff, 0x36, 0x5e, 0x6b, 0xf0, 0x14, 0x8a, 0xb2, 0xab, 0xf8, 0x92, - 0x43, 0xa3, 0x07, 0xb7, 0x57, 0x39, 0x0d, 0x06, 0xd8, 0x5e, 0xcf, 0xc8, 0xc3, 0xfb, 0xe0, 0xdb, 0x75, 0x91, 0x87, - 0xc1, 0xb7, 0x03, 0x2c, 0x64, 0xf0, 0x6d, 0x40, 0xbe, 0x35, 0x06, 0x32, 0x82, 0x6d, 0x03, 0x17, 0x9a, 0x75, 0x68, - 0x03, 0xa6, 0xf9, 0xd2, 0xb8, 0x9a, 0xfe, 0xab, 0xe8, 0xce, 0x86, 0xb7, 0x44, 0xe5, 0xa6, 0x1b, 0xd4, 0xf4, 0x2d, - 0x78, 0x27, 0x40, 0xa3, 0xa2, 0xe0, 0x3a, 0x2e, 0xc2, 0xe1, 0xb0, 0xbc, 0xbe, 0x24, 0x60, 0x97, 0xb9, 0xe2, 0x71, - 0x15, 0x05, 0x42, 0x0e, 0xd5, 0xcf, 0x40, 0x45, 0x02, 0x0b, 0x10, 0xca, 0x08, 0xfe, 0x0b, 0x6a, 0xfa, 0x4e, 0xb2, - 0x6d, 0x30, 0xbc, 0xe1, 0xe7, 0x9f, 0xb2, 0x6a, 0xa8, 0x44, 0x8b, 0x37, 0x82, 0xc2, 0x0f, 0xf8, 0xeb, 0xaa, 0x8e, - 0xfe, 0x05, 0x6e, 0xdc, 0x4d, 0x0d, 0xfb, 0x3b, 0xe9, 0x39, 0xb4, 0xc9, 0x79, 0xb6, 0x98, 0xb6, 0x0e, 0xf4, 0xb7, - 0x92, 0x54, 0xf3, 0x6c, 0x10, 0x0c, 0x83, 0x01, 0x5f, 0xb0, 0xb7, 0x72, 0xce, 0x3d, 0xf3, 0xa9, 0x53, 0xe9, 0x4f, - 0xf3, 0x2c, 0x1b, 0x80, 0x6f, 0x0a, 0xf2, 0x23, 0x87, 0xff, 0x35, 0x1f, 0xa2, 0xf0, 0x70, 0xf0, 0xe0, 0x90, 0xcc, - 0x82, 0xd5, 0x2d, 0x7a, 0x74, 0x46, 0x41, 0x26, 0x96, 0xbc, 0xc8, 0x2a, 0x6f, 0xa9, 0x5c, 0xaf, 0xdb, 0x5e, 0x1e, - 0x77, 0x9e, 0xcd, 0xab, 0x58, 0x04, 0xea, 0x9c, 0x03, 0xc5, 0x1b, 0xca, 0x9e, 0xca, 0xa6, 0x84, 0x54, 0x1b, 0xf2, - 0x86, 0xe5, 0x80, 0x05, 0xc7, 0xbd, 0xe1, 0xf0, 0x20, 0x18, 0x38, 0x75, 0xee, 0x20, 0x38, 0x18, 0x0e, 0x4f, 0x02, - 0x77, 0x1f, 0xca, 0x46, 0xee, 0xce, 0x48, 0x0b, 0xf6, 0x57, 0x11, 0x96, 0x14, 0xc4, 0x63, 0x52, 0x8b, 0xbf, 0x34, - 0xb8, 0xcc, 0x00, 0xa0, 0x8f, 0x94, 0x04, 0xcc, 0xc0, 0xca, 0x0c, 0x20, 0x54, 0x39, 0x8d, 0xd9, 0x2d, 0x30, 0x8f, - 0xc0, 0x31, 0x2b, 0x98, 0x2c, 0x40, 0x2c, 0x09, 0x70, 0xee, 0x82, 0x28, 0xd6, 0x85, 0x9c, 0x42, 0x10, 0x00, 0xfc, - 0x49, 0x4c, 0x29, 0x98, 0xa4, 0x63, 0x37, 0x82, 0x20, 0x8e, 0xcf, 0x6e, 0x44, 0x6b, 0x72, 0x96, 0xe8, 0x60, 0x46, - 0x12, 0x60, 0x43, 0x0c, 0x0c, 0x1f, 0xdc, 0xcf, 0x41, 0xe9, 0x61, 0xf5, 0x4e, 0xc8, 0x05, 0x6f, 0xb8, 0x63, 0xa1, - 0x6e, 0xe0, 0xea, 0x09, 0x07, 0xc1, 0x86, 0x6b, 0x16, 0x60, 0x54, 0x15, 0xeb, 0xb2, 0xe2, 0xe9, 0xc7, 0xcd, 0x0a, - 0x62, 0x01, 0xe2, 0x80, 0xbe, 0x93, 0x79, 0x96, 0x6c, 0x42, 0x67, 0xcf, 0xb5, 0x55, 0xe9, 0x2f, 0x3f, 0xbe, 0xfe, - 0x29, 0x02, 0x91, 0x63, 0x6d, 0x28, 0xfd, 0x86, 0xe3, 0xd9, 0xe4, 0x47, 0xbc, 0xf2, 0x37, 0xf6, 0x86, 0xdb, 0xd3, - 0xa3, 0xdf, 0x87, 0xba, 0xe9, 0x86, 0xcf, 0x36, 0x7c, 0xe4, 0x8a, 0x43, 0x75, 0x85, 0x67, 0x97, 0xb5, 0xf6, 0x8d, - 0x90, 0xee, 0x9f, 0x67, 0xca, 0x1b, 0xf3, 0xa3, 0x1d, 0x0c, 0x83, 0x60, 0xaa, 0x85, 0x92, 0x10, 0x85, 0x84, 0x29, - 0x01, 0x43, 0x74, 0xa0, 0x97, 0xd5, 0x14, 0x39, 0x37, 0x35, 0xb2, 0xf0, 0x7e, 0xc0, 0xb4, 0xd0, 0xa1, 0x91, 0x43, - 0xf9, 0xc1, 0xe1, 0x84, 0x31, 0x0b, 0xbf, 0x55, 0xc2, 0xf4, 0xab, 0x45, 0xe5, 0x1c, 0x44, 0x0f, 0xc0, 0x18, 0x57, - 0xf0, 0x02, 0xba, 0xc2, 0x3e, 0xad, 0x55, 0x94, 0x10, 0x04, 0xd3, 0x43, 0x0e, 0xd0, 0xc3, 0x2e, 0x68, 0x59, 0x59, - 0xaa, 0x5b, 0x95, 0xb3, 0x54, 0x51, 0x97, 0xa1, 0xac, 0x8c, 0x15, 0x06, 0x7e, 0xc9, 0x7e, 0x29, 0xd0, 0xb3, 0x7c, - 0x2a, 0xba, 0xe0, 0x85, 0x50, 0x82, 0xe5, 0xba, 0xde, 0x89, 0x40, 0xd4, 0xf9, 0xa1, 0x77, 0xd5, 0xd7, 0xb8, 0x7e, - 0x3c, 0x7d, 0x2d, 0x53, 0xae, 0x4d, 0x28, 0x34, 0x9f, 0x2f, 0x7d, 0xc5, 0x44, 0xc1, 0x3e, 0x40, 0xbf, 0xda, 0x36, - 0xfa, 0xec, 0x7a, 0xad, 0x37, 0x83, 0x12, 0x1d, 0xf3, 0x1a, 0x05, 0xd7, 0x4a, 0xa1, 0x60, 0xb4, 0xb7, 0xf1, 0x17, - 0x38, 0x72, 0xab, 0xdb, 0x43, 0xef, 0xb7, 0x2a, 0xbe, 0x7c, 0x83, 0xbe, 0x9d, 0xf6, 0xe7, 0xa8, 0x92, 0xbf, 0xac, - 0x56, 0xe0, 0x43, 0x05, 0x91, 0x56, 0x2c, 0x4e, 0x2f, 0xd4, 0xf3, 0xe1, 0xdd, 0xe9, 0x1b, 0xf0, 0xa3, 0xc4, 0xdf, - 0xbf, 0xfe, 0x18, 0xd4, 0x64, 0x1a, 0xcf, 0x0a, 0xf3, 0xa1, 0xcd, 0x01, 0xa1, 0x5a, 0x5c, 0x9a, 0x7d, 0x3f, 0x8b, - 0x9b, 0xec, 0xbb, 0x66, 0xeb, 0x69, 0xd1, 0x44, 0x92, 0x32, 0xdc, 0x3e, 0x18, 0x10, 0xe8, 0x03, 0x44, 0x71, 0xf6, - 0x05, 0x8d, 0x21, 0xcd, 0x67, 0xf6, 0xfd, 0x08, 0x81, 0xaf, 0xf6, 0x42, 0xaa, 0x71, 0x85, 0x45, 0xa3, 0x87, 0x7c, - 0xc6, 0x23, 0x65, 0x58, 0xf4, 0x1e, 0x13, 0x88, 0x33, 0x9c, 0x56, 0xef, 0x11, 0x03, 0x1a, 0xef, 0x06, 0x5a, 0xf6, - 0x10, 0x65, 0xd4, 0x65, 0x6f, 0x58, 0x7c, 0xbf, 0x5e, 0x87, 0x99, 0xb5, 0xbc, 0x1c, 0xc2, 0xdf, 0x40, 0x1b, 0x80, - 0x53, 0x8e, 0x2c, 0x5f, 0x65, 0x36, 0xba, 0x5a, 0x62, 0x7a, 0x13, 0x41, 0x6c, 0x22, 0x9d, 0x0e, 0x6b, 0x57, 0xa7, - 0xea, 0x5d, 0xed, 0x7c, 0x26, 0x7a, 0x15, 0x68, 0xe5, 0xda, 0xf6, 0x78, 0x08, 0xff, 0xa9, 0xa5, 0x15, 0x36, 0xc2, - 0x9e, 0x8b, 0x2f, 0x3c, 0xc7, 0xe6, 0x04, 0x34, 0xb8, 0x92, 0x29, 0x00, 0x67, 0x69, 0x35, 0x1a, 0x35, 0xc2, 0x3e, - 0x2b, 0xe7, 0x73, 0xd8, 0x5a, 0x88, 0xa7, 0x05, 0xe0, 0xc0, 0x4d, 0x4c, 0x4e, 0xde, 0x8d, 0xc9, 0x39, 0xfd, 0xa4, - 0xe0, 0xbe, 0x83, 0xb3, 0x72, 0x19, 0xa7, 0xf2, 0x06, 0xb0, 0x29, 0x03, 0x3f, 0x15, 0x4b, 0xf5, 0x12, 0x92, 0x25, - 0x4f, 0x3e, 0xa1, 0xd5, 0x46, 0x1a, 0x00, 0x57, 0x39, 0x35, 0x96, 0x7b, 0x0a, 0x34, 0xd5, 0x95, 0xa2, 0x12, 0xe2, - 0xaa, 0x8a, 0x93, 0xe5, 0x07, 0x4c, 0x0d, 0xb7, 0xd0, 0x8b, 0x28, 0x90, 0x2b, 0x2e, 0x80, 0xa4, 0xe7, 0xec, 0x1f, - 0x99, 0xc6, 0x5e, 0x7f, 0x20, 0x51, 0xc0, 0xa4, 0x51, 0x94, 0xb1, 0x52, 0xf6, 0x4a, 0x9a, 0xe8, 0x77, 0x41, 0x50, - 0xbb, 0x97, 0x7f, 0x41, 0xdd, 0x4f, 0xa1, 0x15, 0x61, 0x03, 0xbc, 0x50, 0x83, 0x1f, 0xa6, 0x76, 0xc9, 0x79, 0x40, - 0x86, 0xce, 0xfb, 0xac, 0xb6, 0x5b, 0xfd, 0xe9, 0x12, 0xb0, 0x5e, 0x53, 0xe3, 0x53, 0x18, 0x26, 0xc4, 0xc4, 0x4a, - 0xb6, 0xca, 0x4a, 0xbb, 0xa1, 0x4c, 0x3b, 0xe9, 0x92, 0x79, 0x2d, 0x9c, 0xe6, 0x3d, 0xc6, 0x96, 0x23, 0x95, 0xbb, - 0xdf, 0x0f, 0xcd, 0x4f, 0x96, 0xd3, 0x07, 0x3a, 0x84, 0xb5, 0x37, 0x1e, 0x34, 0x27, 0x5a, 0x5d, 0xd5, 0xd1, 0x0f, - 0xe8, 0x00, 0xcc, 0xb4, 0x45, 0xa8, 0x74, 0xc1, 0xb7, 0x7d, 0x25, 0x2a, 0x2e, 0x49, 0x58, 0x2a, 0x09, 0xec, 0xec, - 0xa6, 0x64, 0x67, 0x1b, 0x10, 0xcf, 0x70, 0xd7, 0xd3, 0x62, 0x27, 0xa4, 0x09, 0x6f, 0x71, 0x90, 0x80, 0xa8, 0x43, - 0x55, 0x97, 0x90, 0xad, 0x31, 0x74, 0xf1, 0x2f, 0x4a, 0x61, 0xc2, 0x5a, 0x26, 0x55, 0x89, 0x09, 0x0a, 0x55, 0xee, - 0xb7, 0x08, 0x2c, 0x51, 0xb0, 0x03, 0xd8, 0x7b, 0x37, 0xea, 0x66, 0xd4, 0x54, 0x75, 0xea, 0x25, 0xf8, 0x38, 0xcd, - 0xba, 0x0a, 0x32, 0x0b, 0xbb, 0x2a, 0xd6, 0x3c, 0xd0, 0xb1, 0xba, 0x94, 0x31, 0x71, 0x97, 0x16, 0x19, 0xe2, 0x23, - 0x63, 0x6c, 0x61, 0x0d, 0x47, 0xda, 0x1e, 0x37, 0x3d, 0x41, 0xe8, 0x27, 0x6c, 0x28, 0x81, 0x9b, 0xce, 0xf6, 0xd4, - 0x34, 0xf3, 0x01, 0x11, 0x87, 0x01, 0x05, 0x92, 0x8d, 0x43, 0x9a, 0x23, 0x7d, 0x41, 0xd2, 0x84, 0x81, 0xb2, 0x15, - 0xcf, 0x09, 0xb2, 0xa2, 0xd0, 0xb3, 0x75, 0x55, 0x43, 0xfc, 0x5c, 0x86, 0x39, 0x5a, 0x72, 0x2a, 0x3c, 0x4d, 0x90, - 0x89, 0xdd, 0xd1, 0x36, 0x33, 0x19, 0x8e, 0x92, 0x05, 0xe6, 0x57, 0x10, 0x25, 0xee, 0x4c, 0xb3, 0x2a, 0x07, 0xe3, - 0x02, 0x16, 0x68, 0xe5, 0x7b, 0x50, 0x37, 0xd6, 0xd0, 0x56, 0xc3, 0x32, 0xbb, 0xfd, 0x09, 0xf6, 0x6b, 0xed, 0xb4, - 0x2e, 0x53, 0x2c, 0x2f, 0x53, 0x88, 0xf6, 0x42, 0xe6, 0x37, 0x8a, 0x44, 0xf7, 0x8a, 0x30, 0x24, 0xac, 0xa3, 0xec, - 0x49, 0x9b, 0x1a, 0x40, 0x4f, 0xbd, 0x00, 0xf0, 0x9d, 0x6b, 0x19, 0x76, 0x91, 0xee, 0xaf, 0x0a, 0xc6, 0xa5, 0x1b, - 0x04, 0x29, 0x7a, 0x93, 0x82, 0x39, 0xaf, 0x47, 0x49, 0xbd, 0x39, 0x6d, 0x99, 0x51, 0x75, 0x54, 0x84, 0x94, 0x13, - 0xfc, 0x27, 0xaf, 0xa4, 0x26, 0x36, 0x61, 0x82, 0x07, 0x3e, 0xcc, 0x33, 0x6c, 0xe0, 0xdd, 0xee, 0x34, 0x0d, 0x93, - 0x36, 0xdb, 0x90, 0x82, 0xb4, 0xc2, 0xc4, 0x09, 0x81, 0xca, 0x5e, 0xe1, 0x7e, 0xc1, 0x76, 0xd2, 0x14, 0x3c, 0x08, - 0x1b, 0x0d, 0x4c, 0xdc, 0xea, 0x12, 0x60, 0x34, 0x13, 0x2e, 0xa9, 0x76, 0x76, 0xd2, 0xc2, 0xfa, 0xf6, 0xba, 0xbc, - 0xb0, 0x7d, 0xd0, 0xb1, 0xd4, 0xba, 0x86, 0x07, 0x9a, 0xd7, 0xec, 0xe2, 0x8a, 0x69, 0x9a, 0x68, 0xac, 0x87, 0x94, - 0x25, 0xc7, 0xba, 0x9e, 0xae, 0x70, 0xb5, 0xcc, 0x34, 0xd0, 0xbd, 0xc4, 0x0b, 0x3d, 0xe0, 0x83, 0x87, 0x2b, 0x12, - 0x5d, 0x60, 0xb3, 0xd9, 0xaa, 0x26, 0xd3, 0xfc, 0xae, 0x6c, 0xb9, 0x09, 0x90, 0x67, 0xa9, 0x6f, 0xee, 0x93, 0x63, - 0x4d, 0xdb, 0xfc, 0x24, 0xc0, 0x35, 0xf7, 0x0a, 0x48, 0x3a, 0x96, 0xa0, 0x8b, 0xf7, 0xe9, 0x0f, 0x22, 0x35, 0x53, - 0x41, 0xef, 0x9c, 0x2f, 0x52, 0x37, 0xbf, 0x00, 0xdb, 0xa8, 0xad, 0x35, 0xcd, 0x5a, 0x87, 0x89, 0xb2, 0xb0, 0x46, - 0x16, 0x72, 0x09, 0x3e, 0x98, 0xfb, 0x4d, 0x9d, 0x3e, 0xef, 0x20, 0xc2, 0x7e, 0x17, 0x3d, 0x1e, 0x61, 0xac, 0x58, - 0x83, 0xc4, 0xb0, 0x0a, 0x6b, 0xda, 0x5c, 0x0e, 0x51, 0x4e, 0xcd, 0x92, 0x89, 0x96, 0xd4, 0xa7, 0x14, 0x51, 0x0a, - 0xe6, 0xc6, 0xd3, 0xb2, 0x61, 0x4a, 0x88, 0x90, 0x15, 0xd2, 0x01, 0xd5, 0x5a, 0x68, 0xa9, 0x26, 0x08, 0x78, 0xe8, - 0x65, 0xa1, 0x31, 0x05, 0xd1, 0x47, 0x64, 0xb8, 0x11, 0x47, 0x46, 0xf7, 0xc7, 0x28, 0x26, 0x10, 0xba, 0xdb, 0xcb, - 0x0b, 0xab, 0x4f, 0xcb, 0xb6, 0x3a, 0x88, 0x6b, 0x4c, 0x93, 0x3b, 0x08, 0x6a, 0x8c, 0x82, 0x36, 0xa7, 0x1b, 0xfd, - 0x77, 0x11, 0xfa, 0x76, 0xe1, 0xd8, 0x8d, 0x82, 0x48, 0x88, 0x48, 0xeb, 0x35, 0x15, 0x03, 0xd4, 0xce, 0x63, 0x17, - 0xb1, 0x4a, 0x77, 0x0b, 0x51, 0xde, 0xa8, 0xac, 0x5f, 0xaf, 0x43, 0xb2, 0xdb, 0x61, 0x59, 0xe0, 0xcb, 0xfe, 0x74, - 0x7d, 0x07, 0x04, 0xfa, 0x83, 0xf5, 0x17, 0x21, 0xd0, 0x9f, 0x65, 0x5f, 0x03, 0x81, 0xfe, 0x60, 0xfd, 0x3f, 0x0d, - 0x81, 0xfe, 0x74, 0xed, 0x41, 0xa0, 0xab, 0xc1, 0xf8, 0x67, 0xc1, 0x82, 0xb7, 0x6f, 0x02, 0xfa, 0x4c, 0xb2, 0xe0, - 0xed, 0x8b, 0x17, 0x9e, 0x30, 0xfd, 0x63, 0xa6, 0x91, 0xfc, 0x8d, 0x2c, 0x18, 0x71, 0x5b, 0xe0, 0x15, 0x6a, 0x9d, - 0x7c, 0xa0, 0xa2, 0x0c, 0x80, 0xe8, 0xcb, 0xdf, 0xb2, 0x6a, 0x19, 0x06, 0x87, 0x01, 0x99, 0x39, 0x48, 0xd0, 0xe1, - 0xa4, 0x71, 0x7b, 0xfb, 0x45, 0x34, 0x84, 0x3a, 0x36, 0xf2, 0x00, 0x7c, 0xe5, 0x72, 0xbd, 0xf5, 0x6f, 0x88, 0xf8, - 0xc9, 0xcc, 0x82, 0x8e, 0x1e, 0x06, 0x04, 0x3c, 0x96, 0x32, 0x0f, 0x81, 0x73, 0xee, 0x87, 0x84, 0xfe, 0xb1, 0xf0, - 0x6c, 0x8b, 0x7e, 0x11, 0x61, 0x05, 0x3e, 0x77, 0x7f, 0xad, 0xf9, 0x59, 0x96, 0x12, 0x27, 0x0f, 0xe5, 0x22, 0x91, - 0x29, 0xff, 0xe5, 0xfd, 0x2b, 0x8b, 0x3c, 0x1e, 0x2a, 0xe8, 0x25, 0x82, 0x21, 0x8d, 0x53, 0x7e, 0x9d, 0x25, 0x7c, - 0xf6, 0xc7, 0x83, 0x6d, 0x67, 0x46, 0xf5, 0x9a, 0xd4, 0x87, 0x7f, 0x44, 0x41, 0xa0, 0xc7, 0xe0, 0x8f, 0x07, 0xdb, - 0xac, 0x3e, 0x7c, 0xb0, 0xad, 0x46, 0xa9, 0x04, 0x78, 0x6f, 0xf8, 0x2d, 0xeb, 0x07, 0xdb, 0x12, 0x7e, 0xf0, 0xfa, - 0x0f, 0x0f, 0x98, 0xcd, 0x36, 0xc8, 0xeb, 0x83, 0x55, 0x5e, 0x39, 0x4c, 0xd0, 0x7b, 0x0a, 0x16, 0xa6, 0x50, 0x87, - 0x47, 0xb5, 0xf6, 0xe4, 0x7e, 0x53, 0xdd, 0x75, 0x42, 0xe0, 0x1a, 0xe9, 0x06, 0x0e, 0xa1, 0xb2, 0x04, 0x3b, 0xe9, - 0xe8, 0x94, 0x20, 0xa6, 0xe6, 0xc3, 0x40, 0xd9, 0xfa, 0x7a, 0xc1, 0x8a, 0x5d, 0x33, 0x31, 0xbe, 0xd3, 0x18, 0xd8, - 0x70, 0xd1, 0xd5, 0x62, 0xce, 0xfe, 0x30, 0x3d, 0xde, 0xaf, 0x42, 0x12, 0xc4, 0xc8, 0xf6, 0xfb, 0xc4, 0xeb, 0x59, - 0xca, 0xab, 0x38, 0xcb, 0x59, 0x9c, 0xe7, 0x7f, 0xa0, 0x2c, 0xe2, 0xc7, 0xaf, 0x02, 0xdd, 0x1f, 0x8d, 0x46, 0x71, - 0x71, 0x89, 0x57, 0x7f, 0x43, 0x6e, 0x11, 0x16, 0x3b, 0xe3, 0xa5, 0x0d, 0xac, 0xb2, 0x8c, 0xcb, 0x33, 0x1d, 0xd1, - 0xa8, 0xb4, 0x04, 0xbb, 0x5c, 0xca, 0x9b, 0x33, 0x88, 0xee, 0x60, 0x29, 0x78, 0x8c, 0x03, 0xa8, 0xee, 0x4d, 0x3a, - 0xec, 0xf2, 0xe9, 0x5a, 0xbf, 0x3b, 0x8f, 0x4b, 0xfe, 0x2e, 0xae, 0x96, 0x0c, 0xf6, 0x82, 0xa6, 0xea, 0x85, 0x5c, - 0xaf, 0x5c, 0x25, 0x67, 0x6b, 0xf1, 0x49, 0xc8, 0x1b, 0xa1, 0x68, 0xef, 0x19, 0xbf, 0x86, 0x16, 0xb1, 0x2d, 0xea, - 0xac, 0x04, 0x4f, 0x2a, 0x8f, 0x13, 0x57, 0xb1, 0x00, 0x32, 0x6a, 0xa2, 0x01, 0x74, 0xe4, 0xa0, 0xa1, 0xdd, 0x6b, - 0xda, 0xb1, 0xdc, 0xa8, 0x2c, 0x32, 0xb0, 0x84, 0x7d, 0x0e, 0xa5, 0x03, 0x62, 0x3b, 0x84, 0x0b, 0x81, 0xab, 0x27, - 0x5e, 0x8d, 0x1a, 0x88, 0x3d, 0xb4, 0xf4, 0xdd, 0x85, 0x14, 0xab, 0x45, 0x30, 0xb0, 0x24, 0xac, 0xee, 0xb3, 0x2c, - 0x05, 0x30, 0xde, 0x2c, 0xd5, 0x9a, 0xf3, 0xc6, 0xc0, 0xe1, 0x85, 0x1b, 0x9d, 0x88, 0xd1, 0x1f, 0xda, 0x2d, 0x53, - 0xc6, 0x98, 0xb2, 0x41, 0x2b, 0x7a, 0x28, 0x1a, 0x93, 0xbe, 0xa6, 0x5a, 0x87, 0x98, 0xf3, 0x4c, 0xf4, 0xb6, 0xca, - 0xb9, 0x67, 0x0e, 0xe6, 0x61, 0x7e, 0xf9, 0x80, 0x16, 0x8a, 0x79, 0xcf, 0xc4, 0xfa, 0x8a, 0x17, 0x59, 0x72, 0xb6, - 0xcc, 0xca, 0x4a, 0x16, 0x9b, 0xc5, 0x34, 0xd6, 0x08, 0x93, 0x9a, 0x53, 0xa2, 0x5f, 0xf7, 0x1d, 0x78, 0x29, 0xaa, - 0x60, 0x26, 0xc3, 0x27, 0x63, 0x52, 0x6b, 0xcb, 0x79, 0xe8, 0x1e, 0xb5, 0xbf, 0x75, 0xaf, 0x5d, 0x82, 0xda, 0x44, - 0xee, 0xd9, 0xf6, 0x92, 0x36, 0x9d, 0x20, 0xda, 0x4d, 0xa0, 0x66, 0x9d, 0x15, 0xfc, 0xaf, 0x35, 0x37, 0xa1, 0x10, - 0x42, 0x07, 0xf3, 0x1d, 0x96, 0xc6, 0x0a, 0x46, 0xd1, 0x6f, 0x55, 0xb7, 0x22, 0xcd, 0xad, 0x17, 0xaa, 0x0d, 0x84, - 0xa8, 0xab, 0x64, 0x9a, 0x3e, 0x47, 0x44, 0x77, 0x10, 0xa1, 0xe0, 0xc6, 0xb3, 0x01, 0xc1, 0xba, 0xd6, 0xd6, 0x5c, - 0x2e, 0x66, 0xf7, 0xbe, 0x1d, 0x0c, 0xa2, 0x7b, 0xdf, 0xb3, 0xc9, 0x3d, 0x2b, 0x77, 0x2e, 0x17, 0xc7, 0xc6, 0x18, - 0x73, 0x8a, 0xb6, 0x2d, 0xe1, 0xbb, 0x75, 0xd8, 0xdc, 0x0c, 0x70, 0x1a, 0x6e, 0xaf, 0x78, 0xb5, 0x94, 0x69, 0x14, - 0xfc, 0xf8, 0xfc, 0x63, 0x60, 0x14, 0xd9, 0xb1, 0x86, 0x30, 0xd2, 0xba, 0x9d, 0x5c, 0x5e, 0x86, 0x31, 0xc4, 0xb2, - 0x1e, 0xc9, 0x4f, 0x7b, 0x31, 0x3f, 0xff, 0x78, 0xf9, 0xf1, 0xe3, 0xbb, 0x03, 0x54, 0xff, 0xf4, 0x0e, 0x3e, 0x28, - 0x2c, 0x81, 0x83, 0x07, 0xdb, 0x58, 0x2b, 0xdc, 0xeb, 0x3f, 0xec, 0xc9, 0x15, 0xb7, 0xd4, 0xe5, 0xc6, 0xad, 0xce, - 0xab, 0xa2, 0x35, 0x8e, 0xb1, 0xd3, 0x69, 0xfb, 0x99, 0x95, 0xae, 0x29, 0x40, 0x4d, 0x8a, 0xaa, 0x39, 0x0a, 0x28, - 0xe4, 0x85, 0xb8, 0x0b, 0x61, 0x75, 0xc7, 0xc6, 0xab, 0xba, 0x36, 0x9e, 0x2c, 0xaa, 0x4c, 0x5c, 0x9e, 0x21, 0x2d, - 0xf8, 0x9a, 0x0d, 0x68, 0x63, 0xbc, 0x29, 0xea, 0xe1, 0xed, 0xb4, 0x82, 0x9d, 0x14, 0x4d, 0xe0, 0x32, 0x6d, 0xa2, - 0xbb, 0xd5, 0xb6, 0x2d, 0xa3, 0xd1, 0xa8, 0xac, 0xa7, 0xfe, 0xc7, 0xc6, 0x7e, 0xc4, 0x4f, 0x53, 0xb0, 0x6e, 0xc0, - 0x11, 0xc1, 0xce, 0x35, 0xed, 0xbb, 0x41, 0x29, 0xca, 0x71, 0xd2, 0x4a, 0x98, 0x0d, 0x27, 0xd1, 0x84, 0xd8, 0x68, - 0x13, 0x9a, 0xa2, 0xfd, 0x38, 0x7a, 0xfe, 0xe6, 0xe3, 0xab, 0x8f, 0xff, 0x3e, 0x7b, 0x7a, 0xfa, 0xf1, 0xf9, 0x8f, - 0x6f, 0xdf, 0xbf, 0x7a, 0xfe, 0x01, 0xcf, 0x0b, 0x0d, 0x5f, 0x19, 0x6e, 0xb5, 0x8d, 0x74, 0xb3, 0xac, 0x48, 0xd4, - 0xa4, 0xd9, 0x14, 0x85, 0x1f, 0x85, 0x99, 0x6d, 0x91, 0xbf, 0xbc, 0x79, 0xf6, 0xfc, 0xc5, 0xab, 0x37, 0xcf, 0x9f, - 0xb5, 0xbf, 0x1e, 0x4e, 0x6a, 0x52, 0xbb, 0x99, 0xd3, 0xf1, 0x52, 0xcc, 0xad, 0x00, 0x70, 0x06, 0x2c, 0xd9, 0xca, - 0x80, 0x6c, 0x99, 0x71, 0xec, 0xa0, 0x59, 0x88, 0x3d, 0xe6, 0xd3, 0xac, 0x4a, 0x8d, 0x64, 0xbf, 0x5f, 0xb9, 0x73, - 0x3f, 0xd3, 0x7b, 0x6f, 0xb7, 0x7b, 0xbb, 0x06, 0x27, 0x76, 0x0d, 0x03, 0x0c, 0x86, 0xad, 0x54, 0xbd, 0x89, 0x4a, - 0x6a, 0x0b, 0x89, 0x2a, 0xaa, 0x82, 0x2d, 0x9c, 0x25, 0x71, 0xc5, 0x2f, 0x65, 0xb1, 0x89, 0xb2, 0x51, 0x2b, 0x85, - 0x36, 0x16, 0x43, 0x14, 0xa2, 0x85, 0xb1, 0x9f, 0x44, 0x7a, 0x6a, 0xf7, 0x8b, 0xa8, 0x63, 0x84, 0xe7, 0x2e, 0x8e, - 0x40, 0xbb, 0x60, 0xb2, 0xd8, 0xed, 0x3a, 0x06, 0xb0, 0x93, 0x12, 0x46, 0xf3, 0x4c, 0x91, 0xc8, 0x45, 0x3d, 0x95, - 0x78, 0xf0, 0xa9, 0x53, 0x8d, 0x99, 0x83, 0xf0, 0x54, 0x31, 0xd4, 0xc0, 0xc7, 0x7a, 0xaf, 0x4d, 0xc8, 0x99, 0xff, - 0xaf, 0xbd, 0xa7, 0xdd, 0x6e, 0x13, 0x49, 0xf6, 0xff, 0x3c, 0x05, 0x26, 0xd9, 0x04, 0x12, 0xc0, 0x20, 0x59, 0xb6, - 0x22, 0x19, 0x79, 0x26, 0x89, 0x33, 0x1f, 0xeb, 0x99, 0xcc, 0x49, 0x3c, 0xd9, 0x7b, 0xd7, 0xeb, 0x63, 0x21, 0xa9, - 0x25, 0xb1, 0x41, 0xa0, 0x03, 0xc8, 0x1f, 0xa3, 0xb0, 0xcf, 0xb2, 0x8f, 0x70, 0x9f, 0x61, 0x9f, 0xec, 0x9e, 0xaa, - 0xea, 0x86, 0x06, 0x81, 0x2c, 0x4f, 0x32, 0xb3, 0x7b, 0xcf, 0xb9, 0x67, 0x26, 0x89, 0x68, 0x9a, 0xee, 0xea, 0xaf, - 0xaa, 0xea, 0xfa, 0x2c, 0x53, 0x4a, 0xbb, 0x82, 0x7f, 0x85, 0x15, 0x72, 0xa5, 0x94, 0xb6, 0x1c, 0x88, 0x39, 0xdd, - 0x01, 0xae, 0x1a, 0x58, 0x15, 0x8a, 0x7b, 0x32, 0x98, 0x09, 0x56, 0x76, 0x9d, 0x98, 0x87, 0x79, 0x8f, 0x36, 0xbc, - 0x11, 0xb8, 0x60, 0x7a, 0xd8, 0x50, 0x6b, 0xd2, 0xf3, 0x4a, 0xa1, 0x30, 0xe3, 0xf2, 0xa4, 0x1e, 0x7b, 0xe5, 0x67, - 0xd8, 0xd2, 0x95, 0x2a, 0xe0, 0x1b, 0x53, 0xa9, 0x04, 0x52, 0xb0, 0xe0, 0x84, 0xba, 0xb7, 0xd2, 0xe8, 0x2c, 0xba, - 0x11, 0x82, 0xe3, 0x63, 0xaf, 0xa6, 0x10, 0xcf, 0x49, 0x6f, 0x7c, 0x1c, 0xd0, 0x0f, 0x27, 0x6b, 0xa0, 0x00, 0x59, - 0x31, 0xc1, 0x39, 0xdb, 0x3a, 0xa4, 0xcb, 0xd4, 0xd5, 0xe3, 0xb5, 0xd8, 0x72, 0xd9, 0xd0, 0xcf, 0xd3, 0xc2, 0x96, - 0x58, 0x8e, 0x8c, 0x4f, 0xbd, 0x1c, 0x85, 0xb4, 0xa6, 0x1a, 0xdf, 0x1f, 0xae, 0x5f, 0xcb, 0xb7, 0x58, 0xf4, 0xc8, - 0x88, 0xa6, 0xd7, 0x57, 0x61, 0xb7, 0x6c, 0xac, 0xd5, 0x01, 0x46, 0x82, 0x27, 0x31, 0x04, 0x0c, 0xcc, 0x8c, 0xa8, - 0xff, 0xdb, 0xb8, 0x8a, 0xfa, 0xd1, 0xfe, 0x2e, 0x47, 0xfe, 0x3f, 0xbf, 0x7d, 0x7f, 0x0e, 0x7a, 0x2d, 0x0f, 0x15, - 0xd1, 0x6b, 0x95, 0xdb, 0xb0, 0x98, 0xa0, 0x29, 0x52, 0x7b, 0xaa, 0xb7, 0x04, 0xea, 0x8c, 0x37, 0x86, 0xfd, 0x5b, - 0xf3, 0xe6, 0xe6, 0xc6, 0x04, 0x8b, 0x56, 0x73, 0x15, 0x07, 0xc4, 0x1d, 0x4e, 0xd4, 0x4c, 0x20, 0x75, 0x56, 0x41, - 0xea, 0x10, 0x0e, 0x97, 0xe7, 0x53, 0x79, 0x3f, 0x8f, 0x6e, 0xbe, 0x09, 0x02, 0x59, 0x6c, 0x23, 0x98, 0x38, 0x2e, - 0xc9, 0x28, 0x21, 0x03, 0x0d, 0xb4, 0x4f, 0x96, 0x9f, 0x5c, 0x71, 0x7b, 0x81, 0xc9, 0xd5, 0xe8, 0xee, 0x8a, 0xeb, - 0x24, 0xf2, 0x78, 0xc4, 0xef, 0x87, 0xc7, 0x13, 0xff, 0x5a, 0x41, 0x4e, 0xd3, 0x55, 0xc1, 0x99, 0x2b, 0x60, 0xa3, - 0x55, 0x9a, 0x46, 0xa1, 0x19, 0x47, 0x37, 0xea, 0xe0, 0x98, 0x1e, 0x44, 0x05, 0x8f, 0x1e, 0x55, 0xe5, 0xeb, 0x71, - 0xe0, 0x8f, 0x3f, 0xba, 0xea, 0xe3, 0xb5, 0xef, 0x0e, 0x2a, 0xfc, 0xa4, 0x9d, 0xa9, 0x03, 0x80, 0x55, 0xf9, 0x26, - 0x08, 0x8e, 0xf7, 0xe9, 0x8b, 0xc1, 0xf1, 0xfe, 0xc4, 0xbf, 0x1e, 0x48, 0xa9, 0x61, 0xb8, 0xde, 0xd4, 0xe5, 0x21, - 0x38, 0x73, 0x4b, 0xb3, 0x04, 0x63, 0x3a, 0x8c, 0x99, 0x56, 0x5c, 0x7e, 0x21, 0xd6, 0x0c, 0xc1, 0xab, 0x8d, 0x51, - 0x9c, 0x1e, 0xc0, 0x55, 0xef, 0xd3, 0x27, 0x2d, 0xb7, 0x43, 0x9d, 0x4b, 0x41, 0xda, 0x50, 0xcd, 0x87, 0x55, 0x0c, - 0x8c, 0x34, 0xa3, 0x6b, 0x22, 0x94, 0x5c, 0xa0, 0x1b, 0xe3, 0xcc, 0xc0, 0x0c, 0x3b, 0xde, 0x12, 0x34, 0x8e, 0xfc, - 0xa7, 0x74, 0x23, 0x1e, 0x43, 0x56, 0x6d, 0x09, 0x89, 0xeb, 0x92, 0xce, 0x85, 0x4e, 0x21, 0x8f, 0x13, 0x08, 0xca, - 0x12, 0xec, 0x87, 0xf4, 0x20, 0x5a, 0xa0, 0x43, 0x56, 0xb7, 0x3c, 0x38, 0x8f, 0x97, 0x89, 0x3c, 0x6a, 0x62, 0x5e, - 0x4e, 0x4a, 0x2b, 0xd4, 0xab, 0xae, 0x97, 0x88, 0x1a, 0xb9, 0x97, 0x34, 0x2d, 0x19, 0xe8, 0xf0, 0xb4, 0xd4, 0xa8, - 0xd0, 0x5c, 0xf0, 0xea, 0x93, 0x14, 0x47, 0xcc, 0xd0, 0x2e, 0x12, 0x23, 0xba, 0x2c, 0xe8, 0x54, 0x42, 0x88, 0xb2, - 0x17, 0x65, 0x45, 0x00, 0x67, 0x5a, 0xf5, 0xc1, 0xe3, 0x75, 0x88, 0x84, 0x2d, 0x71, 0x07, 0xe5, 0x7d, 0x90, 0x7a, - 0x23, 0x93, 0x36, 0xb3, 0xaa, 0x7c, 0x3d, 0x19, 0x05, 0xf9, 0x62, 0xd3, 0x21, 0x98, 0x7b, 0xe1, 0x24, 0x60, 0xe7, - 0xde, 0xe8, 0x3b, 0xac, 0xf3, 0x7a, 0x14, 0xbc, 0x82, 0x0a, 0x99, 0x3a, 0x78, 0xbc, 0x26, 0xd2, 0x5d, 0x87, 0xb0, - 0x33, 0xda, 0x02, 0xd5, 0x7e, 0x78, 0xca, 0x25, 0x16, 0xd3, 0xd7, 0x08, 0x2c, 0x91, 0x5b, 0x8a, 0x63, 0x5b, 0x86, - 0x8c, 0xa7, 0xfc, 0x81, 0xbd, 0xa9, 0xf0, 0x53, 0x0b, 0x70, 0x45, 0xe2, 0x04, 0xcb, 0x3b, 0x53, 0x06, 0x96, 0xc8, - 0xea, 0xbb, 0xe8, 0x46, 0x40, 0xca, 0x27, 0x80, 0x42, 0x54, 0x9e, 0xbc, 0x1f, 0x1e, 0xcb, 0x6a, 0x21, 0x94, 0x9d, - 0x53, 0xbb, 0xf0, 0x2b, 0x53, 0x95, 0x22, 0x01, 0xd4, 0xf2, 0x56, 0x1d, 0x1c, 0xef, 0xcb, 0xb5, 0x07, 0xc3, 0xde, - 0xa9, 0x34, 0x38, 0x6c, 0x55, 0xdc, 0x9b, 0x2f, 0x8a, 0x87, 0xec, 0x52, 0x81, 0x5b, 0x72, 0x06, 0x25, 0x30, 0x47, - 0xe5, 0x4f, 0x36, 0xc8, 0x0f, 0xa4, 0x4c, 0x2c, 0x08, 0x14, 0xed, 0x1e, 0x81, 0x1f, 0x23, 0xbd, 0x97, 0x2f, 0x21, - 0x59, 0x66, 0x8a, 0xd6, 0x86, 0xfc, 0xdf, 0x62, 0x4a, 0x50, 0xd2, 0xcd, 0xc2, 0x24, 0x8a, 0x55, 0x18, 0x66, 0x35, - 0x6f, 0x92, 0x22, 0xe5, 0x6b, 0xc3, 0x01, 0xd7, 0x92, 0x55, 0x98, 0xb0, 0xfd, 0xea, 0xa7, 0xd2, 0xb8, 0x87, 0x7a, - 0xf1, 0x43, 0xe1, 0x83, 0xa9, 0x20, 0xad, 0x1c, 0xc0, 0xe6, 0x7c, 0x54, 0x17, 0x8f, 0x7d, 0xe3, 0x2f, 0x91, 0x31, - 0xf2, 0x8c, 0x2b, 0xcf, 0xf8, 0x31, 0xbc, 0xcc, 0x6a, 0x17, 0x2f, 0xcf, 0x25, 0x67, 0xb0, 0xbe, 0x06, 0x11, 0x98, - 0xca, 0x97, 0x0a, 0xdf, 0xe2, 0x36, 0x23, 0xe7, 0x5e, 0x3c, 0x63, 0x22, 0x85, 0x9b, 0x78, 0x2b, 0x64, 0x07, 0xba, - 0x34, 0x2d, 0x10, 0x9e, 0x6c, 0x8f, 0x9b, 0xd6, 0xf9, 0xd6, 0x38, 0x8d, 0x83, 0x3f, 0xb3, 0x3b, 0x60, 0xb3, 0x92, - 0x34, 0x5a, 0x82, 0xcc, 0xca, 0x9b, 0x71, 0x1d, 0x84, 0xa1, 0xb1, 0xdd, 0xba, 0xfb, 0xf4, 0x89, 0x49, 0x59, 0xc5, - 0xd2, 0x68, 0x36, 0x0b, 0x98, 0x26, 0x65, 0x1f, 0xcb, 0xbb, 0x39, 0xd9, 0xb3, 0x45, 0xe4, 0x6a, 0x3d, 0x6b, 0x3a, - 0x58, 0x62, 0xc4, 0x2c, 0xe7, 0x06, 0x01, 0x71, 0x91, 0x71, 0x15, 0x32, 0xe4, 0x9a, 0x38, 0x17, 0xc5, 0xc1, 0x35, - 0x27, 0xd1, 0x6a, 0x14, 0x30, 0x13, 0x4f, 0x03, 0x74, 0xb9, 0x1e, 0xad, 0x46, 0xa3, 0x80, 0xd2, 0x85, 0x41, 0xfc, - 0xb5, 0x28, 0x41, 0xb9, 0x68, 0xa6, 0xf7, 0x61, 0x50, 0x56, 0x5a, 0x05, 0x1f, 0x6c, 0x26, 0xe1, 0xe6, 0x40, 0x1d, - 0xa4, 0x20, 0x03, 0xdd, 0x3c, 0xd3, 0xae, 0x0a, 0x37, 0x16, 0x96, 0xa8, 0xfd, 0x1a, 0x96, 0xce, 0xbd, 0x50, 0xdf, - 0xe3, 0x0c, 0x2b, 0x5e, 0x38, 0x51, 0x5e, 0xd1, 0xde, 0x55, 0x0d, 0x95, 0x4c, 0xbf, 0x78, 0x76, 0x39, 0xd5, 0x50, - 0x5f, 0xfb, 0xde, 0x2c, 0x8c, 0x92, 0xd4, 0x1f, 0xab, 0x97, 0xfd, 0xd7, 0xbe, 0x76, 0xb1, 0x48, 0x35, 0xfd, 0xd2, - 0xf8, 0x56, 0xce, 0x03, 0x26, 0x30, 0x25, 0xa6, 0x01, 0x6b, 0xa8, 0x23, 0x9f, 0x9e, 0x6d, 0xf5, 0x04, 0x46, 0xc6, - 0x3a, 0xdf, 0xba, 0x50, 0xab, 0x92, 0x51, 0x0c, 0x53, 0x45, 0x42, 0x46, 0xb1, 0x6f, 0xf5, 0x3e, 0x09, 0x61, 0xbe, - 0x59, 0xad, 0x91, 0x69, 0x48, 0x0b, 0xe2, 0x8b, 0x41, 0xf0, 0x85, 0xe7, 0x28, 0x3d, 0xef, 0xc9, 0x5e, 0x0f, 0x25, - 0x32, 0x3e, 0xfc, 0xa6, 0xcc, 0x81, 0x3c, 0x5e, 0xa7, 0x19, 0x98, 0x1c, 0x86, 0x51, 0xaa, 0x40, 0x64, 0x37, 0xe8, - 0x70, 0x58, 0xb5, 0x92, 0xe6, 0xad, 0x6a, 0x7a, 0xc6, 0xb1, 0xc0, 0x4b, 0xa4, 0xa5, 0x28, 0xb9, 0x84, 0x40, 0x14, - 0x10, 0xa4, 0xb4, 0x14, 0xc7, 0x89, 0xfb, 0xe6, 0xc1, 0xf2, 0x95, 0xf8, 0x37, 0x09, 0xef, 0x97, 0xe9, 0xf9, 0xe3, - 0x75, 0x72, 0x22, 0x88, 0xfa, 0xf7, 0x09, 0xae, 0x25, 0xb0, 0x2b, 0x9c, 0xca, 0x67, 0xaa, 0x72, 0x22, 0x28, 0x11, - 0xd6, 0x2d, 0xa1, 0x57, 0x4d, 0xb0, 0xbb, 0xb1, 0x88, 0x99, 0xcf, 0xc5, 0x28, 0x82, 0x01, 0xab, 0x1c, 0x3d, 0x08, - 0xd6, 0x94, 0xf3, 0x56, 0x29, 0x58, 0x5c, 0x23, 0xc1, 0x00, 0xcc, 0xc5, 0x79, 0x84, 0x61, 0x76, 0x05, 0x8c, 0x24, - 0x44, 0x30, 0x13, 0x63, 0x34, 0x22, 0x39, 0x89, 0x9c, 0x1f, 0x2e, 0x57, 0x29, 0x46, 0xa6, 0x07, 0x00, 0x58, 0xa6, - 0x2a, 0x78, 0x61, 0x04, 0x5c, 0x5f, 0x5c, 0x78, 0x32, 0x55, 0xf1, 0x27, 0x9b, 0x65, 0x5c, 0x3a, 0x03, 0x38, 0x0e, - 0x87, 0x81, 0x7a, 0x1d, 0x78, 0x8c, 0xf9, 0x30, 0xc6, 0x46, 0x91, 0xd6, 0x45, 0x1b, 0xa3, 0xfd, 0x43, 0x0d, 0x02, - 0x19, 0x53, 0x3b, 0x7d, 0x2d, 0xa8, 0x1d, 0x2c, 0x44, 0xab, 0x2e, 0x0d, 0x73, 0x08, 0x32, 0xca, 0x13, 0x98, 0x3b, - 0x17, 0x2e, 0xf5, 0xc2, 0xb4, 0x4e, 0x3d, 0x57, 0xc9, 0xae, 0x6e, 0x88, 0xd3, 0x30, 0xcc, 0xae, 0x0a, 0x47, 0xd7, - 0x62, 0xbc, 0xb0, 0x25, 0xa9, 0x5c, 0x41, 0x4b, 0x37, 0x97, 0xdb, 0xb3, 0x2d, 0x63, 0x7f, 0xe1, 0xc5, 0x77, 0x64, - 0xfe, 0x66, 0xc8, 0x36, 0x72, 0xba, 0xaa, 0x10, 0x3d, 0xa0, 0x09, 0x20, 0xd2, 0xa0, 0x2a, 0x5f, 0xe7, 0x65, 0x8c, - 0x8f, 0x36, 0xb7, 0x01, 0x82, 0xbe, 0xae, 0xd4, 0xe7, 0xcc, 0x22, 0xf9, 0x23, 0x7d, 0xd2, 0xd7, 0x92, 0x86, 0xe1, - 0x25, 0xe5, 0xe1, 0x85, 0xe5, 0x8d, 0x86, 0x83, 0x21, 0x4a, 0x41, 0x70, 0xe3, 0xc8, 0x30, 0x09, 0x66, 0xfd, 0x8a, - 0xd2, 0xbb, 0x3f, 0x74, 0x39, 0x18, 0x2c, 0x47, 0x08, 0xcb, 0x51, 0x23, 0x9a, 0xf5, 0xc4, 0x8a, 0x00, 0x2f, 0x02, - 0x5c, 0x48, 0x8c, 0x1c, 0x08, 0xe5, 0xc7, 0x54, 0xf2, 0x2d, 0x14, 0xc3, 0xd1, 0x20, 0xd8, 0xe9, 0x68, 0xc4, 0xae, - 0x1b, 0xe1, 0x57, 0x71, 0x76, 0xbc, 0x4f, 0xb5, 0x89, 0x28, 0x52, 0x25, 0x98, 0x86, 0x18, 0x46, 0x58, 0xcc, 0x02, - 0x24, 0x08, 0x77, 0x9d, 0xe2, 0xa2, 0x63, 0x2d, 0x50, 0x2d, 0xed, 0x9c, 0x94, 0x19, 0x1e, 0xfc, 0x4a, 0x1d, 0x1c, - 0x63, 0xca, 0x4f, 0x20, 0xeb, 0x10, 0x14, 0xeb, 0x78, 0x9f, 0x1e, 0x95, 0xca, 0x89, 0x28, 0x1a, 0x11, 0x32, 0xc8, - 0x1e, 0x6f, 0xe0, 0x41, 0x47, 0x25, 0x49, 0xd9, 0x12, 0x4a, 0xbd, 0x4c, 0x55, 0x16, 0x9c, 0xc1, 0xe2, 0xd1, 0xf7, - 0x20, 0x34, 0x8f, 0x0d, 0x2e, 0x11, 0xaa, 0xb2, 0xf0, 0x6e, 0x71, 0xe4, 0xe2, 0x8d, 0x77, 0xab, 0x39, 0xfc, 0x55, - 0x71, 0xd6, 0x92, 0xf2, 0x59, 0x1b, 0x6f, 0xdc, 0x90, 0x03, 0xb8, 0x21, 0x8f, 0xeb, 0x17, 0x77, 0x2e, 0x16, 0x77, - 0xd2, 0xb0, 0xb8, 0x93, 0x2d, 0x8b, 0x1b, 0xf0, 0x85, 0x54, 0xf2, 0xa9, 0x8b, 0xd1, 0x97, 0x3a, 0x9f, 0x3c, 0xce, - 0x8f, 0xf4, 0xf8, 0x39, 0xc3, 0x79, 0x32, 0x93, 0x00, 0x6c, 0x89, 0x1b, 0xe6, 0xaa, 0x6e, 0x5e, 0xa4, 0x89, 0xd8, - 0x1c, 0x78, 0x7e, 0xea, 0xc4, 0xb8, 0x21, 0x85, 0xb7, 0x16, 0x54, 0xc7, 0x0b, 0xbb, 0x14, 0x3f, 0x34, 0xb4, 0x79, - 0xc3, 0x48, 0xe7, 0x5b, 0x46, 0x3a, 0x2e, 0x1d, 0x5d, 0x3e, 0x6c, 0x3a, 0x84, 0xf2, 0xa0, 0x60, 0x0f, 0x82, 0x7f, - 0x05, 0x6e, 0x99, 0xf2, 0x3e, 0x6c, 0xc6, 0xb1, 0xd2, 0x8e, 0x5a, 0x7a, 0x49, 0x72, 0x13, 0xc5, 0x60, 0xa0, 0x00, - 0xcd, 0x3c, 0x6c, 0x4b, 0x2d, 0xfc, 0x90, 0xc7, 0x3e, 0x6b, 0xdc, 0x4c, 0xc5, 0x7b, 0x79, 0x4b, 0xb5, 0x3a, 0x1d, - 0xaa, 0xb1, 0xf4, 0xd2, 0x94, 0xc5, 0x38, 0xe9, 0x1e, 0x24, 0xc9, 0xf8, 0x0f, 0xd9, 0x66, 0x35, 0x38, 0x24, 0x90, - 0xb0, 0x3a, 0x62, 0xe8, 0x25, 0xb0, 0x60, 0xa4, 0x91, 0x0c, 0xf5, 0xb5, 0x14, 0x47, 0x35, 0xce, 0x27, 0xfe, 0x27, - 0x3c, 0xae, 0x5a, 0x2c, 0x79, 0xfa, 0x3a, 0x87, 0xba, 0xb5, 0xf4, 0x26, 0xef, 0xc1, 0x0e, 0x46, 0x6b, 0x19, 0xe0, - 0xd3, 0x22, 0x47, 0x4d, 0x8d, 0x89, 0x27, 0x1c, 0x17, 0x48, 0x12, 0xb1, 0x24, 0xb7, 0x18, 0x86, 0x60, 0x03, 0x9e, - 0x39, 0xbd, 0x5c, 0xb7, 0xb2, 0xfd, 0x99, 0xaf, 0x6f, 0x60, 0x4d, 0x40, 0x6d, 0x81, 0x3b, 0xc8, 0x85, 0x6e, 0x81, - 0xe1, 0x1c, 0xea, 0xa0, 0x28, 0xbd, 0x80, 0x74, 0xe8, 0xb6, 0xb8, 0x4c, 0x0f, 0x63, 0xa0, 0x5a, 0xa0, 0x56, 0x7c, - 0x32, 0xc3, 0x5f, 0xce, 0x65, 0xf6, 0x64, 0x84, 0xbf, 0x5a, 0x97, 0xb9, 0x12, 0xab, 0x22, 0x45, 0x90, 0xc6, 0xac, - 0x0e, 0x4a, 0xfb, 0x89, 0xcc, 0xb5, 0x1f, 0xb0, 0x6d, 0xf8, 0x02, 0x3f, 0x7a, 0xbc, 0x4e, 0x20, 0x40, 0x81, 0x3c, - 0x86, 0xd0, 0x8a, 0xf5, 0xac, 0xb6, 0x7c, 0xd6, 0x50, 0x3e, 0xd2, 0xff, 0x60, 0xc2, 0x8f, 0xbb, 0x24, 0x2a, 0x68, - 0x4a, 0x59, 0x06, 0x72, 0x35, 0xf2, 0x43, 0x2f, 0xbe, 0xbb, 0xa2, 0x5b, 0x88, 0x26, 0x58, 0xfc, 0x5c, 0xb6, 0x43, - 0xbc, 0x68, 0xd9, 0x3a, 0x24, 0x95, 0x14, 0x55, 0x77, 0x9c, 0xd0, 0xbb, 0x7f, 0x8e, 0x25, 0xfe, 0xae, 0x74, 0x8d, - 0xe5, 0x0b, 0x52, 0xea, 0xe8, 0xea, 0xf1, 0x5a, 0x63, 0x9b, 0xcd, 0x54, 0x46, 0x5b, 0x61, 0x20, 0x61, 0x79, 0xf0, - 0x4a, 0xbc, 0x98, 0xf8, 0x3d, 0x34, 0xff, 0x18, 0x45, 0xb7, 0xe6, 0xe3, 0x75, 0x7a, 0xa2, 0x2e, 0xbc, 0xf8, 0x23, - 0x9b, 0x98, 0x63, 0x3f, 0x1e, 0x07, 0xc0, 0x3c, 0x8e, 0x02, 0x2f, 0xfc, 0xc8, 0x1f, 0xcd, 0x68, 0x95, 0xa2, 0x41, - 0xd7, 0xbd, 0x37, 0x68, 0x31, 0x27, 0x24, 0x48, 0x44, 0xae, 0xb6, 0x66, 0x16, 0x94, 0xf7, 0x43, 0x71, 0xad, 0x2f, - 0x18, 0xc5, 0xa2, 0x96, 0x01, 0xfe, 0x08, 0x60, 0x63, 0x06, 0x01, 0x1e, 0x0c, 0x15, 0xd7, 0x4b, 0x35, 0xe4, 0xa1, - 0x92, 0x56, 0x2d, 0xcf, 0x50, 0x7c, 0x85, 0x2d, 0xfc, 0xf6, 0xee, 0xa0, 0xe4, 0x21, 0xdd, 0xe5, 0xad, 0x7c, 0xde, - 0x08, 0xa1, 0xd4, 0x24, 0xc7, 0xc2, 0x07, 0x74, 0xce, 0x19, 0xcc, 0xe6, 0xae, 0xe5, 0x8f, 0xbd, 0x24, 0x59, 0x2d, - 0xd8, 0x84, 0x54, 0x62, 0x27, 0x05, 0x50, 0xe5, 0x7b, 0x88, 0x0c, 0xd8, 0xdf, 0x56, 0xad, 0xa3, 0x83, 0x57, 0x60, - 0xe0, 0x07, 0x0c, 0x65, 0x34, 0x9d, 0xaa, 0x85, 0x28, 0xe0, 0x9e, 0xcf, 0x9c, 0x83, 0xbf, 0xad, 0xde, 0x9c, 0xda, - 0x6f, 0xf2, 0x8f, 0x43, 0x60, 0x8c, 0x85, 0xb5, 0x12, 0xe7, 0x8b, 0x25, 0x78, 0xc5, 0x88, 0xa6, 0x5e, 0xd8, 0x3c, - 0x9c, 0x8b, 0xd2, 0x16, 0x5f, 0x32, 0x36, 0x01, 0x86, 0xdb, 0xd8, 0x28, 0xbd, 0x0a, 0xd8, 0x35, 0xcb, 0x2d, 0xa1, - 0x36, 0x3b, 0xab, 0xf9, 0x02, 0x43, 0xb5, 0x72, 0xdd, 0x23, 0xe7, 0xea, 0xa4, 0x21, 0x0d, 0x71, 0x0c, 0x7c, 0xe4, - 0xf2, 0x11, 0xab, 0x1c, 0xa9, 0xa1, 0xa1, 0x4a, 0x00, 0x34, 0x42, 0x76, 0xd2, 0x50, 0xde, 0x03, 0x44, 0xdd, 0x00, - 0x9b, 0xe1, 0xe8, 0x3d, 0x48, 0x6d, 0xc1, 0xe7, 0x29, 0x80, 0x93, 0xa7, 0x15, 0x52, 0x93, 0xa6, 0x19, 0xab, 0x13, - 0xb5, 0xa9, 0x24, 0xa4, 0x11, 0xce, 0x01, 0xe8, 0x25, 0x23, 0xc4, 0x55, 0xb5, 0x6b, 0xa3, 0x94, 0x47, 0x3e, 0xc2, - 0xc4, 0xef, 0x21, 0x4b, 0x92, 0xc6, 0x09, 0xcb, 0x17, 0xdd, 0x50, 0x8b, 0xda, 0xe5, 0xf9, 0x28, 0xca, 0x81, 0x0e, - 0x1a, 0x6a, 0xab, 0xd3, 0x51, 0x69, 0x90, 0xd5, 0xfe, 0x90, 0xc4, 0x5c, 0xa5, 0x6c, 0xb1, 0xdc, 0xa5, 0xbf, 0xa2, - 0x76, 0xb9, 0xbf, 0xa2, 0xdc, 0x50, 0x9d, 0xce, 0x81, 0x6a, 0xa8, 0xed, 0x23, 0x7b, 0x6b, 0x8f, 0x0b, 0x6e, 0x54, - 0x1a, 0xcf, 0x46, 0x2a, 0x37, 0xf8, 0x6b, 0x7a, 0x7f, 0xa3, 0x72, 0xd0, 0x4a, 0xcc, 0x41, 0x2d, 0x80, 0x5a, 0x09, - 0xe1, 0x6f, 0xc8, 0xb2, 0xb0, 0x01, 0x01, 0x53, 0x05, 0xab, 0xb3, 0xe9, 0x94, 0x8d, 0xd3, 0x44, 0x17, 0x92, 0xad, - 0x3c, 0xc4, 0x3b, 0xb8, 0xf6, 0xee, 0xb9, 0xea, 0x4f, 0x10, 0xe8, 0x46, 0x44, 0x42, 0xe4, 0x00, 0x89, 0x9b, 0x5a, - 0xfd, 0x64, 0x51, 0x8b, 0xe5, 0x89, 0xe2, 0xbd, 0x80, 0xec, 0xbb, 0xa6, 0x1c, 0x41, 0xe3, 0x54, 0xaf, 0xd8, 0x8d, - 0x51, 0x6e, 0x7a, 0xba, 0x1d, 0x01, 0x6e, 0x43, 0x1a, 0x6b, 0xe7, 0x4d, 0xc7, 0xb1, 0x33, 0xd5, 0x00, 0x07, 0xeb, - 0x8f, 0x95, 0xc3, 0x43, 0x64, 0xd1, 0x55, 0xcf, 0xde, 0xbe, 0xfa, 0xf3, 0xe9, 0xeb, 0x5d, 0xf1, 0x10, 0x36, 0xd9, - 0x86, 0x26, 0x57, 0xe1, 0x96, 0x46, 0x7f, 0xf9, 0xe9, 0x61, 0xcd, 0xb6, 0x9c, 0x17, 0x8e, 0x6a, 0x90, 0x4d, 0xbc, - 0x84, 0x8d, 0xc7, 0xd1, 0x35, 0x8b, 0x3f, 0x7b, 0x1a, 0xe4, 0xc6, 0xeb, 0xc1, 0x7d, 0xfb, 0xf3, 0xe9, 0x4f, 0x3b, - 0x83, 0x7a, 0xe8, 0xc0, 0xe1, 0x02, 0xb1, 0xe7, 0x03, 0x46, 0xd7, 0x86, 0x73, 0x14, 0x44, 0x09, 0x6b, 0x80, 0xe0, - 0xd5, 0xd9, 0xdb, 0xf7, 0x38, 0x5d, 0x05, 0xe3, 0x43, 0x4d, 0x7d, 0xde, 0xe0, 0x7f, 0x7e, 0x77, 0xfa, 0xfe, 0xbd, - 0x6a, 0x60, 0x8a, 0xf0, 0x44, 0x6e, 0x9d, 0x6f, 0xe2, 0x7b, 0xe8, 0x5c, 0xed, 0x5e, 0x27, 0x5a, 0x4a, 0xd7, 0xf7, - 0xf2, 0x68, 0xa8, 0x6c, 0x63, 0x9b, 0x73, 0x1a, 0xcb, 0x7b, 0xa6, 0x3b, 0xf7, 0x4e, 0xe3, 0xaa, 0xc1, 0x4a, 0xdb, - 0x09, 0x79, 0xa9, 0x64, 0xe1, 0x87, 0x57, 0x35, 0xa5, 0xde, 0x6d, 0x4d, 0x29, 0x5c, 0x5a, 0x37, 0xb0, 0xf2, 0x2a, - 0x5a, 0x48, 0x4c, 0x10, 0xbb, 0xbd, 0x7f, 0xba, 0xa4, 0x9b, 0xe3, 0x67, 0x00, 0xcd, 0x53, 0xbc, 0x54, 0xa1, 0xae, - 0x29, 0xe6, 0xd7, 0xbd, 0x7c, 0x6e, 0xc7, 0x01, 0x78, 0x02, 0x30, 0x59, 0xf9, 0x59, 0x66, 0x90, 0xb9, 0x1f, 0x8f, - 0x5b, 0xb9, 0x8b, 0xd0, 0x67, 0xa4, 0x30, 0xe2, 0x94, 0x6c, 0xe9, 0x4d, 0xc0, 0xbc, 0xde, 0x1c, 0x45, 0x69, 0x1a, - 0x2d, 0x7a, 0x8e, 0xbd, 0xbc, 0x55, 0x95, 0xbe, 0x10, 0xb1, 0x70, 0xeb, 0xff, 0xde, 0xbf, 0xfe, 0x59, 0x41, 0xf3, - 0x54, 0x8e, 0x44, 0x81, 0xc5, 0x5e, 0xba, 0x8a, 0x59, 0xa6, 0xfc, 0xeb, 0x7f, 0x5e, 0x55, 0xc4, 0x09, 0x7d, 0xf9, - 0x1b, 0xba, 0x48, 0xc8, 0x9f, 0x5c, 0x05, 0xd1, 0xcd, 0x5e, 0xe1, 0xe7, 0x77, 0x4f, 0xe5, 0xb9, 0x3f, 0x9b, 0xe7, - 0xb5, 0x4f, 0xd2, 0x2d, 0x63, 0x13, 0xd0, 0x93, 0x16, 0x42, 0x39, 0x8b, 0x6e, 0x7a, 0xff, 0xfa, 0x67, 0x2e, 0x26, - 0xba, 0x77, 0xd7, 0xd5, 0x03, 0x5a, 0x5e, 0xd1, 0xfa, 0x3a, 0x1b, 0x4b, 0x8c, 0x44, 0xb3, 0xba, 0xc0, 0x1b, 0x85, - 0xb4, 0x2b, 0x37, 0x35, 0x82, 0x5b, 0xc6, 0xf4, 0x9d, 0x3f, 0x9b, 0x7f, 0xee, 0xa0, 0x60, 0x42, 0xef, 0x1d, 0x15, - 0x54, 0xfa, 0x02, 0xc3, 0x1a, 0xf6, 0x76, 0x5f, 0xb0, 0xcf, 0x1c, 0xd7, 0x7d, 0x43, 0xfa, 0x12, 0xa3, 0xe1, 0xf2, - 0xe2, 0xf7, 0xc3, 0x61, 0x9e, 0x22, 0x57, 0xfe, 0x1e, 0x3c, 0x15, 0x4f, 0x36, 0x4a, 0x38, 0x7b, 0xd1, 0xb3, 0x75, - 0x0a, 0x21, 0xb4, 0xc3, 0x84, 0xa0, 0xcd, 0x7d, 0xcd, 0x74, 0x34, 0xe3, 0x6b, 0x72, 0x9d, 0xdb, 0xe8, 0x7b, 0x03, - 0x59, 0x43, 0x29, 0xa6, 0x57, 0xcd, 0x75, 0x95, 0x46, 0x3d, 0x38, 0x37, 0xb1, 0xb7, 0x24, 0xd5, 0x84, 0x82, 0x7a, - 0x1a, 0x10, 0xf5, 0x54, 0xee, 0xee, 0xd7, 0x5e, 0x70, 0xbd, 0xdb, 0x35, 0xae, 0x99, 0x82, 0x21, 0x69, 0xfe, 0xf7, - 0x11, 0x6f, 0xa4, 0xcb, 0x0f, 0xa6, 0xdd, 0x37, 0x5e, 0xca, 0xe2, 0xab, 0x39, 0xf8, 0x18, 0x0b, 0x99, 0x05, 0x44, - 0xef, 0xdd, 0x86, 0x94, 0x4b, 0x6c, 0x69, 0x0d, 0x1a, 0x2d, 0x30, 0xdc, 0x6f, 0xc3, 0xdd, 0x5f, 0x08, 0x73, 0xf7, - 0x4e, 0xc1, 0x0b, 0xf4, 0x77, 0xc3, 0xde, 0xdb, 0x28, 0xd3, 0xff, 0x63, 0xef, 0xff, 0x44, 0xec, 0xbd, 0xb5, 0x9f, - 0xdf, 0xb2, 0xb0, 0xff, 0x07, 0xb0, 0x7c, 0x8f, 0xb9, 0xa7, 0x1c, 0xd3, 0x6b, 0x9a, 0xe7, 0x6a, 0x71, 0xe9, 0xf0, - 0x22, 0x5e, 0xdd, 0x50, 0xeb, 0xf2, 0x10, 0x6f, 0xdc, 0x5e, 0xd1, 0x43, 0x64, 0xbf, 0xe5, 0x28, 0xff, 0xfe, 0x88, - 0x3e, 0xa1, 0xbc, 0x58, 0x12, 0xa6, 0xef, 0x9d, 0x1a, 0x49, 0x69, 0x24, 0xde, 0x8d, 0x77, 0xb7, 0x0b, 0xde, 0x11, - 0xc0, 0x7e, 0x73, 0xe3, 0xdd, 0xd5, 0x01, 0xdb, 0x88, 0x5e, 0xab, 0x9d, 0x9d, 0x80, 0x6f, 0x51, 0x0f, 0x1d, 0x8b, - 0x8c, 0x61, 0xc2, 0xd2, 0x13, 0x28, 0x74, 0x1f, 0xaf, 0xf7, 0xaa, 0x15, 0xb3, 0x21, 0x78, 0x5d, 0x4b, 0x80, 0x47, - 0x25, 0xc0, 0xfd, 0xe4, 0x2a, 0x0a, 0x1f, 0x02, 0xf9, 0xcf, 0x20, 0x72, 0xfa, 0xcd, 0xa0, 0x63, 0x77, 0x1b, 0xb0, - 0x63, 0x69, 0x15, 0x78, 0x2c, 0xac, 0x42, 0xdf, 0xaf, 0xd7, 0x10, 0x54, 0x08, 0x2d, 0xd2, 0x58, 0x46, 0x84, 0x56, - 0x01, 0x6d, 0x8e, 0x02, 0x9a, 0xb5, 0x0a, 0xc9, 0xf5, 0xc3, 0x69, 0xec, 0xc5, 0x6c, 0xd2, 0x7c, 0x05, 0x28, 0xd9, - 0x44, 0xdf, 0x59, 0xc9, 0x6a, 0xb9, 0x8c, 0xe2, 0x34, 0xb9, 0xc2, 0xe8, 0x30, 0x0b, 0x1f, 0x2e, 0x14, 0x90, 0xc7, - 0x2c, 0x8f, 0x15, 0x7c, 0x5a, 0x27, 0x55, 0x37, 0x98, 0x5b, 0x4e, 0xf1, 0xc1, 0x7d, 0x7e, 0x0c, 0xee, 0x35, 0x34, - 0x97, 0xb4, 0x26, 0x73, 0x2b, 0x8d, 0xfd, 0x85, 0xa6, 0x1b, 0x8e, 0xad, 0xeb, 0x42, 0xbe, 0x32, 0x77, 0x07, 0x7b, - 0x14, 0xe3, 0x78, 0xae, 0x43, 0xac, 0x44, 0xf4, 0xa3, 0x01, 0x0b, 0xbd, 0x97, 0xab, 0xe9, 0x94, 0xc5, 0x9a, 0x08, - 0x06, 0x09, 0xd1, 0x68, 0xc9, 0x04, 0x11, 0xbc, 0x2b, 0x3f, 0xf8, 0xec, 0x06, 0xb2, 0x4e, 0x15, 0xc1, 0xdc, 0xc1, - 0xc3, 0x94, 0x8c, 0xd8, 0x21, 0xa3, 0x5d, 0xda, 0x6e, 0x69, 0x93, 0x67, 0x07, 0xc6, 0x1c, 0x42, 0x40, 0x15, 0x4e, - 0xf9, 0x18, 0x5d, 0xd0, 0x0f, 0xd3, 0x2e, 0xf6, 0x00, 0x0d, 0xc0, 0xe1, 0x0d, 0xdc, 0xdc, 0x1b, 0x4b, 0x19, 0xe7, - 0x0d, 0xce, 0xdd, 0x41, 0xf0, 0xdc, 0x25, 0xed, 0x12, 0x5a, 0x0b, 0xbe, 0x9a, 0x7b, 0xf1, 0xab, 0x68, 0xc2, 0x10, - 0xd0, 0x51, 0x1a, 0x81, 0x8f, 0xa8, 0x14, 0xfc, 0x07, 0x63, 0xff, 0x98, 0xa5, 0x78, 0x40, 0xfb, 0x50, 0x74, 0x25, - 0x17, 0xb9, 0xcf, 0x1f, 0xef, 0x1b, 0x70, 0xd2, 0xea, 0x57, 0x5a, 0x2c, 0x1a, 0x5f, 0xea, 0xda, 0x57, 0xf2, 0x6e, - 0x7d, 0xe5, 0xc5, 0xb1, 0xcf, 0x62, 0x45, 0xfb, 0xee, 0x57, 0x5d, 0xde, 0xb4, 0x25, 0x35, 0x12, 0xd7, 0x6d, 0x2b, - 0x18, 0x03, 0x6f, 0xea, 0xb3, 0x60, 0xe2, 0xaa, 0x63, 0xfa, 0x30, 0x57, 0x19, 0xb5, 0xbb, 0xb6, 0x6d, 0x73, 0x35, - 0xad, 0x43, 0x3f, 0x41, 0x4d, 0x0b, 0x3f, 0xe1, 0xa1, 0x24, 0xd4, 0xec, 0x12, 0x17, 0xb1, 0x41, 0xce, 0x6a, 0x21, - 0x7c, 0x47, 0x51, 0x84, 0x1e, 0x02, 0x1b, 0x8f, 0x36, 0x24, 0x40, 0x73, 0x04, 0x58, 0x05, 0x4c, 0x15, 0x80, 0x3a, - 0x0f, 0x01, 0xe8, 0xdc, 0x5f, 0xf8, 0xe1, 0x2c, 0x69, 0x84, 0x08, 0x95, 0xb5, 0x25, 0x78, 0x52, 0xfa, 0x42, 0x55, - 0x70, 0x0d, 0xe7, 0x51, 0x00, 0xd9, 0x8f, 0x54, 0x66, 0xcd, 0x2c, 0xe5, 0x85, 0x6d, 0xdb, 0x86, 0x79, 0x00, 0x79, - 0x06, 0x3b, 0x87, 0xb6, 0x61, 0xc2, 0x5f, 0x96, 0x65, 0xd5, 0x48, 0x81, 0xfb, 0x0b, 0x3f, 0x34, 0xe9, 0xb1, 0x65, - 0xef, 0x06, 0xef, 0xbd, 0xb6, 0xc4, 0x09, 0xd7, 0xc8, 0x8d, 0x72, 0x87, 0x55, 0x6d, 0xe4, 0x26, 0x65, 0x0b, 0x3b, - 0x8b, 0xc2, 0x3c, 0xf1, 0x28, 0x1c, 0x15, 0x62, 0x34, 0x2a, 0xbf, 0x45, 0xb6, 0x34, 0xae, 0x66, 0xcf, 0x50, 0xbf, - 0xe7, 0x60, 0xf5, 0x94, 0x57, 0xd1, 0x2a, 0x98, 0xa0, 0x11, 0x16, 0x58, 0x4c, 0x2b, 0x85, 0x2d, 0x6a, 0x25, 0xc5, - 0x15, 0x64, 0x30, 0xc7, 0xf4, 0x6e, 0xef, 0x91, 0x38, 0x45, 0xb1, 0xf6, 0x14, 0xa7, 0xf8, 0xa2, 0x6e, 0x0b, 0x5e, - 0x3e, 0x85, 0x28, 0x46, 0x3b, 0x7c, 0xc0, 0xf7, 0x05, 0xd4, 0x0f, 0x76, 0xa9, 0x2f, 0xd6, 0xed, 0xf2, 0x29, 0x85, - 0xba, 0xf5, 0x3e, 0x7d, 0xda, 0x1b, 0x7f, 0xfa, 0xb4, 0xb7, 0x91, 0x1f, 0xa4, 0x79, 0x84, 0xb4, 0x31, 0x18, 0x0f, - 0x6c, 0x02, 0xd1, 0x8a, 0x08, 0xe8, 0xef, 0xa1, 0xbc, 0xe7, 0xf1, 0x18, 0x59, 0xf4, 0x34, 0x36, 0x78, 0x87, 0xf4, - 0x18, 0x64, 0x95, 0x49, 0x99, 0xbb, 0x1e, 0x89, 0x79, 0x3e, 0x7d, 0xe2, 0xc7, 0xcd, 0x98, 0xb8, 0xe3, 0xbc, 0xc8, - 0x51, 0x8d, 0x95, 0x1b, 0xe4, 0x8f, 0x2a, 0x82, 0xbc, 0xe2, 0x18, 0xb3, 0x80, 0xf8, 0xc6, 0x8b, 0x43, 0x19, 0xe0, - 0x9f, 0x22, 0x85, 0x77, 0xab, 0xf0, 0x38, 0xac, 0x93, 0xea, 0x6a, 0x4c, 0x5d, 0xa6, 0xad, 0x08, 0x07, 0x0a, 0xfb, - 0x3a, 0xa9, 0x81, 0x73, 0x81, 0xed, 0x31, 0x19, 0xab, 0x18, 0x20, 0x7a, 0x75, 0xe3, 0xc9, 0x9d, 0x88, 0x61, 0xbd, - 0xf3, 0x6e, 0x7a, 0x2b, 0xf1, 0x70, 0x4a, 0x86, 0xf8, 0xbd, 0x69, 0xee, 0x2d, 0xbd, 0x24, 0x5f, 0xc7, 0x99, 0xfb, - 0x6d, 0xac, 0x2d, 0x8d, 0xd4, 0x50, 0x05, 0x19, 0x51, 0x75, 0x63, 0x51, 0x17, 0xd6, 0xb5, 0xbf, 0xe0, 0x41, 0x6e, - 0x34, 0xb1, 0x15, 0xae, 0xa6, 0xe8, 0x21, 0x11, 0x8e, 0xef, 0x30, 0x6c, 0x73, 0xf1, 0x9e, 0x40, 0xb9, 0xe2, 0x39, - 0xff, 0x26, 0xf2, 0x2b, 0x58, 0x70, 0xd5, 0x98, 0xea, 0x06, 0x79, 0x1e, 0xcc, 0xbe, 0xa4, 0x93, 0x01, 0x45, 0x72, - 0x5e, 0x48, 0x41, 0x66, 0x85, 0xdb, 0xc1, 0x55, 0xc5, 0xed, 0xa0, 0x66, 0x3e, 0x95, 0x98, 0x25, 0xcb, 0x28, 0x84, - 0xbb, 0xe2, 0x55, 0xe1, 0x57, 0x76, 0xb5, 0xe9, 0x57, 0x56, 0xf3, 0x29, 0xbe, 0xa1, 0xef, 0x40, 0x11, 0x7e, 0xfe, - 0x5f, 0x15, 0xbf, 0x00, 0x41, 0xea, 0x31, 0x37, 0xfa, 0x69, 0x93, 0x3f, 0xf9, 0xf7, 0xf7, 0xfb, 0x93, 0x9f, 0xed, - 0xe4, 0x4f, 0xfe, 0xfd, 0x17, 0xf7, 0x27, 0x3f, 0x95, 0xfd, 0xc9, 0x81, 0x04, 0x9f, 0xb2, 0x9d, 0xdc, 0x77, 0x85, - 0x23, 0x4d, 0x74, 0x93, 0xb8, 0x0e, 0xd7, 0xe7, 0x25, 0xe3, 0x39, 0x03, 0x03, 0x09, 0xce, 0xea, 0x06, 0xd1, 0x0c, - 0xbc, 0x6c, 0x9b, 0xfd, 0x68, 0xbf, 0x94, 0x17, 0x6d, 0x10, 0xcd, 0x54, 0x29, 0x3b, 0x5c, 0x28, 0xb2, 0xc3, 0x41, - 0x44, 0xbc, 0xbf, 0xdd, 0x3a, 0x2f, 0x2f, 0x9c, 0x7e, 0xdb, 0x81, 0xe8, 0xaa, 0xa0, 0xf3, 0xc6, 0x02, 0xbb, 0xdf, - 0x6e, 0x43, 0xc1, 0x8d, 0x54, 0xd0, 0x82, 0x02, 0x5f, 0x2a, 0xe8, 0x40, 0xc1, 0x58, 0x2a, 0x38, 0x84, 0x82, 0x89, - 0x54, 0x70, 0x04, 0x05, 0xd7, 0x6a, 0x76, 0x11, 0xe6, 0xde, 0xf2, 0x47, 0xfa, 0x65, 0x29, 0x31, 0x68, 0x6e, 0xa0, - 0x21, 0xaa, 0x1c, 0x19, 0x22, 0x4b, 0x85, 0x79, 0xa0, 0x73, 0x1e, 0x6d, 0xf8, 0xd5, 0x10, 0x30, 0x2f, 0xd8, 0xab, - 0x18, 0x60, 0xed, 0x43, 0x35, 0xdb, 0xe2, 0xb5, 0xda, 0xcb, 0xbd, 0xcb, 0x6d, 0xa3, 0x25, 0xbc, 0xb5, 0x7b, 0x18, - 0x3b, 0x44, 0x54, 0xee, 0x3c, 0x9f, 0xe7, 0x21, 0xab, 0x57, 0x6e, 0x11, 0x82, 0xa7, 0x0d, 0x89, 0x7b, 0x38, 0xaf, - 0xc6, 0x34, 0xb0, 0xd2, 0x81, 0x08, 0x2b, 0xe2, 0x14, 0x89, 0x0e, 0x14, 0x74, 0xc1, 0xef, 0x7b, 0x05, 0x0f, 0xc7, - 0x03, 0xbc, 0x13, 0xf4, 0x8b, 0x3c, 0x6e, 0x36, 0x69, 0x70, 0x57, 0x46, 0xea, 0xcd, 0x7a, 0x73, 0x83, 0xcc, 0xb7, - 0x7a, 0x33, 0x48, 0x84, 0x72, 0x32, 0xe9, 0x2d, 0x8d, 0x9b, 0x39, 0x0b, 0x7b, 0x53, 0xee, 0xec, 0x08, 0xeb, 0x4f, - 0xfe, 0x2b, 0x0b, 0x5d, 0x38, 0x5e, 0xe1, 0x9e, 0x28, 0xde, 0x12, 0x94, 0x66, 0xbe, 0x95, 0x0a, 0x9f, 0x21, 0x4d, - 0x36, 0xed, 0xfa, 0x12, 0x1e, 0x1e, 0xaf, 0xd9, 0x68, 0x35, 0x53, 0xce, 0xa2, 0xd9, 0xbd, 0xde, 0x1c, 0xf2, 0x2b, - 0x80, 0x52, 0x25, 0x1b, 0x56, 0x53, 0x6c, 0x6f, 0xde, 0x17, 0x3d, 0x66, 0xe5, 0xfa, 0x29, 0xc0, 0xa6, 0xa4, 0xc4, - 0x36, 0x40, 0x3f, 0x30, 0xdb, 0x92, 0xbf, 0xc4, 0x19, 0xcc, 0x9f, 0xf4, 0x7c, 0xee, 0x49, 0xf0, 0x0c, 0x7e, 0x64, - 0x49, 0xe2, 0xcd, 0x98, 0x8c, 0x5a, 0x4a, 0x8d, 0x03, 0x16, 0xcc, 0x95, 0xd8, 0x38, 0x81, 0xc0, 0xd8, 0xfb, 0x1b, - 0x5e, 0x30, 0xe0, 0xa8, 0x0b, 0xde, 0x61, 0xb0, 0x68, 0x85, 0xcb, 0x88, 0x6f, 0xc1, 0xf2, 0x94, 0xbd, 0x37, 0x00, - 0x89, 0x5c, 0xb3, 0xa0, 0x5a, 0x98, 0x7a, 0xb3, 0x6a, 0x11, 0xad, 0x75, 0x56, 0x42, 0x7b, 0x7a, 0xe9, 0x51, 0xe0, - 0xc2, 0xcf, 0xf0, 0x06, 0x08, 0xa2, 0xd9, 0xef, 0xea, 0x0a, 0xb0, 0xc5, 0x85, 0xe3, 0xc7, 0xd0, 0x08, 0xd3, 0xa1, - 0x85, 0x73, 0xac, 0x58, 0x30, 0x85, 0xbd, 0x30, 0x9d, 0x9b, 0x18, 0xce, 0x4e, 0x6b, 0x85, 0xba, 0x61, 0xe1, 0xda, - 0xae, 0xab, 0x41, 0x3c, 0x7b, 0xf1, 0x6c, 0xe4, 0x69, 0x4e, 0xeb, 0xc8, 0x10, 0x7f, 0x2c, 0xbb, 0xa3, 0x67, 0xd8, - 0x82, 0x32, 0xf1, 0xaf, 0xd7, 0xd3, 0x28, 0x4c, 0xcd, 0xa9, 0xb7, 0xf0, 0x83, 0xbb, 0xde, 0x22, 0x0a, 0xa3, 0x64, - 0xe9, 0x8d, 0x59, 0x5f, 0xe2, 0x47, 0x31, 0x3c, 0x34, 0x8f, 0x50, 0xe8, 0x58, 0xad, 0x98, 0x2d, 0xe8, 0xeb, 0x3c, - 0xfa, 0xf3, 0x34, 0x60, 0xb7, 0x19, 0xef, 0xbe, 0x54, 0x99, 0xaa, 0xe2, 0x96, 0xa3, 0x2f, 0x80, 0x65, 0xe6, 0xa1, - 0xa5, 0x21, 0xa1, 0x42, 0x9f, 0x4b, 0x1d, 0x7b, 0x56, 0xab, 0x13, 0xb3, 0x85, 0x62, 0x75, 0x1a, 0x1b, 0x8f, 0xa3, - 0x9b, 0x01, 0x40, 0x8b, 0x1f, 0x9b, 0x09, 0x0b, 0xa6, 0xf8, 0xc6, 0xc4, 0x68, 0x56, 0xa2, 0x1d, 0x13, 0xad, 0x19, - 0xa0, 0x35, 0xb6, 0xe8, 0xc3, 0xeb, 0x5e, 0x4b, 0xb1, 0x25, 0x7e, 0xfa, 0xc8, 0x5e, 0x4a, 0x6d, 0xc9, 0xf3, 0xa7, - 0xaf, 0xb1, 0xba, 0xa3, 0xd8, 0x7d, 0xd0, 0x1f, 0x4f, 0x83, 0xe8, 0xa6, 0x37, 0xf7, 0x27, 0x13, 0x16, 0xf6, 0x11, - 0xe6, 0xbc, 0x90, 0x05, 0x81, 0xbf, 0x4c, 0xfc, 0xa4, 0xbf, 0xf0, 0x6e, 0x79, 0xab, 0x07, 0x4d, 0xad, 0xb6, 0x79, - 0xab, 0xed, 0x9d, 0x5b, 0x95, 0x9a, 0x81, 0xc8, 0x59, 0xd4, 0x0e, 0x07, 0xad, 0xa3, 0xd8, 0x95, 0x71, 0xee, 0xdc, - 0xea, 0x32, 0x66, 0xeb, 0x85, 0x17, 0xcf, 0xfc, 0xb0, 0x67, 0x67, 0xd6, 0xf5, 0x9a, 0x36, 0xc6, 0xa3, 0x6e, 0xb7, - 0x9b, 0x59, 0x13, 0xf1, 0x64, 0x4f, 0x26, 0x99, 0x35, 0x16, 0x4f, 0xd3, 0xa9, 0x6d, 0x4f, 0xa7, 0x99, 0xe5, 0x8b, - 0x82, 0x76, 0x6b, 0x3c, 0x69, 0xb7, 0x32, 0xeb, 0x46, 0xaa, 0x91, 0x59, 0x8c, 0x3f, 0xc5, 0x6c, 0xd2, 0xc7, 0x8d, - 0xc4, 0xbd, 0xae, 0x8f, 0x6c, 0x3b, 0x43, 0x0c, 0x70, 0x51, 0xc2, 0x4d, 0x68, 0x30, 0x73, 0xb9, 0xde, 0xb9, 0xa6, - 0x52, 0x74, 0x37, 0x1e, 0xd7, 0xd6, 0x9b, 0x78, 0xf1, 0xc7, 0x4b, 0x45, 0x1a, 0x85, 0xe7, 0x51, 0xb5, 0xb5, 0x98, - 0x06, 0xf3, 0xb6, 0x07, 0x69, 0x42, 0xfa, 0xa3, 0x28, 0x86, 0x33, 0x1b, 0x7b, 0x13, 0x7f, 0x95, 0xf4, 0x9c, 0xd6, - 0xf2, 0x56, 0x14, 0xf1, 0xbd, 0x5e, 0x14, 0xe0, 0xd9, 0xeb, 0x25, 0x51, 0xe0, 0x4f, 0x44, 0x51, 0xd3, 0x59, 0x72, - 0x5a, 0x7a, 0x1f, 0xf9, 0x57, 0x1f, 0x43, 0x3d, 0x7b, 0x41, 0xa0, 0x58, 0xed, 0x44, 0x61, 0x5e, 0x82, 0x46, 0x7a, - 0x8a, 0x9d, 0xd0, 0xbc, 0x60, 0x40, 0x5c, 0xe7, 0x60, 0x79, 0x9b, 0xef, 0x79, 0xe7, 0x70, 0x79, 0x9b, 0x7d, 0xbd, - 0x60, 0x13, 0xdf, 0x53, 0xb4, 0x62, 0x37, 0x39, 0x36, 0x18, 0xf2, 0xe9, 0xeb, 0x86, 0x6d, 0x2a, 0x8e, 0x05, 0xa4, - 0x53, 0xda, 0xf3, 0x17, 0x20, 0x87, 0xf1, 0xc2, 0x34, 0xcb, 0x86, 0x97, 0x59, 0xd6, 0x3f, 0xf3, 0xb5, 0x8b, 0xff, - 0xd6, 0x88, 0x16, 0x92, 0xe1, 0x6b, 0xa6, 0x5f, 0x1a, 0xa7, 0x4c, 0x76, 0xd2, 0x01, 0x32, 0x86, 0x0e, 0x3a, 0x72, - 0x65, 0xa2, 0xb7, 0x9b, 0x95, 0x69, 0x92, 0xf3, 0xea, 0xe4, 0xf3, 0x53, 0xae, 0x82, 0x14, 0x08, 0x2a, 0x9c, 0x32, - 0xf7, 0x4c, 0xf2, 0xf8, 0x01, 0xa6, 0x07, 0x2b, 0x53, 0x2c, 0xa3, 0xd7, 0x4d, 0xbc, 0xe7, 0xf9, 0xfd, 0xbc, 0xe7, - 0x5f, 0xd3, 0x5d, 0x78, 0xcf, 0xf3, 0x2f, 0xce, 0x7b, 0xbe, 0xde, 0x8c, 0x65, 0x74, 0x1e, 0xb9, 0x6a, 0x6e, 0xa6, - 0x09, 0xa4, 0x29, 0xa6, 0x2c, 0x01, 0xaf, 0xd3, 0xdf, 0x1a, 0x54, 0x46, 0xb4, 0x86, 0x44, 0x81, 0xf3, 0xa9, 0x20, - 0x66, 0x7d, 0x1b, 0xba, 0x7f, 0x8e, 0xe5, 0xe7, 0xe9, 0xd4, 0x7d, 0x1d, 0x49, 0x05, 0xf9, 0x13, 0xf7, 0x60, 0x29, - 0x45, 0x74, 0xa6, 0x37, 0xb9, 0x8f, 0x11, 0xe4, 0xbc, 0x86, 0x80, 0xb0, 0xe4, 0x50, 0x3e, 0xc9, 0x3d, 0xfd, 0xfa, - 0x65, 0x10, 0xb4, 0xdc, 0xb5, 0x56, 0x84, 0xfd, 0xda, 0xb0, 0x8c, 0x9a, 0x31, 0x21, 0x03, 0x78, 0x79, 0xf7, 0xfd, - 0x44, 0x3b, 0x8f, 0xf4, 0xcc, 0x4f, 0xde, 0x56, 0x83, 0x6e, 0x09, 0x3d, 0x97, 0x3c, 0x9c, 0x8c, 0x7b, 0xeb, 0x49, - 0xb1, 0x75, 0xf1, 0x35, 0x7d, 0x7e, 0x52, 0x1a, 0x69, 0x4f, 0xfe, 0xb0, 0x4f, 0x91, 0xc6, 0x37, 0x88, 0x31, 0x0f, - 0x4e, 0xb3, 0xe6, 0x5c, 0xde, 0x1a, 0x9f, 0x21, 0x56, 0xe9, 0x84, 0x3e, 0xf7, 0x27, 0x59, 0xa6, 0xf7, 0xc5, 0x44, - 0x48, 0x84, 0x96, 0xdd, 0xc7, 0xc4, 0x25, 0x85, 0x10, 0x88, 0x4b, 0x7c, 0xc8, 0x86, 0xfa, 0x1c, 0xbc, 0x12, 0xb8, - 0xc5, 0x35, 0x9f, 0x33, 0x55, 0xa1, 0xe9, 0x23, 0x6f, 0x15, 0x69, 0x40, 0x60, 0x46, 0x2f, 0xfb, 0x78, 0x95, 0x16, - 0x64, 0xd3, 0x9d, 0x96, 0x26, 0x07, 0xdd, 0x2a, 0x20, 0xb2, 0xb0, 0x10, 0x0b, 0x11, 0xda, 0xe1, 0x75, 0xf0, 0x21, - 0x53, 0x73, 0xde, 0x0f, 0xb7, 0xdf, 0xe0, 0x78, 0x1f, 0x3e, 0x18, 0x54, 0x94, 0x6e, 0xf7, 0x78, 0x83, 0x02, 0x2b, - 0x91, 0xdc, 0x18, 0x56, 0x72, 0xa3, 0x3c, 0x5b, 0x8b, 0xa8, 0xdc, 0xa9, 0xb7, 0x34, 0x41, 0xcb, 0x83, 0xb8, 0x97, - 0x63, 0x3c, 0x29, 0x00, 0x78, 0x7f, 0x95, 0x00, 0x6e, 0x44, 0x39, 0x0a, 0xe2, 0x9f, 0xfe, 0x78, 0x15, 0x27, 0x51, - 0xdc, 0x5b, 0x46, 0x7e, 0x98, 0xb2, 0x38, 0x23, 0xc1, 0x0a, 0xce, 0x8f, 0x98, 0x9e, 0xcb, 0x75, 0xb4, 0xf4, 0xc6, - 0x7e, 0x7a, 0xd7, 0xb3, 0x39, 0x4b, 0x61, 0xf7, 0x39, 0x77, 0x60, 0xd7, 0xd6, 0xef, 0xf1, 0xd9, 0x7c, 0x8e, 0x8c, - 0x5f, 0xbc, 0xc9, 0xce, 0xc8, 0xdb, 0xbc, 0x2f, 0xbd, 0xa5, 0xb8, 0xe4, 0xc0, 0x7e, 0x78, 0xb1, 0x39, 0x03, 0x2c, - 0x0f, 0x4b, 0x6d, 0x4f, 0xd8, 0xcc, 0x40, 0xac, 0x0d, 0xfe, 0x0e, 0xe2, 0x8f, 0xd5, 0xd1, 0x15, 0xbb, 0xbe, 0x18, - 0x38, 0x1e, 0x7d, 0x17, 0xc8, 0x7a, 0xde, 0x34, 0x65, 0xb1, 0xb1, 0x4b, 0xcd, 0x11, 0x9b, 0x46, 0x31, 0xa3, 0x1c, - 0x76, 0x4e, 0x77, 0x79, 0xbb, 0x7b, 0xf3, 0xdb, 0x87, 0x5f, 0xdf, 0x4e, 0x18, 0xa5, 0x9a, 0x68, 0x4c, 0xbf, 0xa7, - 0xb5, 0x4d, 0x7a, 0x06, 0xac, 0x21, 0xcd, 0xfc, 0x98, 0xa4, 0x20, 0x10, 0x7f, 0xac, 0x36, 0x55, 0xc8, 0x32, 0xe2, - 0x34, 0x2f, 0x66, 0x81, 0x97, 0xfa, 0xd7, 0x82, 0x67, 0x6c, 0x1f, 0x2e, 0x6f, 0xc5, 0x1a, 0x23, 0xc1, 0x7b, 0xc0, - 0x22, 0x55, 0x40, 0x11, 0x8b, 0x54, 0x2d, 0xc6, 0x45, 0xea, 0x6f, 0x8c, 0x46, 0x44, 0xcf, 0xae, 0x50, 0xfa, 0xce, - 0xf2, 0x56, 0x26, 0xd1, 0xc5, 0x67, 0x39, 0xa5, 0xae, 0xa6, 0x3d, 0x59, 0xf8, 0x93, 0x49, 0xc0, 0xb2, 0xd2, 0x42, - 0x97, 0xd7, 0x52, 0x9a, 0x9c, 0x7c, 0x1e, 0xbc, 0x51, 0x12, 0x05, 0xab, 0x94, 0xd5, 0x4f, 0x97, 0x90, 0xe8, 0x16, - 0x93, 0x83, 0xbf, 0xcb, 0xb0, 0x76, 0x80, 0xdd, 0x86, 0x6d, 0x62, 0xf7, 0x21, 0xcb, 0xa1, 0xd9, 0x2e, 0x83, 0x0e, - 0xaf, 0x72, 0xa0, 0x8d, 0x9a, 0x81, 0x18, 0x40, 0x96, 0x08, 0x7b, 0x2b, 0x96, 0xc3, 0xcb, 0xf2, 0x4c, 0x6f, 0x79, - 0x51, 0x56, 0x1e, 0xcc, 0xef, 0x73, 0xc6, 0x5e, 0xd4, 0x9f, 0xb1, 0x17, 0xe2, 0x8c, 0x6d, 0xdf, 0x99, 0x8f, 0xa6, - 0x0e, 0xfc, 0xd7, 0x2f, 0x06, 0xd4, 0xb3, 0x95, 0xf6, 0xf2, 0x56, 0x71, 0x96, 0xb7, 0x8a, 0xd9, 0x5a, 0xde, 0x2a, - 0xd8, 0x34, 0x3a, 0xd5, 0x18, 0x56, 0x4b, 0x37, 0x6c, 0x05, 0x0a, 0xe1, 0x8f, 0x5d, 0x7a, 0xe5, 0x1c, 0xc0, 0x3b, - 0xf8, 0xaa, 0xb3, 0xf9, 0xae, 0xb5, 0xfd, 0xa8, 0xd3, 0x59, 0x12, 0x48, 0x5b, 0xb7, 0x52, 0x6f, 0x34, 0x02, 0x51, - 0x66, 0x34, 0x5e, 0x25, 0xff, 0xe0, 0xf0, 0xf3, 0x49, 0xdc, 0x8a, 0x08, 0x2a, 0xed, 0x88, 0x4f, 0x41, 0x51, 0x78, - 0xcd, 0x44, 0x0b, 0xeb, 0x7c, 0x9d, 0x7a, 0x94, 0x92, 0xb1, 0x65, 0x1d, 0xd4, 0x6c, 0xf2, 0xfa, 0x89, 0xfe, 0xdd, - 0x56, 0xa9, 0x19, 0xc5, 0x7c, 0xc6, 0xb4, 0x6c, 0x9d, 0x8e, 0x87, 0xcf, 0x06, 0x5f, 0x4d, 0xbb, 0x5b, 0x0f, 0xee, - 0x85, 0xe8, 0xe9, 0x52, 0x10, 0x15, 0x4e, 0xb7, 0x78, 0x00, 0x90, 0xed, 0xad, 0x36, 0xed, 0x91, 0x8d, 0x56, 0xb7, - 0x10, 0x84, 0xa2, 0xee, 0x8e, 0x58, 0xfe, 0xd1, 0x8b, 0x03, 0xf8, 0x8f, 0xb8, 0xfa, 0xbf, 0xa6, 0x75, 0x8c, 0xfa, - 0xeb, 0xb4, 0xc4, 0xa8, 0x13, 0xab, 0x84, 0x8c, 0xf8, 0xee, 0xf5, 0xa7, 0xd3, 0x87, 0x7d, 0xb0, 0x73, 0x6d, 0xf2, - 0x47, 0xab, 0xd6, 0x7e, 0x19, 0x45, 0x01, 0xf3, 0xc2, 0xcd, 0xea, 0x62, 0x7a, 0x28, 0xb8, 0x40, 0xea, 0xc2, 0x47, - 0xe2, 0x1e, 0x41, 0xae, 0x10, 0x2a, 0x7e, 0x43, 0x57, 0x89, 0xb3, 0xa6, 0xab, 0xc4, 0xbb, 0xfb, 0xaf, 0x12, 0x3f, - 0xec, 0x74, 0x95, 0x78, 0xf7, 0xc5, 0xaf, 0x12, 0x67, 0x9b, 0x57, 0x89, 0xb3, 0x48, 0x38, 0x21, 0x1b, 0x6f, 0x56, - 0xfc, 0xe7, 0x07, 0xb2, 0xf7, 0x7d, 0x17, 0xb9, 0x1d, 0x9b, 0xd2, 0x2c, 0x9e, 0xff, 0xe6, 0x8b, 0x05, 0x6e, 0xc4, - 0x77, 0xe8, 0x93, 0x57, 0x5c, 0x2d, 0x38, 0x66, 0xc7, 0x7e, 0xa4, 0xe2, 0x20, 0x0a, 0x67, 0x3f, 0x83, 0xbd, 0x37, - 0x88, 0x03, 0x63, 0xe9, 0x85, 0x9f, 0xfc, 0x1c, 0x2d, 0x57, 0x4b, 0x54, 0x54, 0x7d, 0xf0, 0x13, 0x7f, 0x14, 0xb0, - 0x3c, 0xae, 0x25, 0x69, 0x5d, 0xb9, 0x6c, 0x1d, 0x14, 0xaf, 0xe2, 0xa7, 0x77, 0x2b, 0x7e, 0xa2, 0x63, 0x2f, 0xff, - 0x4d, 0xce, 0x89, 0x6a, 0xfd, 0x45, 0x44, 0x58, 0x88, 0x49, 0x40, 0x3f, 0xfc, 0x32, 0x72, 0x26, 0x22, 0x88, 0x95, - 0x46, 0x29, 0xdc, 0x37, 0x1a, 0xdb, 0x61, 0xd5, 0x76, 0xde, 0xac, 0x74, 0x23, 0x4f, 0xfb, 0xb1, 0x29, 0xce, 0x5f, - 0x44, 0xab, 0x84, 0x4d, 0xa2, 0x9b, 0x50, 0x35, 0x42, 0xae, 0x57, 0x8d, 0x50, 0xa6, 0x9e, 0x7f, 0x53, 0x56, 0x38, - 0xaa, 0xd6, 0x12, 0xe6, 0xd0, 0x24, 0x0d, 0xb6, 0x89, 0x43, 0x54, 0x45, 0xa0, 0xa8, 0xfe, 0x9e, 0xa6, 0x45, 0xee, - 0xc3, 0xbe, 0x14, 0x9e, 0x27, 0x91, 0xc5, 0xa5, 0xc2, 0x89, 0x16, 0x0a, 0xe1, 0xa2, 0x88, 0xbd, 0x5d, 0xb3, 0x70, - 0xfc, 0x0d, 0xc5, 0xa5, 0x2c, 0xde, 0x82, 0xae, 0x2a, 0x5b, 0xf1, 0xf5, 0xe0, 0x91, 0xa8, 0xe9, 0xf1, 0x95, 0x34, - 0x8d, 0x6f, 0xaf, 0x59, 0x1c, 0x78, 0x77, 0x9a, 0x9e, 0x45, 0xe1, 0x8f, 0x30, 0x01, 0xaf, 0xa3, 0x9b, 0x50, 0xae, - 0x80, 0x09, 0xe2, 0x6b, 0xf6, 0x52, 0x6d, 0xcc, 0x74, 0x88, 0x14, 0x22, 0x41, 0xe0, 0x5b, 0x4b, 0x6f, 0xc6, 0xfe, - 0xcb, 0xa0, 0x7f, 0xff, 0x5b, 0xcf, 0x8c, 0x77, 0x51, 0xde, 0xd1, 0x2f, 0xcb, 0x1d, 0xba, 0x79, 0xf2, 0x64, 0xaf, - 0x79, 0xd8, 0xda, 0x38, 0x60, 0x5e, 0x2c, 0xa0, 0xa8, 0xf9, 0x5a, 0x6f, 0x3c, 0x05, 0x00, 0xc5, 0x79, 0xb4, 0x1a, - 0xcf, 0xd1, 0x5b, 0xf8, 0xcb, 0x8d, 0x37, 0x85, 0x36, 0x59, 0x72, 0x61, 0x5f, 0xe6, 0x43, 0xaf, 0x14, 0x15, 0xb3, - 0x80, 0xfd, 0x9f, 0x42, 0xd2, 0xaf, 0x7f, 0xe3, 0x34, 0x6c, 0xee, 0x9a, 0x3c, 0xd0, 0xd8, 0x83, 0x36, 0x6f, 0xdf, - 0x87, 0x58, 0x40, 0x14, 0x4e, 0x5b, 0x28, 0xe9, 0xea, 0x91, 0x4c, 0x56, 0x9d, 0x34, 0x39, 0x75, 0x4d, 0x53, 0x56, - 0x1e, 0xd1, 0x0b, 0xb3, 0x4a, 0x56, 0x23, 0x06, 0xe3, 0xd8, 0xaa, 0x82, 0x64, 0xb8, 0x37, 0x05, 0x43, 0xf4, 0x55, - 0x7d, 0xb7, 0xf0, 0x43, 0x03, 0x33, 0xcf, 0x6e, 0xbe, 0xf1, 0x6e, 0x21, 0xf7, 0x22, 0x20, 0xb7, 0xea, 0x2b, 0x28, - 0x34, 0xe4, 0x18, 0x45, 0xde, 0x64, 0xa2, 0xa9, 0xb5, 0x33, 0x21, 0xb4, 0x81, 0xc3, 0xaf, 0x14, 0x45, 0x51, 0xf2, - 0x6b, 0x84, 0x92, 0xdf, 0x23, 0xb0, 0x1c, 0xaf, 0x03, 0xa0, 0x2d, 0xc9, 0x96, 0xb7, 0x54, 0x02, 0x37, 0x03, 0xb4, - 0x9f, 0x16, 0x05, 0x3c, 0xbd, 0x10, 0x18, 0xb7, 0x50, 0x81, 0xb8, 0xd0, 0x83, 0xea, 0xdb, 0x8b, 0x21, 0x0b, 0x61, - 0x4f, 0xc1, 0x0b, 0x3b, 0xbe, 0xe5, 0x92, 0x60, 0xc5, 0xa6, 0xc7, 0x61, 0x9f, 0xd5, 0xe7, 0xa1, 0x09, 0x25, 0x2c, - 0x08, 0x5a, 0x87, 0x4a, 0x5a, 0x49, 0x83, 0xd5, 0xe0, 0x46, 0xbc, 0x17, 0xdd, 0xa6, 0x0b, 0x16, 0xae, 0x54, 0x03, - 0xac, 0x4e, 0x30, 0x2f, 0x10, 0xd4, 0x79, 0x4d, 0xcc, 0x16, 0x60, 0x9b, 0xfa, 0x2f, 0xe7, 0x44, 0x0b, 0x85, 0xa9, - 0x8a, 0x67, 0x8c, 0x79, 0xd8, 0x9d, 0x84, 0xe3, 0xb6, 0x2a, 0x85, 0xe0, 0x4b, 0x1a, 0x95, 0xb1, 0x39, 0x0f, 0xb4, - 0x85, 0x9c, 0x02, 0xd9, 0x88, 0x71, 0x71, 0x91, 0x98, 0x76, 0xcd, 0xab, 0x2e, 0x5a, 0xae, 0x91, 0xf1, 0x2a, 0x82, - 0xa2, 0x58, 0xdf, 0x6c, 0x86, 0xc3, 0x09, 0xc9, 0x10, 0x1a, 0xdb, 0x19, 0x6f, 0xb4, 0xd3, 0x30, 0xe8, 0x8f, 0xec, - 0x8e, 0x08, 0x09, 0x4d, 0xd5, 0x47, 0x76, 0x07, 0xc6, 0xe1, 0xa7, 0x20, 0x4d, 0x51, 0xb7, 0xa0, 0x6b, 0x03, 0xd2, - 0x0b, 0x8f, 0x21, 0x41, 0xc6, 0x96, 0x03, 0x64, 0x67, 0x5b, 0xb0, 0x38, 0x05, 0x41, 0x35, 0x92, 0xbe, 0x38, 0xc4, - 0x3c, 0x4e, 0x82, 0x56, 0x3b, 0xc7, 0x66, 0xcd, 0xd1, 0xd0, 0x9f, 0x39, 0xb6, 0xbd, 0xbf, 0x51, 0x1f, 0x04, 0xd9, - 0x75, 0xb5, 0x75, 0x23, 0x75, 0x1d, 0xdb, 0xf4, 0x9f, 0x59, 0xad, 0xfe, 0x06, 0x8d, 0x96, 0xf2, 0x57, 0x0d, 0x51, - 0xfc, 0x35, 0x78, 0xbc, 0xd6, 0x36, 0x0e, 0xa4, 0x5e, 0x8d, 0x3b, 0x80, 0xb0, 0x65, 0x5c, 0xfe, 0x35, 0xdc, 0x24, - 0xfd, 0x94, 0x3d, 0x8b, 0x72, 0xa9, 0x0f, 0x21, 0x03, 0xa3, 0x06, 0xc7, 0xe8, 0x4f, 0xca, 0x73, 0x45, 0xa3, 0xe3, - 0xa3, 0xeb, 0xc3, 0xbe, 0xc0, 0x28, 0x22, 0x30, 0x8f, 0xdc, 0x40, 0xa5, 0xc7, 0xa4, 0x8a, 0xe1, 0x78, 0xae, 0x37, - 0x56, 0x68, 0xf4, 0xb6, 0x72, 0x0b, 0xd8, 0x7e, 0x03, 0xf9, 0xb4, 0x46, 0x10, 0x59, 0x12, 0x6a, 0x40, 0xbe, 0xd6, - 0x7b, 0x1b, 0x5c, 0x2d, 0xcb, 0xcd, 0x95, 0x89, 0xe4, 0xee, 0x8d, 0x21, 0xd1, 0x41, 0x1d, 0x5a, 0xde, 0x5e, 0x3d, - 0xb9, 0x7b, 0x60, 0x93, 0x2c, 0x9c, 0x94, 0x1b, 0xac, 0xd0, 0xaf, 0xdd, 0x9b, 0x2b, 0x61, 0x14, 0x48, 0x64, 0x1c, - 0xd5, 0x60, 0x94, 0x2c, 0x0a, 0x71, 0xf3, 0xd3, 0x71, 0xf3, 0x77, 0xe2, 0x62, 0xf0, 0x03, 0xca, 0x42, 0x92, 0x7f, - 0x26, 0x09, 0xc5, 0x21, 0x5b, 0x26, 0xc6, 0xed, 0xd2, 0x04, 0x23, 0xda, 0xb8, 0x13, 0x53, 0xe1, 0xae, 0x58, 0x7c, - 0xe3, 0xf3, 0xfc, 0x57, 0xbb, 0x4a, 0xad, 0xfd, 0xfb, 0xa5, 0xd6, 0xe9, 0x7d, 0x52, 0x6b, 0x8a, 0x49, 0xc3, 0xed, - 0x41, 0x45, 0x6c, 0x1e, 0xc1, 0x9c, 0xcb, 0xd1, 0x8d, 0x4a, 0xa2, 0x6e, 0x0c, 0x61, 0x53, 0x63, 0x45, 0x4a, 0xad, - 0x91, 0x03, 0x22, 0x8a, 0xbf, 0xa5, 0x0b, 0x8a, 0x50, 0xa8, 0xcb, 0xb2, 0xf1, 0xb3, 0x42, 0x36, 0x4e, 0xb7, 0x9a, - 0x22, 0x1a, 0x89, 0xe0, 0xfe, 0xa5, 0x48, 0x3f, 0xf9, 0xed, 0xa0, 0x88, 0xf8, 0x53, 0x40, 0x2a, 0xc5, 0xb0, 0x29, - 0x2e, 0x1a, 0x52, 0x64, 0x24, 0x71, 0xcb, 0x28, 0x07, 0x48, 0x2a, 0x57, 0x2d, 0x42, 0xd8, 0x14, 0xe5, 0x20, 0x75, - 0x47, 0x90, 0xf3, 0x62, 0x79, 0xdb, 0x94, 0x63, 0x98, 0xc8, 0xaf, 0xa5, 0x4d, 0x92, 0x07, 0x1b, 0xa1, 0x09, 0x16, - 0x62, 0xfa, 0x8a, 0x5e, 0x3b, 0xb7, 0x81, 0x40, 0x20, 0x6b, 0x62, 0x23, 0xdd, 0x2f, 0x9d, 0xa7, 0x1c, 0xcd, 0x85, - 0xea, 0xda, 0x41, 0xea, 0x4e, 0x9a, 0x60, 0x59, 0x1e, 0x81, 0x73, 0x7d, 0x29, 0x49, 0x10, 0x7a, 0xb6, 0x62, 0xf7, - 0x6b, 0x18, 0x00, 0xa4, 0xff, 0xd5, 0x67, 0xce, 0x0a, 0x80, 0x24, 0x52, 0xb1, 0x65, 0x9d, 0x3f, 0x1e, 0x62, 0x93, - 0x2c, 0xd9, 0xb1, 0xea, 0x66, 0x9f, 0x24, 0xef, 0x59, 0xf3, 0x48, 0x24, 0x65, 0x71, 0x3e, 0xaf, 0xd1, 0x13, 0x70, - 0xf0, 0x5d, 0x16, 0xaf, 0x42, 0x4c, 0xbd, 0x6b, 0xa6, 0xb1, 0x37, 0xfe, 0xb8, 0x96, 0xfa, 0xe3, 0x22, 0x51, 0x10, - 0x17, 0x97, 0x95, 0x0a, 0x7d, 0x0f, 0x33, 0x55, 0xb1, 0x9e, 0xd5, 0x4a, 0x24, 0x41, 0x4d, 0xef, 0x91, 0xdd, 0xf6, - 0x5e, 0x4c, 0x0f, 0x2a, 0xf2, 0xd3, 0x56, 0xa7, 0x2c, 0x5d, 0xcf, 0xe1, 0x58, 0x44, 0xbf, 0xf2, 0x98, 0x4d, 0x7f, - 0x7c, 0xd7, 0x09, 0xef, 0xb3, 0xb2, 0x46, 0x9f, 0x03, 0x02, 0x7c, 0x5f, 0x52, 0x4c, 0xcb, 0x6a, 0x9a, 0x8d, 0x92, - 0x26, 0xb0, 0xa6, 0x7e, 0x10, 0x98, 0x01, 0xb8, 0x31, 0xac, 0x3f, 0x6b, 0x78, 0xd8, 0xce, 0x0a, 0x72, 0x24, 0x7e, - 0x46, 0x3b, 0xe5, 0x9d, 0x92, 0xce, 0x57, 0x8b, 0xd1, 0x5a, 0x16, 0x94, 0x4b, 0xf2, 0xf3, 0x4d, 0x99, 0xb9, 0xdc, - 0xed, 0x74, 0x3a, 0x2d, 0x4b, 0x8d, 0x6d, 0xe5, 0x00, 0x25, 0xbf, 0x8f, 0x6c, 0xdb, 0xae, 0xce, 0x6f, 0xd3, 0x41, - 0xa1, 0x83, 0x61, 0xa2, 0x10, 0xbe, 0x7b, 0xff, 0x9e, 0xfa, 0x83, 0xa0, 0xa5, 0xa6, 0x9a, 0xce, 0x23, 0x6d, 0xb5, - 0xff, 0x08, 0x50, 0x10, 0x35, 0xdc, 0x77, 0xfc, 0x37, 0xf7, 0xca, 0x96, 0x96, 0xaa, 0x07, 0xf8, 0x61, 0x1f, 0xdf, - 0xb3, 0xd7, 0x77, 0xf8, 0xb4, 0x69, 0x7b, 0x67, 0x56, 0x41, 0x76, 0x4b, 0x36, 0x4b, 0x7d, 0xb2, 0x54, 0xf2, 0x53, - 0xb6, 0x48, 0x7a, 0x63, 0x86, 0x0a, 0x52, 0x4b, 0xa2, 0xb6, 0x68, 0xd5, 0x63, 0xce, 0xc0, 0x8e, 0xcb, 0x11, 0x78, - 0xd8, 0x56, 0x50, 0x59, 0xb5, 0xa1, 0x59, 0x13, 0x9d, 0x20, 0x15, 0x5b, 0x6f, 0x2a, 0x9c, 0x70, 0x9b, 0x76, 0xec, - 0x3f, 0x95, 0xea, 0x29, 0xc0, 0x9d, 0xae, 0x85, 0xb5, 0x09, 0x29, 0x4f, 0xf0, 0xef, 0x5c, 0x39, 0xf7, 0x62, 0x79, - 0x5b, 0x36, 0xee, 0xea, 0x82, 0xba, 0xa9, 0x20, 0x65, 0x04, 0x75, 0x1d, 0xea, 0xcb, 0x4d, 0x80, 0xa6, 0xb2, 0x75, - 0x0b, 0x58, 0xd0, 0x88, 0x29, 0xa8, 0xe8, 0x08, 0x73, 0x50, 0xf1, 0x3a, 0x0b, 0x3b, 0xaf, 0x90, 0xef, 0xe3, 0x2f, - 0xc8, 0x8d, 0x0e, 0x49, 0x56, 0xfe, 0x64, 0x3c, 0xef, 0xa2, 0x72, 0xaf, 0xb4, 0x55, 0xd1, 0x54, 0x06, 0xf7, 0x80, - 0xb8, 0x91, 0x2a, 0xab, 0x38, 0x30, 0x97, 0x31, 0x9b, 0xfa, 0xb7, 0x9a, 0xbe, 0xde, 0x1c, 0x77, 0x73, 0xf3, 0x4e, - 0x07, 0xf4, 0x1a, 0x9b, 0x53, 0xb5, 0x93, 0x6a, 0xaf, 0xaa, 0xc3, 0x16, 0x70, 0xc2, 0x0a, 0x80, 0xcf, 0xac, 0x82, - 0x46, 0x43, 0x4a, 0x05, 0xf7, 0xd1, 0xa0, 0xf3, 0xb7, 0x32, 0xb2, 0x16, 0xe3, 0xc4, 0xe6, 0xea, 0xab, 0x50, 0xdb, - 0x42, 0x33, 0x08, 0x73, 0xc7, 0xb1, 0x13, 0x3e, 0x9b, 0xb0, 0x63, 0x64, 0x74, 0xe5, 0xe0, 0x0e, 0xc2, 0x53, 0x6a, - 0x52, 0xca, 0x15, 0x3a, 0xa5, 0xa8, 0x4b, 0xf8, 0xa1, 0x56, 0x78, 0x7f, 0x5e, 0x92, 0xc6, 0xf3, 0xa0, 0x13, 0x2d, - 0x7d, 0xa7, 0xda, 0x0b, 0x3f, 0xdc, 0xbd, 0xae, 0x77, 0xbb, 0x73, 0x5d, 0x60, 0x0e, 0x77, 0xae, 0x0c, 0xdc, 0x25, - 0x56, 0x3e, 0x4f, 0xdd, 0x1f, 0x24, 0xe5, 0x81, 0x1c, 0xa6, 0x51, 0xc5, 0xaf, 0xe8, 0x46, 0xff, 0xd3, 0xca, 0x1d, - 0x1e, 0x9f, 0xdc, 0x2e, 0x02, 0xe5, 0x9a, 0xc5, 0x09, 0xa4, 0xb1, 0x50, 0x1d, 0xcb, 0x56, 0x15, 0x34, 0xe8, 0xf7, - 0xc3, 0x99, 0xab, 0xfe, 0x72, 0xfe, 0xc6, 0xec, 0xaa, 0x27, 0x60, 0x8e, 0x71, 0x3d, 0x43, 0x16, 0xf7, 0xcc, 0xbb, - 0x63, 0xf1, 0x55, 0x8b, 0x7b, 0xfc, 0x10, 0x73, 0x8b, 0x65, 0x4a, 0x4b, 0xdd, 0x21, 0x11, 0xbd, 0x72, 0xed, 0xb3, - 0x9b, 0x97, 0xd1, 0xad, 0xab, 0x02, 0x62, 0x75, 0x5a, 0x5d, 0xc5, 0x69, 0x1d, 0x58, 0x87, 0x5d, 0x75, 0xf0, 0x95, - 0xa2, 0x1c, 0x4f, 0xd8, 0x34, 0x19, 0xa0, 0x38, 0xe6, 0x18, 0xf9, 0x41, 0xfa, 0xad, 0x28, 0xd6, 0x38, 0x48, 0x4c, - 0x47, 0x59, 0xf3, 0x47, 0x45, 0x01, 0x64, 0xd4, 0x53, 0x1e, 0x4d, 0x5b, 0xd3, 0x83, 0xe9, 0x8b, 0x3e, 0x2f, 0xce, - 0xbe, 0x2a, 0x55, 0x37, 0xe8, 0xdf, 0x96, 0xf4, 0x59, 0x92, 0xc6, 0xd1, 0x47, 0xc6, 0x79, 0x49, 0x25, 0x17, 0x14, - 0x55, 0x3f, 0x6d, 0x6d, 0xf6, 0xe4, 0x74, 0x47, 0xe3, 0x69, 0xab, 0xa8, 0x8e, 0x30, 0xee, 0xe7, 0x40, 0x1e, 0xef, - 0x0b, 0xd0, 0x8f, 0xe5, 0x69, 0x72, 0xcc, 0xba, 0x89, 0x72, 0x54, 0x3e, 0xc6, 0x99, 0x18, 0xdf, 0x31, 0xe4, 0x79, - 0x2b, 0xbc, 0x17, 0x13, 0xfc, 0xcc, 0x55, 0x7f, 0x74, 0x5a, 0x5d, 0xc3, 0x71, 0x0e, 0xad, 0xc3, 0xee, 0xd8, 0x36, - 0x0e, 0xac, 0x03, 0xb3, 0x6d, 0x1d, 0x1a, 0x5d, 0xb3, 0x6b, 0x74, 0xbf, 0xeb, 0x8e, 0xcd, 0x03, 0xeb, 0xc0, 0xb0, - 0xcd, 0x2e, 0x14, 0x9a, 0x5d, 0xb3, 0x7b, 0x6d, 0x1e, 0x74, 0xc7, 0x36, 0x96, 0xb6, 0xac, 0x4e, 0xc7, 0x74, 0x6c, - 0xab, 0xd3, 0x31, 0x3a, 0xd6, 0xe1, 0xa1, 0xe9, 0xb4, 0xad, 0xc3, 0xc3, 0xb3, 0x4e, 0xd7, 0x6a, 0xc3, 0xbb, 0x76, - 0x7b, 0xdc, 0xb6, 0x1c, 0xc7, 0x84, 0xbf, 0x8c, 0xae, 0xd5, 0xa2, 0x1f, 0x8e, 0x63, 0xb5, 0x1d, 0xc3, 0x0e, 0x3a, - 0x2d, 0xeb, 0xf0, 0x85, 0x81, 0x7f, 0x63, 0x35, 0x03, 0xff, 0x82, 0x66, 0x8c, 0x17, 0x56, 0xeb, 0x90, 0x7e, 0x61, - 0x83, 0xd7, 0x07, 0xdd, 0xbf, 0xaa, 0xfb, 0x8d, 0x63, 0x70, 0x68, 0x0c, 0xdd, 0x8e, 0xd5, 0x6e, 0x1b, 0x07, 0x8e, - 0xd5, 0x6d, 0xcf, 0xcd, 0x83, 0x96, 0x75, 0x78, 0x34, 0x36, 0x1d, 0xeb, 0xe8, 0xc8, 0xb0, 0xcd, 0xb6, 0xd5, 0x32, - 0x1c, 0xeb, 0xa0, 0x8d, 0x3f, 0xda, 0x56, 0xeb, 0xfa, 0xe8, 0x85, 0x75, 0xd8, 0x99, 0x1f, 0x5a, 0x07, 0x1f, 0x0e, - 0xba, 0x56, 0xab, 0x3d, 0x6f, 0x1f, 0x5a, 0xad, 0xa3, 0xeb, 0x43, 0xeb, 0x60, 0x6e, 0xb6, 0x0e, 0xb7, 0x7e, 0xe9, - 0xb4, 0x2c, 0x98, 0x23, 0x7c, 0x0d, 0x2f, 0x0c, 0xfe, 0x02, 0xfe, 0xcc, 0xf1, 0xdb, 0x3f, 0xb0, 0x99, 0x64, 0xf3, - 0xd3, 0x17, 0x56, 0xf7, 0x68, 0x4c, 0xd5, 0xa1, 0xc0, 0x14, 0x35, 0xe0, 0x93, 0x6b, 0x93, 0xba, 0xc5, 0xe6, 0x4c, - 0xd1, 0x90, 0xf8, 0xc3, 0x3b, 0xbb, 0x36, 0xa1, 0x63, 0xea, 0xf7, 0xdf, 0xda, 0x4e, 0xbe, 0xe4, 0xc7, 0xfb, 0x33, - 0xda, 0xfa, 0xb3, 0xc1, 0x57, 0xc7, 0x70, 0xb8, 0x07, 0x43, 0xe3, 0xd7, 0x26, 0xa5, 0xe4, 0xdf, 0xef, 0x57, 0x4a, - 0xbe, 0x5c, 0xed, 0xa2, 0x94, 0xfc, 0xfb, 0x17, 0x57, 0x4a, 0xfe, 0x5a, 0xf5, 0xad, 0x79, 0x53, 0xcd, 0x7d, 0xfd, - 0xc3, 0xba, 0x2a, 0x72, 0x48, 0x3c, 0xed, 0xe2, 0xa7, 0xd5, 0x25, 0x44, 0xad, 0x7f, 0x13, 0xb9, 0x2f, 0x57, 0x25, - 0x83, 0xcf, 0x08, 0x70, 0xec, 0x9b, 0x88, 0x70, 0xec, 0x87, 0x95, 0x0b, 0x56, 0x66, 0x9c, 0xcd, 0xf1, 0x27, 0xe6, - 0xdc, 0x0b, 0xa6, 0x39, 0x8b, 0x04, 0x25, 0x7d, 0x2c, 0x06, 0xbf, 0x79, 0x20, 0xcf, 0x70, 0x93, 0x59, 0x2d, 0xc2, - 0x04, 0x2c, 0x82, 0xc1, 0x92, 0x63, 0x1a, 0x67, 0x95, 0x8f, 0x2d, 0x11, 0xe7, 0xff, 0x8a, 0x7b, 0x14, 0x37, 0xbe, - 0x47, 0x03, 0xe0, 0xfa, 0xd6, 0x9d, 0xcd, 0x76, 0x15, 0xb0, 0xac, 0x13, 0x06, 0xd2, 0xc0, 0xed, 0xd7, 0xbd, 0x2f, - 0x9b, 0xe1, 0x56, 0x0c, 0xaf, 0x9b, 0x21, 0x05, 0x48, 0xaa, 0xdf, 0x3b, 0x65, 0x33, 0xde, 0xfb, 0x86, 0x59, 0xd3, - 0x7d, 0xe9, 0xf3, 0x2d, 0x36, 0xc4, 0x79, 0xc3, 0xd5, 0xa9, 0x5a, 0x97, 0xf8, 0xb4, 0xfa, 0x09, 0x29, 0x2e, 0xa8, - 0x85, 0xa1, 0x71, 0xc1, 0xa9, 0xda, 0x0a, 0xf2, 0x3b, 0xb6, 0xf4, 0xae, 0xd4, 0xa6, 0x6c, 0x9c, 0xfc, 0x6c, 0x8d, - 0xf7, 0x0a, 0xff, 0x57, 0xe0, 0x44, 0x39, 0xc7, 0x33, 0x8a, 0xe4, 0x79, 0x5e, 0x4b, 0xed, 0x92, 0x34, 0x22, 0x9b, - 0x3b, 0xeb, 0x4d, 0x5e, 0xb4, 0xd1, 0x2d, 0xc1, 0x61, 0x0b, 0xc1, 0x05, 0x61, 0xf7, 0xe4, 0x04, 0x90, 0x91, 0xa3, - 0x06, 0xfa, 0x39, 0x6c, 0x6b, 0x4c, 0xd4, 0x7b, 0x04, 0x9b, 0x98, 0x7b, 0x02, 0x2a, 0x72, 0x20, 0xd5, 0xf5, 0x34, - 0x88, 0xbc, 0xb4, 0x87, 0x6c, 0x9a, 0xc4, 0xf2, 0xb6, 0xd0, 0x63, 0xa1, 0xbf, 0xc5, 0x98, 0x4e, 0x6e, 0x98, 0x37, - 0x82, 0x9e, 0x0f, 0xdb, 0xec, 0xef, 0x72, 0x87, 0xb3, 0x75, 0xc9, 0x1c, 0xc5, 0xe9, 0x1c, 0x19, 0xce, 0xa1, 0x61, - 0x1d, 0x75, 0xf4, 0x4c, 0x1c, 0x38, 0xb9, 0xc9, 0xd2, 0x84, 0x80, 0x03, 0x44, 0x0e, 0xa6, 0x1f, 0xfa, 0xa9, 0xef, - 0x05, 0x19, 0xf0, 0xc3, 0xe5, 0x4b, 0xca, 0xdf, 0x57, 0x49, 0x0a, 0x63, 0x14, 0x4c, 0x2f, 0x3a, 0x7f, 0x98, 0x23, - 0x96, 0xde, 0x30, 0x16, 0x36, 0x18, 0xc6, 0x54, 0x7d, 0x49, 0x7e, 0x3f, 0xcb, 0xfa, 0x8c, 0xac, 0xd6, 0x46, 0x69, - 0xc8, 0xf7, 0x87, 0x70, 0x7c, 0xc8, 0x86, 0xc6, 0x77, 0x4d, 0x08, 0xf7, 0x97, 0xfb, 0x11, 0x6e, 0xca, 0x76, 0x41, - 0xb8, 0xbf, 0x7c, 0x71, 0x84, 0xfb, 0x9d, 0x8c, 0x70, 0x4b, 0xfe, 0x83, 0x85, 0x86, 0xe9, 0x3d, 0x3e, 0x6b, 0xe0, - 0x22, 0xfb, 0x5c, 0xdd, 0x27, 0x06, 0x5e, 0xd5, 0x8b, 0x9c, 0xb9, 0x7f, 0x59, 0xc9, 0x16, 0xd4, 0x28, 0x00, 0xc5, - 0x6c, 0x92, 0x3e, 0xba, 0x2e, 0xfb, 0xe0, 0xea, 0x26, 0xc2, 0x30, 0x40, 0x9b, 0xdf, 0x87, 0x69, 0x60, 0xbd, 0xe3, - 0xf7, 0x48, 0x50, 0xe8, 0xbe, 0x89, 0xe2, 0x85, 0x87, 0x89, 0x4d, 0x54, 0x1d, 0xdc, 0xe9, 0xe0, 0xc1, 0x86, 0x40, - 0x20, 0xe3, 0x28, 0x9c, 0xe4, 0x5a, 0x49, 0xe6, 0x5e, 0x10, 0xc7, 0xad, 0xde, 0x31, 0x2f, 0x56, 0x0d, 0x7a, 0x0d, - 0x8b, 0xfb, 0xac, 0x6d, 0x3f, 0x6b, 0x1d, 0x3c, 0x3b, 0xb4, 0xe1, 0x7f, 0x87, 0xb5, 0x33, 0x83, 0x57, 0x5c, 0x44, - 0x61, 0x3a, 0x2f, 0x6a, 0x36, 0x55, 0xbb, 0x61, 0xec, 0x63, 0x51, 0xeb, 0xa8, 0xbe, 0xd2, 0xc4, 0xbb, 0x2b, 0xea, - 0xd4, 0xd6, 0x98, 0x47, 0x2b, 0x09, 0xac, 0x1a, 0x68, 0xfc, 0x70, 0x05, 0x72, 0x76, 0xa9, 0x86, 0xfc, 0x9a, 0x0f, - 0xb7, 0x18, 0x17, 0x6b, 0x67, 0x97, 0x22, 0x73, 0x83, 0xda, 0x17, 0xc9, 0xfc, 0xee, 0x9d, 0x41, 0xae, 0xa2, 0xb4, - 0x31, 0xd3, 0x15, 0xe6, 0x53, 0x84, 0x3c, 0x57, 0x4c, 0x2c, 0x90, 0x47, 0x0b, 0x94, 0xc6, 0xab, 0x70, 0xac, 0xe1, - 0x4f, 0x6f, 0x94, 0x68, 0xfe, 0x7e, 0x6c, 0xf1, 0x8e, 0x75, 0x5c, 0x35, 0x6f, 0x60, 0x17, 0xa9, 0xee, 0x13, 0xb1, - 0x2a, 0xde, 0xb3, 0xd4, 0x88, 0x51, 0x8f, 0x4d, 0x4b, 0x6b, 0xba, 0xde, 0xb3, 0xfc, 0xc3, 0x67, 0xa9, 0x11, 0x3e, - 0x07, 0xdd, 0xa7, 0x6b, 0x3f, 0x79, 0x42, 0xb5, 0xf6, 0x5c, 0x31, 0xac, 0x93, 0x71, 0x91, 0x0f, 0x43, 0xf1, 0x66, - 0x11, 0xa5, 0xc4, 0xe8, 0x8d, 0x8d, 0xe8, 0xf9, 0xf3, 0x81, 0xeb, 0xe8, 0xa3, 0x98, 0x79, 0x1f, 0x33, 0x11, 0x64, - 0x3c, 0xc4, 0xac, 0xb8, 0x67, 0xbb, 0x19, 0x1a, 0xe9, 0xb5, 0xae, 0xb4, 0x4b, 0xb8, 0x33, 0xd9, 0xc2, 0x1d, 0x81, - 0x63, 0x2f, 0x77, 0x8f, 0x97, 0x80, 0x2b, 0x13, 0x19, 0xfc, 0x88, 0x3a, 0x57, 0x73, 0x2f, 0xf9, 0x21, 0x89, 0xc2, - 0x5f, 0x96, 0x10, 0x72, 0xb9, 0xb0, 0x28, 0x12, 0x97, 0xb1, 0xb6, 0x65, 0x5b, 0xb6, 0x9a, 0xb7, 0x37, 0xf5, 0x67, - 0xee, 0x3a, 0x4a, 0xbd, 0xde, 0x9e, 0x63, 0x04, 0xd1, 0x0c, 0xdc, 0xeb, 0x52, 0x3f, 0x0d, 0x58, 0x4f, 0x55, 0xc1, - 0xcf, 0x6e, 0x41, 0xd7, 0xf5, 0x8c, 0x3b, 0x3d, 0x78, 0x31, 0xe4, 0x50, 0x8f, 0xef, 0x84, 0x87, 0x2e, 0x46, 0x6e, - 0xff, 0x11, 0x68, 0xa4, 0xa6, 0x6a, 0x20, 0x32, 0x60, 0x71, 0x62, 0xca, 0x4e, 0x44, 0x3d, 0x05, 0xbe, 0xd1, 0x55, - 0x3e, 0xb6, 0x69, 0xec, 0x2d, 0x20, 0xc9, 0xef, 0x3a, 0x33, 0x38, 0x02, 0x56, 0x39, 0x06, 0x56, 0x9c, 0x17, 0x87, - 0x86, 0xd2, 0x72, 0x0c, 0xc5, 0x06, 0x2c, 0xac, 0x66, 0xc6, 0x3a, 0xbb, 0xec, 0xdf, 0x67, 0x07, 0x41, 0x68, 0xe7, - 0x11, 0x8d, 0x83, 0x2c, 0x20, 0xb8, 0x86, 0x29, 0xa5, 0x8c, 0x3d, 0x9a, 0x94, 0xce, 0xd3, 0x27, 0x5d, 0xe8, 0x39, - 0xbb, 0x4d, 0x75, 0x50, 0x28, 0x89, 0x2a, 0xbe, 0xbe, 0x46, 0x3f, 0x62, 0x3f, 0x54, 0xfc, 0x4f, 0x9f, 0x34, 0x1f, - 0x7c, 0x9c, 0x5c, 0x69, 0x7e, 0xe0, 0x59, 0x2f, 0x4d, 0x98, 0x5f, 0x68, 0xef, 0x71, 0xb2, 0xc0, 0x01, 0x11, 0xfe, - 0x2d, 0x8a, 0xc5, 0x0f, 0x6e, 0x3d, 0x61, 0x05, 0x5e, 0x38, 0x03, 0x4c, 0xe7, 0x85, 0xb3, 0x0d, 0x2b, 0x2d, 0x72, - 0x85, 0xae, 0x94, 0x16, 0x4d, 0x15, 0x16, 0x54, 0xc9, 0xcb, 0xbb, 0x73, 0x6f, 0xf6, 0x93, 0xb7, 0x60, 0x9a, 0x0a, - 0xc4, 0x0f, 0x3d, 0x77, 0x0b, 0x05, 0xef, 0x73, 0xf7, 0xe9, 0xf1, 0x82, 0xa5, 0x1e, 0x69, 0x87, 0xe0, 0x4e, 0x0c, - 0x5c, 0x82, 0xc2, 0xe9, 0x0f, 0x8f, 0x83, 0xe1, 0x52, 0x62, 0x2f, 0x22, 0x1f, 0x86, 0xc2, 0xc9, 0x97, 0x89, 0x86, - 0xa0, 0xae, 0x63, 0x90, 0x1f, 0xc2, 0xd8, 0xc3, 0xe4, 0x3e, 0x6e, 0x18, 0xa9, 0x83, 0xa7, 0xb9, 0xcb, 0x66, 0xd3, - 0x22, 0x04, 0x7e, 0xf8, 0xf1, 0x22, 0x66, 0xc1, 0x3f, 0xdc, 0xa7, 0x40, 0xcf, 0x9f, 0x5e, 0xaa, 0x7a, 0x3f, 0xb5, - 0xe6, 0x31, 0x9b, 0xba, 0x4f, 0xe1, 0x9e, 0xda, 0x43, 0xab, 0x59, 0x60, 0xe6, 0x9f, 0xdf, 0x2e, 0x02, 0x03, 0x6f, - 0xfd, 0x04, 0x8b, 0xda, 0x6e, 0x15, 0x41, 0xd6, 0xdb, 0x3b, 0xdd, 0xf5, 0x07, 0xfc, 0x12, 0x0f, 0x17, 0xc3, 0x75, - 0xe9, 0xea, 0xed, 0xf4, 0xf1, 0x5a, 0x3d, 0x0a, 0xbc, 0xf1, 0xc7, 0x3e, 0xbd, 0x29, 0x3d, 0x98, 0x40, 0xc4, 0xc7, - 0xde, 0xb2, 0x87, 0x54, 0x57, 0x2e, 0x04, 0xa7, 0x6a, 0x2a, 0xcd, 0x19, 0xbe, 0xda, 0xbd, 0x8c, 0x5b, 0x79, 0x8d, - 0x3d, 0x63, 0x57, 0x37, 0x73, 0x3f, 0x65, 0xa2, 0x2b, 0x7c, 0xc8, 0x32, 0x71, 0x7f, 0xa7, 0x9b, 0x2b, 0xde, 0xb7, - 0xad, 0xb6, 0xe2, 0x74, 0xbf, 0xeb, 0x5c, 0x3b, 0xf6, 0xbc, 0xe5, 0x58, 0xdd, 0x0f, 0x4e, 0x77, 0xde, 0xb6, 0x8e, - 0x02, 0xb3, 0x6d, 0x1d, 0xc1, 0x9f, 0x0f, 0x47, 0x56, 0x77, 0x6e, 0xb6, 0xac, 0x83, 0x0f, 0x4e, 0x2b, 0x30, 0xbb, - 0xd6, 0x11, 0xfc, 0x39, 0xa3, 0xaf, 0xe0, 0x5e, 0x44, 0xd7, 0xa0, 0xa7, 0x25, 0xe4, 0x20, 0xfd, 0xce, 0x55, 0xb5, - 0x46, 0x89, 0xea, 0xd5, 0xa8, 0x7b, 0x97, 0x18, 0x5c, 0x42, 0x24, 0xd3, 0xc1, 0xd0, 0x43, 0x5a, 0xe8, 0x32, 0x4a, - 0x72, 0x2b, 0x0c, 0xdf, 0x84, 0x87, 0x7a, 0x91, 0x75, 0x55, 0x3a, 0x41, 0xbc, 0x6e, 0x3f, 0xa1, 0xed, 0x2e, 0x85, - 0x95, 0xd3, 0x2a, 0xc7, 0xae, 0x21, 0xdf, 0xb2, 0x6e, 0x80, 0xea, 0x18, 0x10, 0x53, 0x11, 0x0e, 0x4a, 0xab, 0x45, - 0x5b, 0x02, 0x9b, 0x25, 0x2c, 0xa5, 0x22, 0x4d, 0x7c, 0x09, 0xc4, 0x46, 0xd7, 0x45, 0x9a, 0x64, 0x6c, 0x98, 0xd7, - 0x60, 0x3c, 0x9f, 0x73, 0xed, 0xab, 0x7e, 0x15, 0x5f, 0x82, 0x57, 0xbc, 0x15, 0x46, 0x37, 0x68, 0xf5, 0x71, 0xdf, - 0xdc, 0x61, 0x9c, 0x01, 0x26, 0x6c, 0xce, 0xca, 0xc0, 0xf2, 0xd0, 0xd9, 0xd5, 0x0e, 0x37, 0x10, 0xf4, 0x83, 0x3a, - 0x94, 0xd2, 0x83, 0x7f, 0x56, 0x3b, 0x3c, 0x8a, 0x85, 0x9c, 0xa2, 0x73, 0xe2, 0xc7, 0x39, 0x78, 0x12, 0x45, 0x71, - 0xea, 0xf3, 0xa3, 0xea, 0x06, 0xc5, 0x72, 0x62, 0xf1, 0xb5, 0x17, 0x48, 0x76, 0x77, 0xd2, 0x97, 0x7b, 0x39, 0xa1, - 0x7a, 0xf2, 0xa4, 0x00, 0xce, 0xac, 0xc0, 0x7d, 0xec, 0x74, 0x80, 0x4b, 0xe8, 0xb0, 0xf6, 0x56, 0x13, 0x50, 0xba, - 0x98, 0x6d, 0x73, 0x05, 0x2f, 0xd2, 0x41, 0x09, 0x33, 0x2f, 0x61, 0x60, 0xd2, 0x68, 0x87, 0xba, 0x61, 0x5e, 0x02, - 0xf9, 0xf4, 0x2a, 0x37, 0x33, 0x55, 0xef, 0x87, 0xc2, 0x5a, 0x22, 0xdc, 0x92, 0x09, 0x8f, 0x5f, 0x1d, 0x55, 0x98, - 0x9a, 0x2d, 0xe3, 0xb8, 0xc7, 0x9f, 0xfd, 0xdf, 0x3d, 0x08, 0xf4, 0x2d, 0x05, 0xf3, 0x8e, 0x0a, 0x16, 0x29, 0xf9, - 0x1a, 0xe6, 0xf4, 0x9e, 0x08, 0x3d, 0x4b, 0x4e, 0x54, 0x28, 0x52, 0x7b, 0x2a, 0xfa, 0xb1, 0xa9, 0xb9, 0x6d, 0x6b, - 0x4e, 0xc5, 0x8a, 0x02, 0xc3, 0xc7, 0xac, 0xa3, 0xc2, 0xcf, 0x55, 0x7f, 0xf2, 0xa4, 0x91, 0x38, 0x92, 0x2d, 0x51, - 0xc2, 0x52, 0x71, 0x9f, 0xd0, 0x54, 0x19, 0xef, 0xaa, 0x32, 0xea, 0xcb, 0xdb, 0x45, 0x6c, 0x26, 0x4c, 0x72, 0x69, - 0xef, 0xe1, 0xcf, 0x11, 0xf3, 0x52, 0x8b, 0xeb, 0x76, 0x35, 0x89, 0xe9, 0x30, 0x00, 0x6d, 0x64, 0x84, 0x42, 0xf2, - 0x61, 0x0e, 0x1f, 0xaf, 0xff, 0xb2, 0xe2, 0x41, 0x28, 0xa0, 0x8d, 0x4f, 0x9f, 0xec, 0x22, 0x6e, 0xe8, 0xdb, 0xd4, - 0xa3, 0xb8, 0x6d, 0x32, 0x2f, 0x10, 0xa5, 0x1e, 0xd9, 0x9f, 0xf8, 0x18, 0x6a, 0xa7, 0x3e, 0x82, 0x98, 0x14, 0xa9, - 0x62, 0xf0, 0xf6, 0xfc, 0x1b, 0x85, 0x1f, 0x00, 0xb2, 0x6e, 0xc0, 0x8b, 0x17, 0xc5, 0xc7, 0x71, 0x29, 0x3e, 0x8e, - 0xc2, 0xf3, 0x3d, 0x43, 0x66, 0xda, 0x6c, 0x9f, 0xa6, 0x10, 0x05, 0xe6, 0x64, 0xf3, 0xb1, 0x58, 0x05, 0xa9, 0xbf, - 0xf4, 0xe2, 0x74, 0x1f, 0x83, 0xe3, 0x60, 0xb0, 0x9d, 0xa6, 0xf8, 0x15, 0x64, 0x36, 0x22, 0x72, 0xa8, 0xa4, 0xa1, - 0xb0, 0x1b, 0x99, 0xfa, 0x41, 0x6e, 0x36, 0x22, 0x3a, 0xf0, 0xc6, 0x63, 0xb6, 0x4c, 0xdd, 0x52, 0x10, 0x9e, 0x68, - 0x9c, 0xb2, 0xd4, 0x4c, 0xd2, 0x98, 0x79, 0x0b, 0x35, 0x0f, 0xca, 0xb5, 0xd9, 0x5e, 0xb2, 0x1a, 0x41, 0x54, 0x21, - 0x11, 0x1e, 0x8c, 0x06, 0x08, 0x06, 0x1c, 0x00, 0x22, 0x04, 0xc5, 0xa1, 0x29, 0x3c, 0x8b, 0x66, 0x95, 0x2d, 0x55, - 0xb0, 0x54, 0x27, 0x98, 0x4a, 0x8d, 0x6e, 0x5e, 0x20, 0xdd, 0x1e, 0x47, 0xc1, 0x15, 0x8f, 0xb9, 0x91, 0xe7, 0xe4, - 0x51, 0x07, 0xc7, 0xfc, 0x3a, 0xae, 0x60, 0xb8, 0x19, 0xb5, 0x63, 0x43, 0xb2, 0xb8, 0xa6, 0x68, 0x1c, 0xfb, 0xbc, - 0x32, 0xd0, 0x4c, 0x6a, 0x19, 0xf3, 0x7d, 0x12, 0x2c, 0xe7, 0x40, 0xb2, 0x4a, 0x06, 0x3e, 0x73, 0x67, 0x90, 0xbb, - 0x7f, 0x22, 0x54, 0x48, 0xd5, 0x3e, 0x7d, 0x7a, 0x3f, 0xfc, 0xd7, 0x3f, 0x21, 0x29, 0xe9, 0xdc, 0x11, 0x31, 0x30, - 0x2e, 0xe4, 0x5a, 0x9c, 0x2d, 0x36, 0x86, 0x68, 0xdc, 0xc5, 0x26, 0x22, 0x3a, 0xa1, 0xd8, 0x5b, 0xd9, 0xf0, 0x52, - 0xc4, 0xd5, 0x83, 0x74, 0xc6, 0xba, 0x88, 0xd4, 0x31, 0x84, 0xe5, 0x1d, 0x8a, 0x18, 0x2e, 0xca, 0xdf, 0x6e, 0x5f, - 0x1e, 0x29, 0x45, 0xb8, 0xc7, 0x3a, 0x0b, 0x24, 0xda, 0x43, 0x83, 0x63, 0x4f, 0x41, 0x6e, 0x0a, 0xf9, 0xa2, 0xa4, - 0xb7, 0x0f, 0xc3, 0x9c, 0x47, 0x0b, 0x66, 0xf9, 0xd1, 0xfe, 0x0d, 0x1b, 0x99, 0xde, 0xd2, 0x27, 0x3b, 0x22, 0x94, - 0x13, 0x2a, 0xc4, 0x92, 0xe6, 0xe6, 0x39, 0xc4, 0xf8, 0x67, 0xc5, 0x54, 0x46, 0x95, 0xc0, 0x6d, 0xad, 0x42, 0x6f, - 0x79, 0xc0, 0x83, 0xa2, 0x89, 0x9a, 0x83, 0xe3, 0x7d, 0x6f, 0x50, 0xce, 0xcf, 0x63, 0x89, 0x3c, 0xb3, 0x65, 0x2a, - 0x70, 0x42, 0x69, 0x76, 0x44, 0x46, 0x9d, 0xe2, 0xc1, 0x8c, 0xa6, 0x53, 0x39, 0xa7, 0x8e, 0x55, 0x06, 0x2f, 0x9f, - 0xb4, 0x62, 0x4b, 0x47, 0x4b, 0xea, 0x69, 0xb3, 0x8b, 0xfc, 0xa7, 0xda, 0xc3, 0x64, 0x5a, 0x30, 0x66, 0x38, 0xef, - 0x1b, 0xb9, 0x79, 0xf2, 0x19, 0x7b, 0x44, 0x95, 0x38, 0x22, 0xa9, 0x66, 0x82, 0x6c, 0x60, 0xa9, 0xf6, 0x5c, 0x97, - 0xf0, 0x5c, 0x15, 0xdd, 0xc1, 0x24, 0xd6, 0xe4, 0xdc, 0x85, 0xc1, 0xa6, 0xf0, 0xa1, 0x49, 0xee, 0xbd, 0xf8, 0x51, - 0x75, 0x38, 0x9b, 0x30, 0xee, 0x7b, 0x62, 0xfb, 0x95, 0x36, 0x28, 0x6c, 0x3c, 0xbe, 0xee, 0x80, 0xe0, 0x45, 0x3b, - 0x15, 0x3c, 0xaf, 0x7c, 0x4d, 0x28, 0xdd, 0x0c, 0xbc, 0xbb, 0x48, 0x32, 0xbb, 0xe2, 0x11, 0x58, 0xce, 0xb0, 0xf4, - 0x5c, 0x78, 0x3e, 0x6f, 0x1c, 0x34, 0xa4, 0x61, 0x90, 0x9b, 0x74, 0xf3, 0xb0, 0x15, 0x04, 0x38, 0x60, 0xf7, 0x9d, - 0x35, 0xb9, 0x6e, 0x79, 0x30, 0x88, 0x3c, 0xb3, 0xe2, 0x1c, 0x96, 0x5e, 0x22, 0x5a, 0xc8, 0x8e, 0xf7, 0x61, 0x7c, - 0x94, 0x6d, 0x51, 0x30, 0x79, 0xc2, 0xbe, 0x10, 0x6f, 0xbd, 0x7e, 0xd3, 0xad, 0xb7, 0xca, 0xa3, 0x94, 0x59, 0x2f, - 0x5f, 0x87, 0xd8, 0x36, 0x5e, 0x42, 0xb6, 0x67, 0xdf, 0x4f, 0x38, 0x61, 0x90, 0x7a, 0xc9, 0x83, 0x61, 0x96, 0xea, - 0xe9, 0x5b, 0x83, 0xc4, 0x50, 0x9e, 0xdf, 0x0f, 0x2b, 0x4c, 0xf2, 0x9b, 0xf5, 0x53, 0x26, 0x62, 0x36, 0x9c, 0xa5, - 0x0d, 0x61, 0x1d, 0x9a, 0xaa, 0x10, 0x1f, 0xbe, 0xa5, 0x42, 0xb1, 0xcd, 0xb7, 0xd5, 0x2a, 0x38, 0xab, 0xa2, 0x9a, - 0xa7, 0xa9, 0x8f, 0xf0, 0x40, 0x6c, 0xd4, 0xc6, 0x52, 0x0c, 0x36, 0x91, 0xba, 0x50, 0x55, 0xa8, 0x16, 0xbc, 0xe5, - 0x92, 0x2a, 0xeb, 0xfd, 0xe3, 0x7d, 0xba, 0x4e, 0x0f, 0x68, 0x03, 0x0e, 0x8e, 0xc1, 0x32, 0x9d, 0xf6, 0x84, 0xb7, - 0x5c, 0xf2, 0x15, 0xa7, 0x5f, 0xf4, 0x66, 0x7f, 0x9e, 0x2e, 0x82, 0xc1, 0xff, 0x02, 0xf1, 0xc9, 0x8b, 0x98, 0x7c, - 0x7b, 0x03, 0x00}; + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xb4, 0xbd, 0xdd, 0x76, 0xe3, 0xb6, 0xd2, 0x28, 0x78, + 0x3d, 0xe7, 0x29, 0x24, 0x6f, 0x47, 0x9b, 0x88, 0x20, 0x5a, 0xb2, 0xbb, 0xf3, 0x43, 0x35, 0xcc, 0xed, 0x76, 0x3b, + 0xe9, 0x4e, 0xfa, 0x6f, 0xb7, 0xdd, 0xc9, 0x4e, 0x14, 0x6d, 0x93, 0x96, 0x20, 0x9b, 0x69, 0x0a, 0x54, 0x48, 0xc8, + 0x3f, 0x91, 0x78, 0x2e, 0xe7, 0x6a, 0xd6, 0x9a, 0x99, 0x35, 0xe7, 0x62, 0x2e, 0x66, 0xd6, 0x9c, 0x47, 0x98, 0xcb, + 0xb9, 0xfe, 0x1e, 0xe5, 0xbc, 0xc0, 0xcc, 0x23, 0xcc, 0xaa, 0xc2, 0x0f, 0x41, 0x4a, 0x76, 0x77, 0xb2, 0xf7, 0xd9, + 0x59, 0xbb, 0x4d, 0x81, 0x20, 0x50, 0x28, 0x14, 0xaa, 0x0a, 0x55, 0x85, 0xc2, 0x93, 0xf6, 0x34, 0x9b, 0xc8, 0xbb, + 0x05, 0x6f, 0x5d, 0xc9, 0x79, 0x7a, 0xf8, 0x44, 0xff, 0xcb, 0xe3, 0xe9, 0xe1, 0x93, 0x34, 0x11, 0x1f, 0x5a, 0x39, + 0x4f, 0x59, 0x32, 0xc9, 0x44, 0xeb, 0x2a, 0xe7, 0x33, 0x36, 0x8d, 0x65, 0x1c, 0x24, 0xf3, 0xf8, 0x92, 0xb7, 0xf6, + 0x0e, 0x9f, 0xcc, 0xb9, 0x8c, 0x5b, 0x93, 0xab, 0x38, 0x2f, 0xb8, 0x64, 0xef, 0xcf, 0xbe, 0xe9, 0x7d, 0x75, 0xf8, + 0xa4, 0x98, 0xe4, 0xc9, 0x42, 0xb6, 0xa0, 0x49, 0x36, 0xcf, 0xa6, 0xcb, 0x94, 0xb7, 0x26, 0x79, 0x56, 0x14, 0x59, + 0x9e, 0x5c, 0x26, 0xe2, 0xf0, 0x3a, 0xce, 0x5b, 0x9c, 0x5d, 0xa6, 0xd9, 0x45, 0x9c, 0x9e, 0x5d, 0x25, 0x05, 0x95, + 0x8c, 0xfb, 0xa7, 0x57, 0xf1, 0x34, 0xbb, 0x79, 0x97, 0x65, 0xb2, 0xd3, 0xf1, 0xd4, 0xcf, 0xbb, 0xe3, 0xd3, 0x53, + 0xc6, 0xd8, 0x75, 0x96, 0x4c, 0x5b, 0xfd, 0xf5, 0xba, 0x2a, 0xf4, 0x45, 0x2c, 0x93, 0x6b, 0xae, 0x3e, 0x21, 0x9d, + 0x4e, 0x14, 0x4f, 0xb3, 0x85, 0xe4, 0xd3, 0x53, 0x79, 0x97, 0xf2, 0xd3, 0x2b, 0xce, 0x65, 0x11, 0x25, 0xa2, 0xf5, + 0x2c, 0x9b, 0x2c, 0xe7, 0x5c, 0x48, 0x7f, 0x91, 0x67, 0x32, 0x03, 0x68, 0x3a, 0x9d, 0x28, 0xe7, 0x8b, 0x34, 0x9e, + 0x70, 0x78, 0x7f, 0x7c, 0x7a, 0x5a, 0x7d, 0x51, 0x55, 0xa2, 0x82, 0x9d, 0xde, 0xcd, 0x2f, 0xb2, 0xd4, 0x23, 0x34, + 0x67, 0x82, 0xdf, 0xb4, 0x7e, 0xe4, 0xf1, 0x87, 0x57, 0xf1, 0x82, 0x26, 0x6c, 0x92, 0xc6, 0x45, 0xb1, 0x9a, 0x64, + 0xa2, 0x90, 0xf9, 0x72, 0x22, 0xb3, 0xdc, 0xe3, 0x54, 0xd2, 0x9c, 0xac, 0x92, 0x99, 0x27, 0xaf, 0x92, 0xc2, 0x3f, + 0xdf, 0x9d, 0x14, 0xc5, 0x3b, 0x5e, 0x2c, 0x53, 0xb9, 0xcb, 0xda, 0x7d, 0x9a, 0xb7, 0x19, 0x13, 0x44, 0x5e, 0xe5, + 0xd9, 0x4d, 0xeb, 0x24, 0xcf, 0xb3, 0xdc, 0xdb, 0x39, 0x3e, 0x3d, 0x55, 0x15, 0x5a, 0x49, 0xd1, 0x12, 0x99, 0x6c, + 0xd9, 0xe6, 0xe2, 0x8b, 0x94, 0xfb, 0xad, 0xf7, 0x05, 0x6f, 0x45, 0x4b, 0x51, 0xc4, 0x33, 0x7e, 0x7c, 0x7a, 0x1a, + 0xb5, 0xb2, 0xbc, 0x15, 0x4d, 0x8a, 0x22, 0x6a, 0x25, 0xa2, 0x90, 0x3c, 0x9e, 0xfa, 0x3b, 0x64, 0x88, 0x7d, 0x4d, + 0x8a, 0xe2, 0x8c, 0xdf, 0x4a, 0xc6, 0x29, 0xfe, 0x94, 0x4c, 0x96, 0x97, 0x5c, 0xb6, 0x0a, 0x3b, 0x26, 0x8f, 0xac, + 0x52, 0x2e, 0x5b, 0x9c, 0xe1, 0xfb, 0x8c, 0x0a, 0xf5, 0x20, 0x87, 0x00, 0x6d, 0xa7, 0xc3, 0x2d, 0x72, 0x55, 0x3d, + 0xc9, 0x44, 0xdb, 0x94, 0x74, 0x3a, 0xc2, 0x4f, 0xb9, 0xb8, 0x94, 0x57, 0x8c, 0xb1, 0xc1, 0x10, 0x27, 0x85, 0xe5, + 0xfe, 0x25, 0x97, 0x9e, 0x20, 0x84, 0x56, 0x9f, 0x76, 0x3a, 0x9e, 0x1a, 0x79, 0xc6, 0x38, 0x22, 0xab, 0x86, 0x55, + 0xe2, 0x6b, 0x7c, 0x9f, 0xde, 0x89, 0x89, 0xe7, 0x42, 0x4d, 0xa8, 0xec, 0x74, 0x72, 0xbf, 0x80, 0x06, 0x29, 0x27, + 0xa4, 0xcc, 0xb9, 0x5c, 0xe6, 0xa2, 0xc5, 0x4b, 0x99, 0x9d, 0xca, 0x3c, 0x11, 0x97, 0x1e, 0x59, 0xe9, 0x32, 0xf7, + 0xbb, 0xb2, 0xa4, 0x31, 0xe3, 0xec, 0x10, 0xba, 0x4a, 0x3c, 0x98, 0xaf, 0x6c, 0xd6, 0xe2, 0x8c, 0x45, 0x05, 0x7e, + 0x14, 0x85, 0x3c, 0xe0, 0xdd, 0x28, 0xa2, 0x0a, 0x3a, 0x2a, 0x08, 0xcd, 0x98, 0xc7, 0xa9, 0xef, 0xfb, 0x92, 0x98, + 0xaf, 0xb8, 0x33, 0xb4, 0x90, 0x8f, 0xfa, 0xe3, 0x40, 0xfa, 0x39, 0x9f, 0x2e, 0x27, 0xdc, 0xf3, 0x24, 0x15, 0x34, + 0x27, 0xec, 0x50, 0x76, 0x3d, 0xce, 0x0e, 0x61, 0x5e, 0xdb, 0x7d, 0xc6, 0x18, 0xaf, 0xcd, 0x2c, 0x31, 0xc0, 0x1a, + 0xa8, 0x10, 0xa3, 0x15, 0x2c, 0x62, 0x39, 0xbf, 0xe0, 0x79, 0x64, 0xab, 0x0d, 0x5d, 0x02, 0x88, 0x96, 0x05, 0x6f, + 0x4d, 0x8a, 0xa2, 0x35, 0x5b, 0x8a, 0x89, 0x4c, 0x32, 0xd1, 0x8a, 0xba, 0xbc, 0x1b, 0xa9, 0x89, 0xaf, 0xe6, 0x9d, + 0x94, 0xc4, 0x13, 0xa4, 0xcb, 0x47, 0x79, 0x77, 0x30, 0xa6, 0x00, 0x25, 0xa1, 0x1c, 0xc6, 0x53, 0x30, 0x4f, 0x81, + 0x88, 0x44, 0x47, 0x84, 0xbf, 0x49, 0xfd, 0x2c, 0xf7, 0xe7, 0xf1, 0x02, 0x06, 0xc0, 0x91, 0x6a, 0x62, 0x31, 0x01, + 0xd0, 0x6a, 0x53, 0x03, 0x88, 0xf2, 0x2b, 0x5a, 0x21, 0x43, 0x9e, 0x16, 0xbc, 0x35, 0xcb, 0x72, 0x0f, 0x69, 0xa1, + 0x95, 0xcd, 0x5a, 0xb9, 0xa2, 0x8b, 0x9c, 0x4d, 0xcd, 0x4a, 0x9a, 0xe4, 0x3c, 0x96, 0xfc, 0x24, 0xe5, 0xf0, 0xcb, + 0x8b, 0xf0, 0xf3, 0x88, 0xd0, 0x84, 0x71, 0x3f, 0x4d, 0xe4, 0xeb, 0x4c, 0x4c, 0xf8, 0x30, 0x71, 0x88, 0x08, 0x27, + 0xf8, 0x48, 0xca, 0x3c, 0xb9, 0x58, 0x4a, 0xee, 0x45, 0x02, 0x6a, 0x44, 0x34, 0x21, 0x34, 0xf7, 0x25, 0xbf, 0x95, + 0xc7, 0x99, 0x90, 0x5c, 0x48, 0x26, 0x0d, 0x22, 0xa9, 0xf0, 0xe3, 0xc5, 0x82, 0x8b, 0xe9, 0xf1, 0x55, 0x92, 0x4e, + 0xbd, 0x9c, 0x94, 0x25, 0x9d, 0x30, 0x19, 0xc2, 0x50, 0x82, 0x87, 0xc7, 0x83, 0xf3, 0xa5, 0xe8, 0x38, 0x8a, 0x86, + 0x66, 0x20, 0x02, 0x06, 0x82, 0xf3, 0xf4, 0x6e, 0x99, 0xf2, 0x82, 0xc8, 0x2e, 0x13, 0x76, 0xd6, 0xf4, 0xfc, 0xc4, + 0x9e, 0x04, 0x6c, 0x73, 0x12, 0x70, 0xba, 0x4a, 0x8a, 0x20, 0xa5, 0x53, 0x3e, 0x4b, 0x04, 0x7f, 0x9b, 0x67, 0x0b, + 0x9e, 0xcb, 0xbb, 0x60, 0x49, 0x2f, 0xb9, 0x7c, 0x73, 0x23, 0x4c, 0xc1, 0x33, 0xae, 0x58, 0x5c, 0x96, 0x07, 0xd3, + 0xc6, 0xab, 0xd7, 0xf1, 0x9c, 0x17, 0xc1, 0xac, 0x51, 0xaa, 0x18, 0x4a, 0x11, 0x2c, 0xa0, 0xfc, 0xad, 0xe1, 0x34, + 0x6f, 0x66, 0xc1, 0xbc, 0x64, 0x6f, 0x2e, 0x7e, 0xe5, 0x13, 0x49, 0xaf, 0x5c, 0x8e, 0xc8, 0x39, 0xbb, 0xf2, 0x65, + 0xbe, 0x2c, 0x24, 0x9f, 0x9e, 0xdd, 0x2d, 0x78, 0x41, 0x25, 0x67, 0x9c, 0x87, 0x9c, 0xfb, 0x7c, 0xbe, 0x90, 0x77, + 0xa7, 0xd8, 0x7d, 0x10, 0x45, 0xf4, 0x92, 0x5d, 0xf9, 0x39, 0x8f, 0x27, 0xc0, 0x10, 0xf5, 0xbc, 0xbc, 0xcd, 0xd2, + 0xbb, 0x59, 0x92, 0xa6, 0xa7, 0xcb, 0xc5, 0x22, 0xcb, 0x25, 0x3d, 0x87, 0x05, 0x00, 0xd4, 0xcf, 0xe9, 0x35, 0x5b, + 0xc9, 0xac, 0x9a, 0x0f, 0x28, 0x5e, 0x15, 0x37, 0x89, 0x9c, 0x5c, 0x79, 0x92, 0xac, 0x26, 0x71, 0xc1, 0x5b, 0x4f, + 0xb3, 0x2c, 0xe5, 0xb1, 0x08, 0x38, 0xe3, 0xa1, 0xe4, 0x81, 0x58, 0xa6, 0xe9, 0xf0, 0x22, 0xe7, 0xf1, 0x87, 0x21, + 0xbe, 0x56, 0xd0, 0x06, 0xf8, 0x7c, 0x94, 0xe7, 0xf1, 0x1d, 0x54, 0x64, 0x0c, 0xaa, 0x85, 0x3c, 0xf8, 0xee, 0xf4, + 0xcd, 0x6b, 0x5f, 0xad, 0xc4, 0x64, 0x76, 0xe7, 0x71, 0x67, 0x59, 0xd3, 0x59, 0x9e, 0xcd, 0x1b, 0x5d, 0xe3, 0x04, + 0x31, 0x3e, 0xbc, 0x07, 0x04, 0xc1, 0x78, 0x5b, 0x35, 0xed, 0x42, 0xf0, 0x1a, 0x17, 0x17, 0xbc, 0x64, 0xba, 0x5f, + 0xf8, 0x27, 0x50, 0xc5, 0x1e, 0x27, 0x0f, 0x43, 0x2b, 0xf3, 0xbb, 0x95, 0x60, 0x08, 0xe7, 0x02, 0x84, 0x16, 0xc0, + 0x38, 0x89, 0xe5, 0xe4, 0x6a, 0x25, 0xb0, 0xb1, 0xd2, 0x40, 0x2c, 0xca, 0x92, 0xde, 0x19, 0xcc, 0xb5, 0x53, 0x7c, + 0xa0, 0x82, 0xb3, 0x55, 0x6c, 0xc6, 0x10, 0xb4, 0xfb, 0x14, 0xa6, 0x31, 0x50, 0xfc, 0x8a, 0x4e, 0x32, 0x71, 0xcd, + 0x73, 0xc9, 0xf3, 0xe0, 0x9a, 0xe6, 0x7c, 0x96, 0x42, 0xcf, 0xed, 0x01, 0x5d, 0x16, 0xfc, 0x19, 0x9f, 0xc5, 0xcb, + 0x14, 0x7f, 0x5d, 0xc5, 0xc5, 0xf1, 0x55, 0x2c, 0x2e, 0xf9, 0x34, 0xb8, 0x2b, 0x87, 0x8a, 0x2e, 0x7c, 0x10, 0xa2, + 0x20, 0x56, 0xc3, 0xd0, 0x88, 0x9e, 0xc8, 0x14, 0x45, 0x84, 0x5e, 0xc1, 0xda, 0x32, 0x94, 0xf4, 0xaa, 0xaa, 0xea, + 0x88, 0xa6, 0x21, 0xc8, 0xd4, 0x0b, 0x25, 0x9e, 0x5a, 0xfc, 0x56, 0x72, 0x31, 0x2d, 0x5a, 0xcf, 0xcf, 0x5e, 0xbd, + 0xd4, 0x24, 0xb1, 0x2a, 0x64, 0x2c, 0x93, 0x49, 0x2b, 0x9e, 0x4e, 0x5f, 0x88, 0x44, 0x26, 0x71, 0x9a, 0xfc, 0x8e, + 0xc8, 0x5a, 0x69, 0xa9, 0x75, 0x92, 0x78, 0x84, 0x2a, 0x06, 0x9d, 0x86, 0x21, 0x1b, 0x8d, 0x89, 0xbf, 0x58, 0x16, + 0x57, 0x80, 0x1d, 0xfd, 0x29, 0x88, 0x96, 0xec, 0xa2, 0xe0, 0xf9, 0x35, 0x9f, 0xda, 0x69, 0x2c, 0x1a, 0x4c, 0x7a, + 0x96, 0x08, 0x6c, 0xda, 0x23, 0xd4, 0x34, 0x7c, 0xd5, 0xe9, 0x8c, 0x80, 0xfb, 0x9a, 0x9f, 0xfe, 0x07, 0x7e, 0x57, + 0x78, 0x64, 0x6c, 0xda, 0x55, 0x2c, 0xc5, 0x0c, 0x0f, 0xd0, 0xcc, 0x04, 0x57, 0x02, 0xd5, 0x87, 0x2a, 0xbc, 0xd3, + 0xf1, 0xa4, 0x6f, 0x91, 0xce, 0xda, 0x83, 0xaa, 0xed, 0xc4, 0xf4, 0x63, 0x85, 0xb7, 0x7f, 0x15, 0x17, 0xce, 0xba, + 0xf3, 0x38, 0x41, 0x01, 0xa5, 0x17, 0x99, 0xe6, 0x5f, 0x9e, 0x24, 0xc4, 0xbf, 0xc9, 0x81, 0xd1, 0x4c, 0x59, 0xbb, + 0xaf, 0xdb, 0xe0, 0x7a, 0xf5, 0xa8, 0x4f, 0x13, 0x5e, 0xa0, 0x70, 0xc2, 0x69, 0x6f, 0x4b, 0x5f, 0x64, 0x47, 0x93, + 0x09, 0x07, 0x1d, 0xc6, 0x90, 0xad, 0xa3, 0x24, 0xe0, 0xf7, 0x6a, 0x65, 0x37, 0xf8, 0x83, 0xc7, 0xa9, 0xa0, 0x92, + 0x0c, 0x73, 0x87, 0x29, 0x2e, 0xbd, 0x3a, 0xcc, 0x94, 0x53, 0xe0, 0x73, 0x15, 0x9e, 0xb7, 0x36, 0x23, 0xa9, 0xc0, + 0x9e, 0x57, 0x97, 0x5c, 0x06, 0x39, 0x2d, 0xb8, 0x0c, 0x92, 0x92, 0x4d, 0x37, 0xda, 0x22, 0x61, 0x08, 0x55, 0xea, + 0x13, 0x33, 0x92, 0xe3, 0x92, 0xe2, 0x70, 0xd4, 0x8c, 0x8f, 0xe4, 0x98, 0xf1, 0xb2, 0xd4, 0x0c, 0xb0, 0x6a, 0xd2, + 0xd3, 0x8b, 0x32, 0x66, 0x79, 0xe8, 0x4f, 0xe2, 0x34, 0xc5, 0xe6, 0xc9, 0x30, 0x71, 0x7e, 0x01, 0x42, 0xb0, 0xd3, + 0x9c, 0xff, 0xb6, 0xe4, 0x85, 0x7c, 0xbf, 0x98, 0xc6, 0xb8, 0xa0, 0x63, 0x2a, 0x48, 0x09, 0xab, 0x60, 0x96, 0x5c, + 0x2e, 0x73, 0x50, 0x66, 0x60, 0x85, 0x70, 0xb1, 0x9c, 0x73, 0xf3, 0x6b, 0xdb, 0x28, 0xdf, 0x2c, 0x40, 0x08, 0x16, + 0x00, 0x9a, 0x4b, 0x4a, 0x9b, 0xd3, 0x71, 0x89, 0xf0, 0x87, 0xa1, 0xe0, 0xa6, 0x15, 0x45, 0x02, 0x56, 0xf9, 0x6a, + 0xcc, 0xfd, 0xb9, 0x17, 0x6d, 0x34, 0x12, 0x11, 0xa2, 0xa5, 0xf2, 0x50, 0xa9, 0x46, 0x73, 0x3d, 0x42, 0xee, 0xd2, + 0x2e, 0xf7, 0x53, 0x67, 0xbe, 0xf4, 0xb2, 0x60, 0x40, 0xc6, 0xdc, 0x4f, 0xc7, 0xf7, 0xd1, 0x0b, 0x2e, 0xc8, 0x57, + 0x20, 0x77, 0x37, 0xdf, 0xd9, 0x65, 0x54, 0xf5, 0xf2, 0x00, 0xd8, 0xa6, 0xd2, 0xd4, 0x01, 0xd7, 0xd4, 0xb6, 0xef, + 0x40, 0xbd, 0xdc, 0x58, 0x08, 0x9b, 0x6d, 0x2d, 0x6a, 0x63, 0x77, 0x15, 0xc2, 0xea, 0x0d, 0x95, 0x38, 0xb8, 0x99, + 0xc7, 0x09, 0x68, 0x4a, 0x0b, 0x8f, 0x93, 0x71, 0x5d, 0x82, 0x4a, 0xa2, 0x94, 0xb0, 0xfa, 0x62, 0x15, 0x94, 0x8f, + 0xc4, 0x98, 0x94, 0x55, 0xa3, 0xa3, 0x06, 0x47, 0x1b, 0x03, 0xdc, 0x86, 0x8b, 0x1b, 0x35, 0x73, 0x0b, 0x3b, 0xd3, + 0x93, 0x8b, 0xa3, 0xb4, 0xa8, 0x27, 0x1a, 0x84, 0x11, 0xa7, 0x62, 0x5c, 0x01, 0x71, 0xdf, 0x42, 0x15, 0xa4, 0xb4, + 0x5c, 0xc6, 0xcc, 0xc5, 0xb0, 0x6a, 0x42, 0x62, 0x13, 0x5b, 0x1b, 0x30, 0x4b, 0xda, 0x7c, 0xbe, 0xc4, 0x65, 0x3f, + 0x74, 0xd5, 0xe1, 0x8a, 0x7f, 0x19, 0x95, 0xb5, 0x74, 0xdb, 0x42, 0x3d, 0xa4, 0x60, 0xb5, 0x19, 0x52, 0x65, 0x6a, + 0xd6, 0x50, 0x53, 0xda, 0xa4, 0x02, 0x5d, 0x85, 0x1b, 0xcc, 0x8c, 0x10, 0x5f, 0x28, 0xa9, 0xfc, 0xa4, 0xc0, 0xbf, + 0x1e, 0x27, 0x06, 0x3c, 0x18, 0xd3, 0x29, 0x0c, 0xd5, 0x9f, 0xa5, 0xb1, 0xf4, 0x06, 0x7b, 0x7d, 0xd0, 0xaf, 0xaf, + 0x39, 0x88, 0x31, 0x42, 0xec, 0x84, 0x71, 0x98, 0x30, 0x41, 0xa4, 0xbf, 0x14, 0xc5, 0x55, 0x32, 0x93, 0xde, 0x04, + 0xda, 0x28, 0x51, 0xbf, 0xe3, 0xee, 0x90, 0x14, 0x8b, 0xc7, 0xb7, 0x46, 0x15, 0x92, 0xce, 0xd2, 0x5a, 0xba, 0x42, + 0xda, 0x61, 0xc1, 0xba, 0x6e, 0x7b, 0x00, 0xf2, 0x37, 0x54, 0xad, 0x05, 0x5a, 0xfb, 0x15, 0x8e, 0x26, 0x2e, 0x82, + 0x6d, 0xea, 0xb9, 0x2f, 0xb3, 0x97, 0xd9, 0x0d, 0xcf, 0x8f, 0x63, 0x80, 0x3a, 0x50, 0x9f, 0x97, 0xee, 0x96, 0x8a, + 0xac, 0x8a, 0xe5, 0x82, 0xe7, 0x8e, 0x0c, 0x59, 0x68, 0x98, 0x55, 0x41, 0x52, 0x28, 0x96, 0xf3, 0x96, 0x8b, 0x69, + 0x22, 0x2e, 0x59, 0x7b, 0x60, 0x69, 0x5f, 0xbd, 0x98, 0xda, 0xa2, 0xf3, 0xdd, 0x93, 0x39, 0x92, 0x9e, 0xfd, 0x79, + 0xed, 0x91, 0x52, 0xfd, 0xb1, 0xa2, 0xef, 0x14, 0x11, 0xfb, 0x36, 0xcf, 0xe6, 0x09, 0xe8, 0x03, 0xec, 0x50, 0x4d, + 0xac, 0x00, 0x9e, 0x85, 0x0d, 0x42, 0x27, 0xdc, 0x42, 0x73, 0xf4, 0xd2, 0x10, 0x97, 0x6d, 0xf4, 0xdc, 0xdb, 0xca, + 0x12, 0x75, 0xa1, 0x33, 0x36, 0x3f, 0x0d, 0xfd, 0x59, 0x96, 0x9f, 0xc4, 0x93, 0x2b, 0xd4, 0xce, 0x15, 0xf3, 0x21, + 0x65, 0x3c, 0x9d, 0x82, 0x2a, 0x9c, 0x67, 0x69, 0xaa, 0xc4, 0xb2, 0xd9, 0x4d, 0x9e, 0xbc, 0xd1, 0x82, 0xfe, 0x14, + 0x36, 0x53, 0xf1, 0x74, 0xea, 0x71, 0xdb, 0x95, 0x98, 0xf2, 0x1c, 0x36, 0xcc, 0x4d, 0x2a, 0x4d, 0x8a, 0xe3, 0x4c, + 0x08, 0x3e, 0x91, 0x7c, 0xda, 0xe9, 0x70, 0xff, 0x2a, 0x2b, 0xa4, 0x2d, 0x08, 0x7d, 0x0f, 0x74, 0xb2, 0x79, 0x76, + 0xcd, 0xeb, 0x1d, 0x56, 0xfd, 0xf9, 0x53, 0x9e, 0x72, 0x89, 0x8a, 0x91, 0x1a, 0x9a, 0xe6, 0x19, 0x76, 0xd0, 0x6c, + 0x63, 0x54, 0x1b, 0x0b, 0xaa, 0xc1, 0x3c, 0xb4, 0xcc, 0x27, 0xdb, 0x58, 0x94, 0x20, 0xb8, 0xe1, 0x57, 0xab, 0x0a, + 0x59, 0x88, 0x18, 0x13, 0xaa, 0x60, 0x68, 0x99, 0xdf, 0x43, 0xee, 0x17, 0xc9, 0xef, 0xfc, 0xd0, 0x72, 0x63, 0x24, + 0x0a, 0x50, 0xdd, 0x90, 0x21, 0xbd, 0xb3, 0xb8, 0xa8, 0x6f, 0x79, 0x0b, 0x6b, 0x54, 0x08, 0x43, 0x2c, 0x88, 0xa5, + 0x8c, 0x27, 0x57, 0xca, 0x70, 0xe0, 0x6d, 0x0c, 0xa3, 0xaa, 0xae, 0x65, 0x92, 0x5d, 0x16, 0x85, 0xc7, 0x37, 0xe7, + 0xb2, 0xb6, 0xf4, 0x09, 0xe5, 0x40, 0xc4, 0x0a, 0xcb, 0xc7, 0x71, 0x9a, 0x5e, 0xc4, 0x93, 0x0f, 0x86, 0xc8, 0xaa, + 0xb9, 0x0a, 0x43, 0xe6, 0x30, 0x52, 0x17, 0x6e, 0xba, 0x85, 0xea, 0x3c, 0xab, 0x9c, 0xa8, 0x99, 0x71, 0x49, 0x67, + 0x73, 0x5e, 0x49, 0xd9, 0xf8, 0x9a, 0x93, 0x55, 0x39, 0x4d, 0x8a, 0x7b, 0xc1, 0xba, 0xa7, 0xd1, 0x67, 0xce, 0x27, + 0xaa, 0x5d, 0xbb, 0xf4, 0xb5, 0xea, 0x6a, 0x1b, 0xd2, 0x6a, 0x89, 0x59, 0x19, 0xdf, 0x2b, 0x2e, 0x7c, 0xbe, 0x7b, + 0x72, 0x56, 0xe3, 0x1d, 0x1f, 0xa5, 0x17, 0xcd, 0xfe, 0x8d, 0x2a, 0xe5, 0xd6, 0xd5, 0x8c, 0x48, 0xa0, 0x6c, 0x70, + 0xd5, 0x28, 0xdc, 0x97, 0x0b, 0x5f, 0x6b, 0xda, 0xaa, 0xaf, 0x84, 0x79, 0xc2, 0xb7, 0x7a, 0x78, 0xe8, 0x3b, 0x9b, + 0x1d, 0x6b, 0xb1, 0x08, 0xaf, 0x03, 0xa7, 0x0e, 0x71, 0xeb, 0xc0, 0xee, 0xdf, 0x07, 0xa6, 0xa5, 0x2d, 0x2c, 0xc8, + 0x3e, 0x38, 0x4d, 0xf4, 0x3e, 0x43, 0xcf, 0x25, 0x2c, 0x9e, 0xea, 0x93, 0x9c, 0x04, 0x8a, 0xd6, 0xdc, 0x8d, 0x6e, + 0x0e, 0x5b, 0xdc, 0x3a, 0x07, 0x2a, 0x4b, 0x8d, 0xa0, 0x7b, 0xd1, 0x02, 0xd6, 0x26, 0x25, 0x62, 0x2a, 0x61, 0x98, + 0x6f, 0x11, 0x41, 0xf3, 0x36, 0x63, 0xb9, 0x5d, 0x95, 0xfe, 0x16, 0x55, 0x2a, 0x87, 0x2d, 0xb9, 0x61, 0xbe, 0xd5, + 0x58, 0x19, 0x8b, 0x8c, 0xcd, 0x21, 0x0a, 0x57, 0xb5, 0xfd, 0x58, 0xe0, 0x54, 0x2b, 0xdd, 0x1f, 0xa1, 0x5f, 0xab, + 0xe7, 0x62, 0xd1, 0xa9, 0xe5, 0xa0, 0x2b, 0x1f, 0x2a, 0x05, 0x32, 0xa9, 0x7f, 0xe8, 0x49, 0xca, 0x1d, 0xd4, 0x8e, + 0xf2, 0x31, 0x8b, 0xf5, 0xa2, 0x3c, 0xdf, 0x3d, 0xf9, 0x35, 0xc4, 0x31, 0xe7, 0x24, 0x0c, 0xe3, 0x0d, 0xbc, 0x35, + 0xf5, 0x4c, 0x34, 0xd1, 0x00, 0x8b, 0x4f, 0x50, 0x87, 0xaa, 0x44, 0x9a, 0xd1, 0x5d, 0x9b, 0x88, 0x05, 0x44, 0xa2, + 0xb4, 0xca, 0x3b, 0x1d, 0x2f, 0x51, 0x7a, 0x0a, 0x1f, 0x13, 0x2a, 0xc2, 0x90, 0xc5, 0xdb, 0xf0, 0xc7, 0x09, 0x6d, + 0x7b, 0x9e, 0xf0, 0xab, 0xcd, 0x5a, 0x18, 0xde, 0x11, 0x2f, 0xa1, 0x92, 0xac, 0xd7, 0xc2, 0xaf, 0x76, 0x74, 0x60, + 0x26, 0xd3, 0x04, 0xd8, 0xe9, 0x24, 0x8c, 0xb1, 0xc6, 0x80, 0x60, 0xfb, 0xd1, 0x36, 0x5c, 0xaf, 0xc2, 0x45, 0x5c, + 0x51, 0x75, 0xa5, 0xe0, 0x61, 0xb5, 0x63, 0xbd, 0xa4, 0x4a, 0x84, 0x77, 0x9b, 0xb8, 0x73, 0x38, 0xe0, 0xa9, 0xed, + 0xee, 0x2d, 0xac, 0x52, 0xf5, 0xed, 0xca, 0xd9, 0x6f, 0x0a, 0xbb, 0x0f, 0xcd, 0xa9, 0xde, 0xef, 0x04, 0x49, 0x49, + 0x63, 0xb2, 0x12, 0x9d, 0x4e, 0xdb, 0xab, 0x80, 0x0d, 0x0d, 0x77, 0x27, 0x00, 0xa8, 0xda, 0x35, 0xd9, 0xb7, 0x5a, + 0xbd, 0x82, 0xe9, 0x52, 0x33, 0x86, 0xc8, 0x6b, 0xf7, 0xdb, 0x8c, 0x25, 0xeb, 0x75, 0x5c, 0xa1, 0x7f, 0xbd, 0x36, + 0x1f, 0x1d, 0xbd, 0xd4, 0xed, 0x98, 0xa2, 0x4a, 0x36, 0xaf, 0xd7, 0x02, 0x0a, 0xcd, 0x37, 0x95, 0x54, 0xb5, 0xdb, + 0x2d, 0x68, 0x5b, 0x4d, 0x96, 0x4b, 0xf1, 0xdc, 0x01, 0xe9, 0xb7, 0x4d, 0xa1, 0x48, 0xca, 0xb8, 0xb8, 0x13, 0xa8, + 0xb7, 0xbc, 0x35, 0xfc, 0x6d, 0x43, 0x51, 0xe8, 0x0f, 0x61, 0xfb, 0x1f, 0xdf, 0xc4, 0x89, 0x6c, 0x59, 0x24, 0xaa, + 0xed, 0x3f, 0x30, 0x4b, 0xad, 0x02, 0xf8, 0x39, 0x87, 0xcd, 0x22, 0x08, 0x40, 0x57, 0x96, 0x4c, 0xae, 0x38, 0x98, + 0xb2, 0x8d, 0x6c, 0x37, 0xa2, 0x81, 0xb7, 0x91, 0x4c, 0x3b, 0x1d, 0xd5, 0x2c, 0xa7, 0xed, 0x6d, 0x7d, 0x97, 0xcd, + 0xcf, 0x6b, 0x7b, 0x9d, 0x05, 0xcf, 0x67, 0x59, 0x3e, 0x37, 0xef, 0xca, 0xc6, 0x6f, 0xb4, 0x42, 0x6e, 0x6b, 0xd5, + 0xd9, 0x1b, 0xb4, 0x1b, 0x68, 0xae, 0xb6, 0x17, 0x9f, 0x2e, 0x7c, 0x40, 0xa8, 0x92, 0xd5, 0x36, 0x8d, 0x19, 0xdf, + 0xe8, 0xa9, 0x67, 0xd2, 0xae, 0x76, 0xa3, 0x97, 0xb9, 0x78, 0x7a, 0x58, 0x2f, 0x80, 0xf5, 0xaa, 0x45, 0xb9, 0xd5, + 0xee, 0xa5, 0xd2, 0xee, 0x95, 0x12, 0xbc, 0x32, 0x74, 0xca, 0x4b, 0x26, 0xb4, 0x3c, 0x18, 0xc9, 0xf1, 0x10, 0xc9, + 0x8d, 0xaf, 0xd7, 0x75, 0x02, 0x83, 0xf5, 0x98, 0x3b, 0x3e, 0x02, 0xbd, 0x86, 0xa4, 0x35, 0xff, 0xe2, 0xce, 0x5a, + 0x41, 0x07, 0x3a, 0x21, 0xb3, 0x9f, 0x23, 0x25, 0x58, 0x35, 0x21, 0x5b, 0xa6, 0x53, 0x8d, 0x6d, 0x49, 0x28, 0x0f, + 0x15, 0xe6, 0x6e, 0x92, 0x34, 0xad, 0x4a, 0x1f, 0x12, 0x99, 0xaa, 0x16, 0x0a, 0x4b, 0x55, 0x6f, 0x69, 0x3e, 0xd3, + 0xd2, 0xe1, 0x7c, 0xf7, 0xe4, 0x95, 0xa7, 0x2d, 0x4d, 0xb0, 0xc9, 0x56, 0x06, 0x61, 0xee, 0x2a, 0xaa, 0xaf, 0x60, + 0x1a, 0x4a, 0x6e, 0xa9, 0xfe, 0xe8, 0x04, 0xcc, 0x92, 0x0e, 0x0c, 0x20, 0xce, 0xb1, 0x98, 0x3f, 0x2c, 0xbf, 0x35, + 0x05, 0x38, 0xd0, 0xb8, 0xab, 0xaf, 0xb9, 0x1e, 0xed, 0x36, 0x72, 0x96, 0xe4, 0xf6, 0x5b, 0x58, 0x50, 0xee, 0x40, + 0xa6, 0x5a, 0x1b, 0x7c, 0x55, 0xa9, 0x0e, 0x4d, 0x35, 0x78, 0x53, 0x2b, 0x47, 0x6f, 0x84, 0xfa, 0xfe, 0x38, 0x9b, + 0x2f, 0x50, 0xa9, 0xac, 0xd3, 0xfd, 0x25, 0xd7, 0x1d, 0x56, 0xef, 0xcb, 0x2d, 0x65, 0xb5, 0x6f, 0x70, 0xc9, 0xd6, + 0x66, 0xcc, 0x1a, 0x0e, 0xda, 0xfd, 0x72, 0x69, 0x8b, 0x2c, 0xaf, 0xe8, 0x74, 0x2c, 0x9b, 0xfc, 0xcd, 0x45, 0x96, + 0x29, 0x3c, 0xd3, 0xba, 0x1d, 0x70, 0x35, 0xe2, 0xce, 0x46, 0x59, 0x8d, 0x7d, 0x55, 0x36, 0xb0, 0xb3, 0x2a, 0xcb, + 0xe1, 0x45, 0x63, 0xf3, 0x37, 0x1a, 0xd3, 0x8b, 0x4d, 0x1d, 0x92, 0xad, 0xe6, 0xd9, 0x94, 0x07, 0x51, 0xb6, 0xe0, + 0x22, 0x2a, 0xe9, 0xc5, 0x68, 0xbb, 0x59, 0x62, 0x6c, 0xb1, 0x89, 0x35, 0x1c, 0x0b, 0x40, 0xf5, 0xe6, 0x32, 0xf4, + 0xbd, 0xd5, 0xbb, 0xba, 0xb1, 0x37, 0xb8, 0x28, 0x09, 0xf5, 0x36, 0x6c, 0xc0, 0x3f, 0xf0, 0xbc, 0x80, 0xde, 0x5d, + 0x5b, 0x5e, 0xb4, 0xef, 0x0f, 0xfc, 0xfd, 0x88, 0xa0, 0xb1, 0x30, 0xaf, 0x79, 0xe0, 0x12, 0x30, 0xe2, 0x1e, 0x72, + 0x1a, 0x73, 0x96, 0xf3, 0xba, 0xe1, 0x39, 0xe3, 0x2c, 0xe6, 0x61, 0xcc, 0xcd, 0xde, 0x3f, 0x4b, 0x93, 0xc9, 0x9d, + 0x17, 0xa5, 0x89, 0xec, 0x81, 0xa3, 0x30, 0xa2, 0x2b, 0xf5, 0x02, 0xac, 0x8d, 0x68, 0xa1, 0x2f, 0xcd, 0xa6, 0x8e, + 0x16, 0x9c, 0x45, 0xbb, 0x69, 0x22, 0x77, 0x23, 0x7a, 0xcb, 0xe0, 0x8b, 0xdd, 0xdd, 0xd5, 0xab, 0x58, 0x5e, 0xf9, + 0x79, 0x2c, 0xa6, 0xd9, 0xdc, 0x03, 0xdd, 0xeb, 0x9b, 0xe4, 0x96, 0x4f, 0xbd, 0xaf, 0x89, 0x5f, 0xa4, 0xc9, 0x84, + 0x7b, 0xfb, 0xa4, 0xdc, 0x8d, 0xe8, 0x84, 0xb3, 0x28, 0x8c, 0xba, 0xb7, 0x34, 0xe5, 0x2c, 0x7a, 0xb2, 0xbb, 0x9a, + 0xf0, 0xf2, 0x30, 0xa2, 0xa7, 0xd6, 0x0f, 0x41, 0x8f, 0x99, 0x47, 0xd8, 0xe1, 0xa9, 0x86, 0xe9, 0x38, 0x9b, 0x2b, + 0x7f, 0x44, 0x44, 0xe8, 0x0d, 0x0e, 0x44, 0x5b, 0x86, 0xd7, 0x6b, 0xa3, 0x04, 0xb5, 0x59, 0x94, 0xa1, 0x09, 0x30, + 0xea, 0x74, 0x9c, 0x32, 0xab, 0x0e, 0xd1, 0x25, 0x67, 0xb5, 0x6d, 0x37, 0x9d, 0x22, 0x4a, 0x96, 0x1c, 0x85, 0x98, + 0xf9, 0x24, 0xf4, 0x8d, 0x81, 0x23, 0x91, 0x3c, 0x8f, 0x65, 0x96, 0x8f, 0x5d, 0xa5, 0x8a, 0xce, 0x38, 0x8b, 0x46, + 0xad, 0xff, 0xe1, 0x3f, 0xfd, 0x32, 0xfb, 0x25, 0x1f, 0x47, 0xf4, 0x8c, 0xed, 0x3d, 0xf1, 0xc2, 0xc0, 0x6b, 0xf7, + 0x7a, 0xeb, 0x5f, 0xf6, 0x46, 0xff, 0x8c, 0x7b, 0xbf, 0x1f, 0xf5, 0x7e, 0x1e, 0x93, 0xb5, 0xf7, 0xcb, 0x5e, 0x38, + 0xd2, 0xbf, 0x46, 0xff, 0x3c, 0xfc, 0xa5, 0x18, 0x7f, 0xae, 0x0a, 0x77, 0x09, 0xd9, 0xbb, 0xa4, 0x0b, 0xce, 0xf6, + 0x7a, 0xbd, 0xc3, 0xbd, 0x4b, 0x3a, 0xe7, 0x6c, 0x0f, 0xfe, 0x9e, 0xb0, 0x77, 0xfc, 0xf2, 0xe4, 0x76, 0xe1, 0x45, + 0x87, 0xeb, 0xdd, 0xd5, 0x8c, 0x97, 0xd0, 0xec, 0xe8, 0x9f, 0xbf, 0xfc, 0x52, 0xec, 0xfc, 0xf5, 0x90, 0xed, 0x8d, + 0xbb, 0xc4, 0xc3, 0xe2, 0xcf, 0x99, 0xfa, 0xe3, 0x85, 0xc1, 0xe8, 0x9f, 0xad, 0x5f, 0xe4, 0x2f, 0x02, 0x40, 0xd9, + 0xf9, 0xeb, 0x2f, 0xd1, 0x93, 0x43, 0x36, 0x5e, 0x7b, 0x3b, 0xeb, 0xbf, 0x92, 0x35, 0x21, 0xeb, 0x5d, 0x12, 0xd1, + 0xe8, 0x12, 0x8c, 0xcb, 0x9c, 0xed, 0xfd, 0x75, 0xef, 0x92, 0x5e, 0x72, 0xb6, 0xb7, 0xb3, 0x77, 0x49, 0xcf, 0x39, + 0xdb, 0xfb, 0xa7, 0x17, 0x06, 0xca, 0xf2, 0xb8, 0x46, 0xbb, 0xc5, 0x1a, 0x5c, 0x35, 0x71, 0xce, 0xe3, 0xb5, 0x4c, + 0x64, 0xca, 0xc9, 0xee, 0x5e, 0x42, 0x9f, 0x31, 0x58, 0x43, 0x9e, 0x04, 0x7b, 0x91, 0x20, 0xec, 0xd0, 0x5b, 0x9d, + 0xc3, 0x54, 0x03, 0xcd, 0xec, 0x06, 0x9c, 0xaa, 0xed, 0x7e, 0x11, 0x48, 0x7a, 0x1d, 0xa7, 0x4b, 0x5e, 0x04, 0xa2, + 0x24, 0xc4, 0x1b, 0x10, 0xfa, 0x46, 0xdb, 0x4d, 0x61, 0x25, 0x2a, 0x2a, 0x12, 0x99, 0xd2, 0xb1, 0x22, 0x42, 0x3f, + 0x6c, 0x79, 0x29, 0xaf, 0xc0, 0x6e, 0x40, 0xe8, 0x35, 0xaf, 0xf9, 0x62, 0x8f, 0x98, 0x99, 0xfd, 0xb3, 0x9c, 0xf3, + 0x1f, 0xe3, 0xf4, 0x03, 0xcf, 0xbd, 0x53, 0x3a, 0xd8, 0xff, 0x9a, 0x0c, 0xad, 0x63, 0xed, 0x4e, 0xfb, 0x19, 0x40, + 0x3e, 0xea, 0x99, 0x6c, 0x6f, 0x98, 0x88, 0xa3, 0x3c, 0xbe, 0x89, 0x48, 0xcd, 0x47, 0x1b, 0x25, 0xe2, 0x3a, 0x4e, + 0x93, 0x69, 0x4b, 0xf2, 0xf9, 0x22, 0x8d, 0x25, 0x6f, 0xe9, 0xf1, 0xb4, 0x62, 0xa0, 0x8d, 0xc8, 0x0a, 0xff, 0xcc, + 0x51, 0x88, 0x65, 0x90, 0x99, 0x45, 0x02, 0x6b, 0x01, 0x98, 0x37, 0x5a, 0xe5, 0xb9, 0x71, 0x22, 0x18, 0x77, 0x87, + 0xf6, 0x3e, 0xf6, 0x06, 0x34, 0x07, 0x9e, 0x91, 0xd0, 0x98, 0x49, 0xc6, 0xd8, 0x7e, 0x18, 0x3d, 0x29, 0xae, 0x2f, + 0x0f, 0xa3, 0x00, 0x7e, 0x1d, 0x84, 0xd1, 0x93, 0x79, 0x2c, 0xaf, 0x0e, 0x23, 0xf0, 0xf2, 0x64, 0xec, 0xcc, 0x6e, + 0xa9, 0x25, 0xeb, 0x0f, 0xe5, 0x13, 0x31, 0x94, 0xdd, 0xae, 0xf5, 0xa0, 0x8c, 0xe4, 0x98, 0x16, 0x74, 0x42, 0x53, + 0xd6, 0x1b, 0xd0, 0x25, 0xeb, 0x63, 0xe5, 0xe1, 0xf2, 0x89, 0x71, 0xe2, 0x76, 0x3a, 0x5e, 0xe6, 0xa7, 0x71, 0x21, + 0x5f, 0x88, 0x29, 0xbf, 0x65, 0x4b, 0x3a, 0x61, 0x99, 0xcf, 0x6f, 0xf9, 0xc4, 0x13, 0x84, 0x4e, 0x8c, 0x79, 0x6e, + 0x48, 0x96, 0xcc, 0xa9, 0x46, 0x33, 0xc6, 0xd8, 0x59, 0x38, 0x19, 0x0d, 0xc6, 0x8c, 0xb1, 0xa8, 0xdd, 0xeb, 0x45, + 0x61, 0xc6, 0x16, 0x3c, 0xd0, 0x25, 0x7a, 0xdc, 0x93, 0xd1, 0x7e, 0xed, 0xd7, 0xc1, 0xd8, 0xb5, 0x9d, 0x66, 0xec, + 0x84, 0x04, 0xde, 0x39, 0xf7, 0x25, 0x2f, 0xa4, 0x07, 0x75, 0x09, 0x2a, 0xe1, 0x86, 0x9c, 0x9f, 0xec, 0x45, 0x5d, + 0x28, 0x45, 0x6a, 0x04, 0x67, 0xed, 0x09, 0x09, 0x32, 0x36, 0xe7, 0x01, 0x74, 0x7e, 0x12, 0x4e, 0x46, 0x7d, 0xec, + 0xfc, 0x30, 0x0a, 0xbd, 0x8c, 0x25, 0x61, 0x78, 0x86, 0x63, 0x24, 0x0d, 0x18, 0x52, 0xd6, 0xdb, 0x0f, 0xbc, 0xd4, + 0x85, 0xbe, 0x07, 0xad, 0xea, 0xe1, 0xd3, 0x82, 0x41, 0x7d, 0x9a, 0x31, 0x00, 0xaf, 0xfa, 0xec, 0x24, 0xd0, 0xbf, + 0xa3, 0x9d, 0x28, 0xbc, 0xe4, 0xc1, 0x15, 0x27, 0xd8, 0xef, 0x25, 0x5f, 0xaf, 0xe1, 0xef, 0x15, 0x0f, 0x33, 0x76, + 0x82, 0x45, 0x0b, 0x5d, 0x34, 0x87, 0xa2, 0xb3, 0x00, 0xc6, 0x45, 0x13, 0xa3, 0xc4, 0xe2, 0x96, 0x67, 0xca, 0x10, + 0xe4, 0x4e, 0x87, 0x8f, 0x64, 0x77, 0x30, 0x06, 0xe7, 0x45, 0x2e, 0x8b, 0x1f, 0x13, 0x79, 0xe5, 0x45, 0x7b, 0x87, + 0x11, 0x09, 0xa3, 0x16, 0xcc, 0xe5, 0x30, 0xee, 0x32, 0x85, 0x58, 0xd1, 0x4d, 0x79, 0x90, 0x1e, 0xb2, 0x7e, 0xe8, + 0xe5, 0x8a, 0x43, 0x17, 0x84, 0x0a, 0xcd, 0x08, 0xfb, 0x34, 0x25, 0xdd, 0x82, 0x77, 0xcd, 0xef, 0x94, 0x74, 0x6f, + 0xbb, 0x53, 0x12, 0x88, 0xee, 0x6d, 0xd7, 0x4b, 0x19, 0x63, 0xbd, 0xfd, 0x50, 0x06, 0x53, 0xe3, 0x60, 0x1b, 0x21, + 0xa9, 0xc7, 0x5d, 0x0f, 0x0c, 0xb2, 0xeb, 0x75, 0xf4, 0x24, 0x3c, 0x8c, 0x48, 0xd7, 0x33, 0x74, 0xb5, 0x57, 0x27, + 0xac, 0x3d, 0x4b, 0x59, 0x84, 0xd0, 0x7c, 0x5c, 0xd2, 0x5b, 0x6e, 0x7c, 0x47, 0xb5, 0xe0, 0x86, 0x55, 0xb5, 0x8c, + 0x9d, 0xd5, 0x2d, 0x4a, 0xaa, 0xb7, 0x9f, 0x89, 0xd2, 0x04, 0x17, 0x30, 0x50, 0xb0, 0x5d, 0xaa, 0xed, 0x57, 0x9f, + 0x66, 0xac, 0x4f, 0x0b, 0x26, 0x2b, 0x42, 0x9f, 0xb0, 0xaa, 0x22, 0x1d, 0xa5, 0x74, 0x39, 0x66, 0x17, 0xb8, 0xdb, + 0x26, 0xd6, 0xae, 0xcd, 0x53, 0xc6, 0x1b, 0xfe, 0xe5, 0x94, 0xe6, 0x84, 0x1e, 0xf9, 0x93, 0x65, 0x9e, 0x73, 0x21, + 0x5f, 0x67, 0x53, 0xad, 0xaf, 0xf1, 0x14, 0xb4, 0x4c, 0x70, 0x1c, 0x53, 0x01, 0x03, 0x5c, 0xaf, 0xe1, 0xcf, 0x41, + 0xcd, 0xf4, 0x53, 0xd5, 0x51, 0x8a, 0x0d, 0xfa, 0x93, 0x87, 0xdc, 0xc4, 0x23, 0xe0, 0xb4, 0xa0, 0x3d, 0x7f, 0x02, + 0x2f, 0xa0, 0xed, 0x82, 0x94, 0xb8, 0x6a, 0xbc, 0x84, 0x1d, 0xf9, 0x82, 0xdf, 0x62, 0x87, 0x1e, 0x21, 0x7a, 0x75, + 0x74, 0x3a, 0x13, 0x3d, 0x9e, 0x27, 0xc5, 0x10, 0x59, 0x4a, 0xe2, 0x8b, 0x6c, 0xca, 0x01, 0x27, 0x10, 0x48, 0xa0, + 0x8b, 0xdc, 0x7d, 0x1e, 0x98, 0xbc, 0x6a, 0x46, 0xd9, 0x04, 0x34, 0x1e, 0xfb, 0x1a, 0x5d, 0xc5, 0x1e, 0x21, 0xa8, + 0x13, 0x83, 0xc7, 0x0e, 0x81, 0x2a, 0x8c, 0xbd, 0x57, 0xb2, 0xe5, 0x28, 0xeb, 0x76, 0xc7, 0x54, 0xb0, 0xfa, 0x77, + 0x1e, 0x27, 0x7e, 0xb1, 0x48, 0x13, 0xe9, 0xdd, 0x82, 0xc5, 0x64, 0xcf, 0x1b, 0xf9, 0xe1, 0xdf, 0xc6, 0x24, 0xf4, + 0xfc, 0xcf, 0xc9, 0x9e, 0x5a, 0xd5, 0x92, 0x0c, 0x27, 0x8a, 0xa4, 0x56, 0xe8, 0xa1, 0x1c, 0xd0, 0x04, 0xd6, 0x44, + 0x10, 0x53, 0x11, 0xcf, 0x79, 0x90, 0xc3, 0x82, 0x33, 0x73, 0x2b, 0x28, 0xcc, 0x75, 0x90, 0xeb, 0x65, 0xee, 0x47, + 0xe1, 0x0d, 0xb7, 0xbf, 0xc2, 0x28, 0x3c, 0xab, 0x7e, 0xfd, 0x2d, 0x0a, 0x4f, 0x78, 0xf0, 0xaa, 0x24, 0x34, 0xd9, + 0xb0, 0x83, 0x70, 0x63, 0x61, 0x76, 0x09, 0xff, 0x16, 0x16, 0x7b, 0x0d, 0x92, 0x2f, 0x0c, 0x24, 0xf7, 0x34, 0x82, + 0x04, 0x61, 0xd8, 0x45, 0xe2, 0xcb, 0xf8, 0x12, 0xd0, 0x64, 0x1d, 0x17, 0x89, 0x1b, 0x36, 0x50, 0x61, 0x41, 0x3a, + 0x5c, 0x15, 0x29, 0xea, 0xb0, 0x4f, 0x56, 0xb5, 0xba, 0x5a, 0x89, 0xa9, 0x7b, 0xcf, 0x2b, 0x33, 0x25, 0xeb, 0x0f, + 0xc5, 0x13, 0x39, 0x14, 0xdd, 0x2e, 0x49, 0x74, 0x04, 0x02, 0x2e, 0x25, 0x7a, 0x0c, 0x4a, 0xb4, 0x4b, 0x0f, 0xb4, + 0x36, 0x9c, 0x7d, 0x3d, 0x9c, 0x6e, 0x37, 0x2e, 0xc9, 0xd0, 0xf9, 0x54, 0xaa, 0x4f, 0xcb, 0x52, 0x61, 0xa5, 0x49, + 0x2e, 0x5f, 0x69, 0x72, 0x01, 0xdf, 0x07, 0x63, 0x6c, 0xc2, 0xc9, 0xd6, 0x66, 0xa1, 0x51, 0xf8, 0x5e, 0x8f, 0xbe, + 0x37, 0x50, 0x8c, 0xdd, 0x03, 0x44, 0xa0, 0xdb, 0x04, 0xab, 0xbd, 0x99, 0x79, 0xb7, 0x94, 0x77, 0x07, 0x48, 0xab, + 0xbd, 0xc1, 0xb0, 0xde, 0xd6, 0x97, 0x0e, 0xc6, 0x79, 0x97, 0xdd, 0x5a, 0x44, 0x95, 0x65, 0xdc, 0xed, 0x96, 0x75, + 0x3f, 0xac, 0x59, 0x7a, 0x8e, 0x99, 0xea, 0xb4, 0x19, 0xf5, 0x61, 0x84, 0x62, 0x25, 0x06, 0x85, 0x9f, 0x08, 0xc1, + 0x73, 0x10, 0x7b, 0x8c, 0x53, 0x51, 0x96, 0x95, 0x08, 0xfe, 0x55, 0x19, 0x34, 0x18, 0x37, 0x51, 0x52, 0x8c, 0xb1, + 0x37, 0x26, 0x30, 0x46, 0x0e, 0x95, 0xd1, 0xae, 0xda, 0xc2, 0x85, 0x60, 0x01, 0x3b, 0x4e, 0x03, 0xfc, 0x93, 0x85, + 0xfe, 0x28, 0x1f, 0xd3, 0x98, 0xdd, 0x78, 0x92, 0x58, 0x47, 0x83, 0x8f, 0xac, 0xe8, 0x59, 0x92, 0x73, 0x54, 0x78, + 0x77, 0x0d, 0x10, 0xe0, 0xa3, 0xac, 0x78, 0x57, 0x9b, 0xb1, 0x18, 0x04, 0x4d, 0x08, 0x5b, 0x95, 0x37, 0xa1, 0xef, + 0x81, 0xdf, 0x38, 0xae, 0xfa, 0x31, 0xbc, 0x3b, 0xf0, 0x12, 0xd4, 0x2b, 0x62, 0x30, 0xfa, 0x24, 0x50, 0xf9, 0x0c, + 0x7d, 0xb6, 0x39, 0x70, 0xc6, 0x26, 0x58, 0x2c, 0x09, 0x3c, 0x0d, 0x19, 0xea, 0xd5, 0x60, 0xc5, 0x4a, 0x08, 0x4d, + 0x6a, 0xce, 0x42, 0x06, 0x43, 0xc6, 0x96, 0x4e, 0x61, 0xec, 0xbe, 0x52, 0x80, 0x08, 0x4d, 0xb0, 0x4d, 0x89, 0x4a, + 0xc1, 0x29, 0xdf, 0x1e, 0x4a, 0x56, 0xed, 0xae, 0x7e, 0x00, 0xd5, 0xc0, 0xfc, 0x78, 0x5d, 0xf3, 0x7f, 0x9c, 0xef, + 0x1e, 0x3d, 0x33, 0x41, 0x5f, 0xe7, 0xbb, 0x47, 0xaf, 0x74, 0xdc, 0xd7, 0x22, 0x36, 0x5c, 0x72, 0x63, 0xc7, 0x74, + 0xf4, 0xca, 0xaf, 0xde, 0x62, 0xe5, 0xf3, 0xdd, 0xa3, 0xf7, 0xdb, 0xaa, 0x41, 0x79, 0xb9, 0xd4, 0x0e, 0xa9, 0x15, + 0x4f, 0x83, 0x95, 0xe6, 0xa2, 0x81, 0x2c, 0x29, 0xb2, 0xef, 0x40, 0x94, 0x76, 0x17, 0xfd, 0x8c, 0xe6, 0xcc, 0xe3, + 0xa1, 0x22, 0x90, 0x24, 0x13, 0xa7, 0x93, 0x6c, 0xc1, 0xc3, 0xf0, 0x94, 0xf8, 0xc9, 0x1c, 0x42, 0x4f, 0x10, 0x18, + 0x49, 0xdb, 0x7d, 0x32, 0xac, 0xb3, 0xf1, 0x5c, 0x4f, 0x7c, 0x6d, 0x61, 0x55, 0x92, 0x43, 0x8c, 0xfa, 0xca, 0xff, + 0x38, 0x2c, 0x2c, 0x6a, 0x15, 0xcf, 0x85, 0x19, 0x2c, 0x14, 0xd5, 0x6b, 0x2e, 0x39, 0x2c, 0xd0, 0xac, 0x88, 0x82, + 0x4e, 0xaa, 0x08, 0x34, 0xee, 0x25, 0x34, 0xc1, 0x96, 0x4f, 0x93, 0x8b, 0x14, 0x42, 0x33, 0x24, 0x06, 0xd5, 0x90, + 0xc0, 0xd6, 0x1d, 0xe8, 0xba, 0x85, 0x8f, 0xa8, 0x4f, 0x68, 0xe1, 0x03, 0x67, 0xa4, 0x85, 0x8e, 0x5e, 0x29, 0x36, + 0x3f, 0xf9, 0x02, 0x27, 0x17, 0x3e, 0x7a, 0x06, 0x1d, 0xe8, 0xf7, 0x95, 0x01, 0xeb, 0x07, 0xb5, 0xe8, 0x24, 0xc1, + 0x01, 0x74, 0xbb, 0xd9, 0xb8, 0x04, 0xdb, 0x58, 0x11, 0x2a, 0x70, 0x51, 0xeb, 0xa9, 0x8f, 0xb7, 0xdb, 0xb5, 0xf1, + 0x31, 0x75, 0xf4, 0x9c, 0xd2, 0xbc, 0x5c, 0x54, 0x5e, 0xc1, 0x7e, 0xc3, 0x9d, 0x62, 0x3a, 0x24, 0xae, 0x83, 0xd2, + 0x13, 0x06, 0xf4, 0x3a, 0xd5, 0x1e, 0xbd, 0x40, 0x6e, 0x44, 0x14, 0xe5, 0xc2, 0x2f, 0x8c, 0x48, 0xa0, 0x18, 0x08, + 0xa5, 0xbf, 0x30, 0x2c, 0x61, 0x1f, 0x86, 0x03, 0x3c, 0x81, 0x1e, 0x57, 0x0a, 0xc1, 0x03, 0xe4, 0x82, 0x8b, 0xeb, + 0xbd, 0x35, 0xe3, 0x1e, 0x5f, 0x97, 0xcd, 0xd0, 0x48, 0x58, 0x48, 0x8a, 0xa6, 0x11, 0x8b, 0xfb, 0x16, 0x5b, 0xcf, + 0xd9, 0x87, 0xfb, 0xc9, 0xfb, 0xc8, 0x21, 0xef, 0xa7, 0x4c, 0x3a, 0xa4, 0xae, 0x5c, 0x44, 0x7e, 0xa6, 0xf7, 0xd6, + 0x39, 0xb5, 0x5d, 0x43, 0xc4, 0x82, 0xe3, 0xf9, 0x0a, 0xc3, 0x76, 0x7f, 0x73, 0x59, 0x38, 0x0a, 0x02, 0x74, 0xe3, + 0xac, 0x0a, 0xc7, 0x36, 0xf4, 0xca, 0x3a, 0x43, 0x1d, 0xf4, 0xf2, 0xb0, 0x26, 0xed, 0x07, 0x18, 0x10, 0x29, 0x9d, + 0x06, 0xc0, 0x01, 0xa4, 0xc2, 0x2f, 0xe3, 0xfc, 0x9e, 0x55, 0x78, 0x84, 0x15, 0xb8, 0x98, 0x6e, 0x7f, 0xfd, 0xb4, + 0xd4, 0xf3, 0xa3, 0x40, 0x21, 0x2b, 0xce, 0x7e, 0x55, 0x11, 0x17, 0x18, 0x84, 0x72, 0x03, 0xc1, 0x0f, 0xd0, 0xf9, + 0x87, 0xf5, 0x9a, 0x9b, 0xfd, 0x2d, 0xfc, 0x8e, 0xa2, 0xd0, 0xda, 0x5d, 0x9f, 0xb7, 0x19, 0xfb, 0x50, 0x99, 0x90, + 0xde, 0x55, 0xa6, 0x3d, 0xc0, 0x38, 0x09, 0xc0, 0x58, 0x6e, 0x0b, 0x3a, 0x1d, 0xf8, 0xf9, 0xc6, 0x54, 0xc7, 0x00, + 0x38, 0xbf, 0x52, 0xf4, 0x2a, 0x3a, 0xe2, 0xee, 0xd8, 0x75, 0xd9, 0x14, 0xa4, 0xb5, 0x9a, 0xf9, 0x0f, 0xf0, 0x65, + 0xd5, 0x06, 0x3e, 0x9d, 0xd9, 0xa7, 0x5d, 0x50, 0x0d, 0xde, 0x34, 0xc3, 0x3b, 0x1a, 0xe8, 0xf7, 0x13, 0x51, 0xf0, + 0x5c, 0x3e, 0xe5, 0xb3, 0x2c, 0xe7, 0x9e, 0x33, 0xfb, 0xa4, 0x3c, 0x73, 0xac, 0x39, 0x38, 0x3e, 0xc7, 0x12, 0xdc, + 0x18, 0x20, 0x3e, 0xbd, 0x41, 0x6b, 0xf0, 0x79, 0xf3, 0xab, 0x0f, 0x9d, 0xce, 0x4d, 0x85, 0x26, 0x12, 0x56, 0x50, + 0x38, 0x8c, 0x42, 0xc9, 0x63, 0x6e, 0x86, 0x60, 0xb7, 0x98, 0x66, 0xd1, 0xba, 0xeb, 0xfd, 0x39, 0xe3, 0xe5, 0xae, + 0xe1, 0x94, 0x7a, 0x97, 0xdb, 0xd0, 0x93, 0x41, 0xea, 0x31, 0xc7, 0x33, 0xae, 0xe3, 0x42, 0x6d, 0xdf, 0xc7, 0x80, + 0x24, 0x4f, 0x80, 0xee, 0x5b, 0x5b, 0xc8, 0x3c, 0x65, 0xb7, 0x4d, 0x65, 0xf8, 0x8e, 0x83, 0x43, 0x82, 0x0a, 0xff, + 0x0a, 0x43, 0x41, 0xdd, 0x65, 0x40, 0x88, 0xab, 0x48, 0x03, 0x68, 0xa1, 0x12, 0x12, 0xe0, 0x27, 0xb2, 0x65, 0xfe, + 0xc2, 0x93, 0x35, 0x6d, 0x42, 0x59, 0xd0, 0x3d, 0xb5, 0x86, 0x08, 0xc8, 0x68, 0x5f, 0x87, 0x26, 0x99, 0x76, 0x87, + 0x1c, 0x3f, 0xa2, 0x1a, 0x1d, 0xa2, 0x3e, 0xf8, 0x52, 0x8f, 0x40, 0x73, 0xa9, 0x6b, 0xae, 0x5c, 0x1e, 0x86, 0xa9, + 0x54, 0x31, 0x05, 0xce, 0xe0, 0xae, 0x95, 0xa7, 0x97, 0x57, 0x6c, 0x16, 0xc1, 0xb8, 0xd5, 0xa8, 0x2d, 0x3f, 0x80, + 0x71, 0x74, 0xc9, 0x9d, 0x89, 0x72, 0x9c, 0x0a, 0xcf, 0x5d, 0x99, 0xf8, 0x0e, 0x42, 0x1e, 0x6a, 0x61, 0x1b, 0x47, + 0xcf, 0x69, 0x4e, 0x13, 0x87, 0x5b, 0xc6, 0x2a, 0x72, 0x25, 0x41, 0x3f, 0xa1, 0x62, 0x71, 0xa1, 0x50, 0x5c, 0x5a, + 0x05, 0x76, 0xeb, 0x7e, 0xde, 0x78, 0xc7, 0xd6, 0x54, 0xea, 0x3c, 0x37, 0x70, 0x1c, 0xe4, 0x4c, 0x8c, 0x92, 0x31, + 0xcd, 0x15, 0x1b, 0x8d, 0x09, 0x4d, 0xba, 0xdd, 0x61, 0xe2, 0xee, 0xb1, 0x2b, 0xd8, 0x72, 0x88, 0x7d, 0x05, 0xfa, + 0xad, 0x89, 0xa1, 0x04, 0xf6, 0x77, 0x3a, 0xf6, 0x38, 0x01, 0x83, 0xea, 0xd1, 0x3b, 0xcf, 0x65, 0x47, 0x35, 0x91, + 0xa5, 0x2c, 0xf1, 0xe6, 0xe5, 0x5b, 0x54, 0x61, 0x28, 0x18, 0x6b, 0xc9, 0xd0, 0x5d, 0xc5, 0x4f, 0x87, 0x66, 0x02, + 0x12, 0xdc, 0x19, 0x38, 0x6d, 0x0c, 0x55, 0x89, 0x52, 0xb2, 0x21, 0xac, 0x89, 0xc9, 0xb2, 0x2c, 0x78, 0xe5, 0x35, + 0x76, 0xd7, 0xc8, 0x2b, 0xd6, 0x8c, 0x78, 0x42, 0xae, 0x5a, 0x2d, 0x45, 0x80, 0x00, 0x56, 0x56, 0x49, 0x5f, 0x69, + 0xe5, 0x05, 0xb8, 0x99, 0x56, 0xd0, 0xbd, 0xad, 0xc1, 0x5b, 0x46, 0x7d, 0xff, 0xb8, 0xca, 0xb1, 0x45, 0x6e, 0x80, + 0x7b, 0xaf, 0x92, 0x1c, 0x83, 0x4f, 0x90, 0x1c, 0xba, 0x57, 0x03, 0x33, 0x08, 0xf4, 0x9a, 0xf0, 0xc8, 0xeb, 0xc2, + 0x23, 0xb1, 0x93, 0x71, 0x08, 0x5b, 0xc8, 0x51, 0x1f, 0x0c, 0x17, 0x51, 0x04, 0x8f, 0x03, 0xf5, 0xe8, 0xf0, 0x55, + 0x65, 0x1d, 0xf4, 0x84, 0xd5, 0x9e, 0x89, 0x0f, 0x31, 0xb6, 0x1e, 0x2e, 0x22, 0xa4, 0x65, 0x4d, 0x40, 0x46, 0x08, + 0x0b, 0x6b, 0xf9, 0x07, 0x88, 0xeb, 0xac, 0x5d, 0x89, 0x45, 0xa5, 0x02, 0xb9, 0x1f, 0xd1, 0x98, 0xb5, 0x71, 0xff, + 0x92, 0x54, 0xa1, 0xf9, 0xae, 0x10, 0xa0, 0x7d, 0xd0, 0x92, 0xda, 0x37, 0x68, 0xc9, 0xda, 0xc6, 0xca, 0x69, 0xec, + 0x50, 0xe1, 0x73, 0xc6, 0x9d, 0xf5, 0x9e, 0x33, 0x4e, 0x33, 0xaa, 0x22, 0x33, 0x38, 0x4b, 0x46, 0x7d, 0x30, 0x87, + 0xf4, 0x87, 0xd9, 0x93, 0xa4, 0xda, 0x39, 0x65, 0xdd, 0x2e, 0x29, 0x4c, 0x7f, 0xf9, 0x48, 0x74, 0xb3, 0x31, 0x95, + 0x34, 0x03, 0x8d, 0x06, 0xe5, 0x84, 0x57, 0x54, 0x3d, 0x8e, 0xb2, 0x31, 0xa1, 0xf1, 0x7a, 0x0d, 0xe0, 0x14, 0x64, + 0xbd, 0x2e, 0x5c, 0x70, 0x46, 0xd9, 0x18, 0xbf, 0xf9, 0x10, 0x72, 0xf6, 0x01, 0x85, 0xce, 0x07, 0x10, 0x98, 0x5d, + 0xe6, 0x15, 0x61, 0x18, 0x45, 0xa4, 0x9b, 0x8c, 0xb2, 0xee, 0x60, 0xec, 0xf0, 0x93, 0x51, 0x36, 0x66, 0x45, 0x19, + 0x77, 0x3a, 0x6d, 0xe3, 0xf7, 0xfb, 0x15, 0xe4, 0x06, 0xfc, 0xb3, 0x42, 0xa1, 0x17, 0xd6, 0x08, 0xab, 0xb9, 0x71, + 0xb4, 0x13, 0xae, 0xb1, 0x6e, 0xea, 0xd5, 0xbc, 0xf2, 0xb6, 0x12, 0xe5, 0x08, 0x45, 0x59, 0xd2, 0x1b, 0xde, 0x08, + 0x9a, 0x7d, 0xb5, 0xda, 0x16, 0x8a, 0xe4, 0xfb, 0x7e, 0x9c, 0x5f, 0xa2, 0xed, 0xb9, 0xd0, 0x40, 0x23, 0x55, 0x1e, + 0x28, 0x00, 0xdd, 0x2e, 0x47, 0xb6, 0x97, 0x31, 0x53, 0x80, 0xeb, 0x8d, 0x06, 0x2f, 0x4b, 0x7a, 0xf6, 0xaf, 0x75, + 0xf7, 0x68, 0xb3, 0x3b, 0x5f, 0x66, 0x97, 0x97, 0xe9, 0x36, 0x4c, 0xd0, 0x76, 0x9b, 0x2b, 0xb2, 0xf8, 0x00, 0x23, + 0x3d, 0x79, 0xb8, 0x6b, 0x67, 0xd1, 0x29, 0x18, 0xaa, 0x02, 0x07, 0x80, 0xc7, 0x4d, 0x15, 0x25, 0x99, 0x79, 0x5e, + 0x83, 0x42, 0xc3, 0xf0, 0x03, 0x71, 0x36, 0x79, 0x9b, 0x3c, 0x5a, 0xa1, 0xa5, 0xd3, 0x01, 0xed, 0x15, 0x74, 0x19, + 0x7f, 0x12, 0x2f, 0xe4, 0x32, 0xc7, 0x28, 0x41, 0xf3, 0x0c, 0xc5, 0x70, 0x56, 0x00, 0xcb, 0xe0, 0x01, 0x0a, 0x16, + 0x71, 0x51, 0x24, 0xd7, 0xaa, 0x4c, 0x3f, 0xc3, 0xd1, 0x03, 0x4d, 0x5d, 0x42, 0xa9, 0x46, 0x39, 0x19, 0x1a, 0x0a, + 0xaa, 0x13, 0xcb, 0xc9, 0x35, 0x17, 0xf2, 0x65, 0x52, 0x48, 0x2e, 0x78, 0xee, 0xa0, 0x49, 0x2d, 0x48, 0x42, 0x93, + 0xc6, 0x57, 0xf1, 0x74, 0xfa, 0xe0, 0x27, 0xbc, 0x2e, 0x0d, 0xaf, 0x62, 0x31, 0x4d, 0x55, 0x27, 0x38, 0x47, 0x4a, + 0xea, 0x57, 0x35, 0xdc, 0xd8, 0x8b, 0x4a, 0x26, 0xdb, 0xa8, 0x5a, 0xc3, 0x95, 0x42, 0x74, 0xe1, 0x85, 0x35, 0x6a, + 0xa7, 0xdc, 0xe1, 0x25, 0x7e, 0xbd, 0xa3, 0xb2, 0xa4, 0xcf, 0xee, 0xd9, 0x4c, 0xda, 0xc8, 0x9c, 0x06, 0x5f, 0xc4, + 0x99, 0xfc, 0xe2, 0x7e, 0xed, 0xfb, 0x95, 0x61, 0x9a, 0x86, 0x51, 0x8a, 0x8f, 0xf3, 0x6f, 0x45, 0x16, 0x64, 0x65, + 0x28, 0x01, 0xe0, 0x7a, 0xc3, 0xd9, 0xea, 0x55, 0x50, 0x70, 0xfa, 0x36, 0xb8, 0xa5, 0x47, 0xc1, 0x84, 0xd3, 0xe3, + 0x60, 0x40, 0x5f, 0x06, 0x17, 0x9c, 0xbe, 0x0b, 0x4e, 0x39, 0x7d, 0x16, 0x4c, 0x39, 0xfd, 0x21, 0xf8, 0x95, 0xbe, + 0x08, 0x8e, 0x39, 0x7d, 0x1e, 0xbc, 0xa2, 0xaf, 0x83, 0x33, 0x4e, 0xdf, 0x07, 0x27, 0x9c, 0x3e, 0x0d, 0x6e, 0x38, + 0xfd, 0x26, 0x78, 0xc6, 0x4b, 0xfa, 0x01, 0x7d, 0x52, 0x69, 0x22, 0x9f, 0xcb, 0x79, 0xda, 0x38, 0xdb, 0x30, 0xfc, + 0x00, 0x4e, 0xd7, 0x5b, 0x4e, 0x8f, 0x39, 0xa1, 0x5e, 0x55, 0x6d, 0xab, 0xfb, 0xeb, 0xc0, 0x3f, 0xf0, 0x0f, 0xb4, + 0xfb, 0xeb, 0x48, 0x59, 0xe5, 0xa9, 0x30, 0x76, 0xf9, 0x9c, 0x89, 0x50, 0xbb, 0xca, 0x95, 0x12, 0x1a, 0x86, 0x92, + 0x26, 0x2c, 0x57, 0xfa, 0xf0, 0xdb, 0x38, 0x97, 0xbb, 0x0d, 0xc6, 0x6c, 0xb4, 0xa8, 0xe6, 0x67, 0x78, 0x5e, 0xc1, + 0xfd, 0x8e, 0x25, 0x66, 0x5b, 0x2a, 0xeb, 0x6a, 0xee, 0x31, 0xc8, 0x64, 0x38, 0xd5, 0x63, 0xbc, 0xd5, 0x61, 0xb8, + 0x2a, 0xed, 0x96, 0x30, 0xd1, 0xdb, 0x35, 0x42, 0x93, 0x92, 0xfe, 0x5a, 0x73, 0xd7, 0xbd, 0x6e, 0x2c, 0xe5, 0x8b, + 0x4f, 0xe5, 0x22, 0x0a, 0x52, 0xeb, 0x99, 0x04, 0x52, 0x43, 0xca, 0x2a, 0xcd, 0xe4, 0x3f, 0xcb, 0x8c, 0x4b, 0xff, + 0xde, 0xc8, 0x3a, 0x6c, 0x7c, 0x4b, 0x0c, 0xc1, 0xd0, 0xa5, 0x8c, 0x5a, 0x47, 0x0d, 0x04, 0x31, 0xee, 0x98, 0x64, + 0x29, 0x77, 0x7c, 0xb6, 0x4a, 0x8f, 0x71, 0x1a, 0xf0, 0x74, 0x20, 0xd6, 0xa6, 0x03, 0xbb, 0xde, 0x81, 0xb3, 0xf1, + 0x33, 0x41, 0x33, 0xb6, 0x80, 0x50, 0x05, 0xb1, 0xed, 0xc6, 0x19, 0xeb, 0x11, 0x98, 0x27, 0x9c, 0xf6, 0x60, 0x24, + 0x5b, 0x30, 0x45, 0xb6, 0x86, 0xf6, 0x69, 0x44, 0x6c, 0xbe, 0xa9, 0x3a, 0x08, 0xfd, 0x9a, 0xba, 0xd5, 0xee, 0x93, + 0xfb, 0x02, 0xf2, 0x54, 0x63, 0xdb, 0x5f, 0xde, 0xdf, 0xde, 0x00, 0xa8, 0x45, 0x21, 0xca, 0x2c, 0xcc, 0x37, 0x65, + 0x39, 0x7c, 0xad, 0xa8, 0x4f, 0x6f, 0x1d, 0xf0, 0x20, 0xe2, 0xeb, 0x7a, 0xe0, 0xf8, 0xaf, 0xb8, 0x54, 0x74, 0x85, + 0xe7, 0x77, 0xd3, 0x3c, 0x96, 0x5c, 0xaf, 0x29, 0x70, 0x32, 0xbf, 0xb4, 0xef, 0x82, 0xd7, 0xa5, 0x5a, 0x31, 0xaf, + 0x38, 0xab, 0x7d, 0xd4, 0x5c, 0x89, 0xaf, 0xf8, 0xe6, 0x87, 0xd4, 0xab, 0x7d, 0xb2, 0x75, 0x55, 0x3e, 0xf2, 0xf7, + 0xad, 0x53, 0xfa, 0x2d, 0x53, 0x3e, 0x45, 0x5c, 0x95, 0xc2, 0x71, 0x2a, 0x2d, 0x0b, 0x99, 0xcd, 0x75, 0x2b, 0x85, + 0xaf, 0x4e, 0x67, 0xa1, 0xbd, 0x2c, 0x80, 0xe3, 0x6f, 0xb5, 0x33, 0x2d, 0xe0, 0x18, 0x5e, 0xdd, 0xff, 0x41, 0x49, + 0x4a, 0xfa, 0xfa, 0x4f, 0x9c, 0xe2, 0xa9, 0x9d, 0xdb, 0xa1, 0x6f, 0x81, 0x7d, 0xb0, 0xd7, 0x2e, 0x07, 0x59, 0x7d, + 0x48, 0xc4, 0x34, 0xc8, 0xa9, 0x89, 0x7c, 0x87, 0xd3, 0x19, 0x82, 0xc6, 0xce, 0xb2, 0xdd, 0x76, 0x8c, 0x07, 0xb7, + 0x4c, 0x09, 0x6e, 0xde, 0x62, 0x47, 0x01, 0xff, 0xc8, 0x47, 0xb0, 0x85, 0x02, 0xb7, 0xa1, 0x09, 0xda, 0x42, 0x4b, + 0x65, 0x54, 0x70, 0x29, 0x79, 0x1e, 0xc1, 0x81, 0x17, 0xde, 0x38, 0xf0, 0xc2, 0x1b, 0x07, 0x5e, 0x54, 0x13, 0x42, + 0x2b, 0x43, 0xfa, 0xfb, 0x58, 0x1f, 0x70, 0x89, 0xd4, 0x96, 0x56, 0x79, 0x0a, 0x4a, 0x26, 0xcc, 0x29, 0x11, 0xfc, + 0xc4, 0xaa, 0xad, 0x00, 0xb9, 0x7b, 0x44, 0x04, 0x75, 0x2d, 0xe7, 0x94, 0x88, 0xd8, 0x1a, 0x12, 0x9d, 0xd3, 0x84, + 0x72, 0xd8, 0xc5, 0xc0, 0x51, 0x91, 0x44, 0x24, 0x78, 0xe2, 0x64, 0x8b, 0xb9, 0x05, 0x3f, 0x3d, 0xf6, 0x72, 0xc3, + 0x1a, 0xd1, 0x02, 0x22, 0xcb, 0xb2, 0x84, 0x98, 0x48, 0x67, 0xb0, 0xdb, 0x41, 0xb5, 0x47, 0x2b, 0x1d, 0x78, 0x55, + 0xd0, 0xe1, 0xf0, 0x8f, 0x81, 0x58, 0xd6, 0xbc, 0xc2, 0xef, 0x45, 0xa1, 0x88, 0x9d, 0x4f, 0x5b, 0x53, 0x3e, 0xc9, + 0x30, 0x00, 0xa0, 0x95, 0x66, 0x13, 0x34, 0x7e, 0x06, 0xad, 0xa8, 0x9b, 0x13, 0xc7, 0xf4, 0xfd, 0x4d, 0x65, 0xf3, + 0xd0, 0x34, 0xed, 0x98, 0x02, 0x74, 0x34, 0x42, 0xf8, 0x56, 0x47, 0x34, 0x92, 0xc0, 0x6b, 0x0a, 0x24, 0xb9, 0x19, + 0x2a, 0x6d, 0x79, 0x6c, 0x2d, 0xcc, 0x6a, 0xf3, 0x54, 0x06, 0xa1, 0x79, 0xa8, 0x29, 0xe0, 0xbe, 0x93, 0x8b, 0x08, + 0x92, 0x09, 0xbf, 0x27, 0x26, 0xec, 0xd0, 0x02, 0xff, 0xc2, 0x31, 0xd8, 0x7c, 0xe3, 0xad, 0xc0, 0x55, 0x46, 0xf1, + 0x38, 0x16, 0xac, 0x17, 0x67, 0xf1, 0x0c, 0x4a, 0xe5, 0xe6, 0xfe, 0xc6, 0x11, 0xa8, 0x2a, 0x06, 0xd7, 0x9e, 0x02, + 0x02, 0x7e, 0x23, 0xfc, 0xea, 0x1c, 0x10, 0xfc, 0x7e, 0xa7, 0x56, 0x96, 0xaf, 0xd1, 0xc8, 0x6d, 0x54, 0x86, 0x74, + 0x23, 0x35, 0xf4, 0x10, 0xea, 0xa7, 0x31, 0x75, 0x37, 0x60, 0xf2, 0xa8, 0xa0, 0xd5, 0x8e, 0x7e, 0x8d, 0x6d, 0xa5, + 0xb7, 0x6a, 0x44, 0x82, 0x77, 0xfd, 0x50, 0xba, 0x61, 0x70, 0xfe, 0x6f, 0x4b, 0x9e, 0xdf, 0x9d, 0x72, 0x80, 0x00, + 0x54, 0x25, 0xa2, 0x85, 0x36, 0x9e, 0xa7, 0xb5, 0x67, 0xac, 0x38, 0x9e, 0xb1, 0x92, 0xa5, 0x31, 0xe0, 0xe4, 0xce, + 0xac, 0x89, 0x20, 0x09, 0x43, 0xc5, 0x6a, 0x94, 0x50, 0x34, 0x87, 0xc1, 0x9c, 0x13, 0x55, 0x8d, 0x13, 0x58, 0x5c, + 0x9f, 0xc0, 0xd2, 0x36, 0x7e, 0x0c, 0xa4, 0x2b, 0xcb, 0x92, 0x54, 0x82, 0xf3, 0x1b, 0x8e, 0x80, 0xeb, 0x6f, 0x4d, + 0xb0, 0x80, 0xb3, 0xc4, 0x8c, 0xb7, 0xa5, 0x66, 0x2c, 0x62, 0xb1, 0x7a, 0x4b, 0x3d, 0xd1, 0xb6, 0x51, 0x2f, 0x75, + 0x99, 0x49, 0xe0, 0xac, 0x87, 0x4b, 0xf6, 0x04, 0x7c, 0x34, 0x56, 0xd1, 0xa8, 0xf7, 0x5b, 0x9d, 0x89, 0x85, 0x56, + 0xa1, 0x1a, 0xce, 0xef, 0x4b, 0xce, 0x56, 0x47, 0x67, 0x67, 0xef, 0x5e, 0x3c, 0x7d, 0x7f, 0x76, 0x12, 0x0c, 0xe8, + 0xf1, 0xf3, 0x17, 0x2f, 0x9f, 0x05, 0xfb, 0xf4, 0xed, 0xbb, 0x37, 0x6f, 0x4f, 0xde, 0x9d, 0xfd, 0x14, 0x1c, 0xd0, + 0xa7, 0x6f, 0xde, 0xbc, 0x3c, 0x39, 0x7a, 0x7d, 0x5e, 0x55, 0x7b, 0x44, 0x4f, 0x7e, 0x38, 0x79, 0x7d, 0x16, 0x3c, + 0xa6, 0x27, 0x2f, 0x4f, 0x5e, 0xc1, 0xd3, 0x17, 0x25, 0x7d, 0x87, 0x81, 0x35, 0x9e, 0x3e, 0x91, 0xad, 0xe3, 0x46, + 0x2a, 0x77, 0x4e, 0xc0, 0x4d, 0xc8, 0x88, 0x2c, 0x09, 0xfd, 0x7d, 0xab, 0x6e, 0x4b, 0x56, 0x9f, 0xa4, 0x91, 0x9e, + 0x35, 0xe2, 0xd3, 0x8f, 0x65, 0xdd, 0x6d, 0x62, 0x8d, 0xc7, 0x09, 0x13, 0xa5, 0xf1, 0xd7, 0xd4, 0xdb, 0x33, 0x4a, + 0x03, 0x48, 0x0e, 0xe7, 0x79, 0xb5, 0xa9, 0xeb, 0xa8, 0x01, 0x95, 0x25, 0x5d, 0xbd, 0x08, 0x9e, 0xf2, 0x92, 0xbd, + 0xe1, 0xf4, 0x07, 0x1d, 0x55, 0xf5, 0x9c, 0x63, 0xb8, 0x52, 0xe3, 0x14, 0xb5, 0x1b, 0xb5, 0xf4, 0x72, 0x43, 0x1b, + 0xe5, 0x1b, 0x06, 0xea, 0x84, 0x49, 0xd7, 0x22, 0x0b, 0xa6, 0x1f, 0x74, 0x86, 0x1d, 0x1d, 0x01, 0xe1, 0x56, 0x44, + 0x41, 0xd4, 0x41, 0xa1, 0xa7, 0xdc, 0xcb, 0xeb, 0xea, 0xe6, 0x73, 0xb0, 0x01, 0xe1, 0xd1, 0xeb, 0xad, 0xc5, 0x9c, + 0x72, 0xc7, 0xf0, 0x67, 0xcc, 0x06, 0x12, 0x63, 0xd2, 0x1b, 0x76, 0xac, 0x58, 0x15, 0xbe, 0xa2, 0x19, 0x03, 0x17, + 0x07, 0x07, 0x00, 0x32, 0xe3, 0x8f, 0xc1, 0x57, 0x7f, 0x47, 0x63, 0x11, 0x55, 0xd5, 0xc0, 0x27, 0x88, 0x16, 0xa4, + 0xba, 0x9f, 0x0c, 0xc7, 0xf0, 0x1e, 0x7c, 0x96, 0x31, 0x3e, 0x41, 0x30, 0x35, 0xd4, 0x82, 0xc8, 0x19, 0x7d, 0x0e, + 0x2c, 0x59, 0xaf, 0xb3, 0x2a, 0xd2, 0x1d, 0xc7, 0x8a, 0x6e, 0x21, 0xb4, 0x7d, 0x58, 0xc3, 0xd7, 0x0f, 0x1b, 0x86, + 0xaf, 0x1f, 0x20, 0x2e, 0xbf, 0x69, 0x53, 0x4e, 0xb4, 0x05, 0xac, 0x3a, 0xe1, 0x4b, 0xdf, 0x31, 0xe3, 0x9e, 0x04, + 0x52, 0xe4, 0x4a, 0xe3, 0x46, 0xee, 0xc2, 0x09, 0x7d, 0xcf, 0xd9, 0xaa, 0xa4, 0x3f, 0x2a, 0xc6, 0xc6, 0xde, 0x43, + 0x15, 0xae, 0xed, 0xcc, 0xf4, 0x5b, 0x35, 0xb5, 0x6a, 0x47, 0xfb, 0x3d, 0xfe, 0x58, 0x71, 0x63, 0x90, 0xd6, 0x73, + 0x67, 0xec, 0x6e, 0x25, 0xfd, 0x6d, 0xcb, 0x6e, 0xa3, 0x7e, 0x3e, 0x0d, 0x24, 0xd4, 0x30, 0x79, 0xc2, 0xc4, 0x30, + 0xe9, 0x76, 0x89, 0xca, 0x8b, 0xc0, 0xc1, 0xda, 0x98, 0xd8, 0x65, 0x9f, 0x97, 0xf4, 0x3b, 0xce, 0xde, 0x71, 0xaf, + 0xae, 0xfb, 0xff, 0xce, 0x9b, 0x6b, 0x23, 0x99, 0x79, 0x7a, 0x0b, 0x4f, 0x74, 0xcc, 0x7d, 0x9b, 0xb1, 0x97, 0xdc, + 0xc7, 0x25, 0x5b, 0x8f, 0x73, 0xca, 0xf9, 0x82, 0xc7, 0xd2, 0x23, 0xad, 0x49, 0x2c, 0x5a, 0x99, 0x48, 0xef, 0x5a, + 0x17, 0xbc, 0xb5, 0x2c, 0xf8, 0xb4, 0x95, 0x88, 0x16, 0x78, 0xcf, 0x5b, 0xfc, 0x76, 0x91, 0xf3, 0x02, 0xd5, 0xb6, + 0x88, 0x94, 0x53, 0xe9, 0x9c, 0x44, 0x6d, 0xe5, 0x43, 0x47, 0x47, 0x13, 0x4c, 0x06, 0xae, 0x04, 0xf7, 0x72, 0x26, + 0x89, 0x76, 0xf3, 0x8d, 0xc0, 0x89, 0x3b, 0x52, 0x06, 0xa7, 0x5a, 0x86, 0x01, 0x4e, 0x12, 0x30, 0xfc, 0xe4, 0x21, + 0x88, 0xa3, 0x8c, 0x04, 0x19, 0x8d, 0xe1, 0xb7, 0xc0, 0x5f, 0x34, 0xeb, 0x76, 0x0d, 0x3f, 0xd5, 0x2c, 0x21, 0xa6, + 0x70, 0x92, 0x28, 0x48, 0x4a, 0xa3, 0xf6, 0x6a, 0x68, 0xdc, 0xe5, 0x68, 0x61, 0xd4, 0x9e, 0xd7, 0x6a, 0xdd, 0x8e, + 0xd0, 0xa2, 0x31, 0x36, 0x2a, 0xc1, 0xb7, 0xb8, 0x19, 0x68, 0x34, 0x9d, 0x69, 0xef, 0xe6, 0x54, 0xea, 0x54, 0x10, + 0x18, 0x5c, 0x5d, 0x3f, 0x91, 0x97, 0x10, 0x52, 0xe3, 0x11, 0x92, 0x65, 0x34, 0xc6, 0xa1, 0x6a, 0xfb, 0xd8, 0x52, + 0xa2, 0x8a, 0x4b, 0x27, 0xf0, 0x4f, 0x4a, 0x97, 0x74, 0xca, 0xfa, 0x74, 0xc6, 0x2a, 0x4b, 0x1b, 0x5d, 0xb0, 0x3e, + 0x9d, 0xb3, 0xb8, 0x32, 0xbd, 0x21, 0x59, 0x4f, 0x9f, 0xb0, 0x59, 0xa7, 0xb3, 0x78, 0xc2, 0xe6, 0x43, 0x88, 0x0a, + 0x49, 0x46, 0xd3, 0xb1, 0x8e, 0x64, 0x24, 0xd3, 0x6e, 0x77, 0x68, 0x23, 0x09, 0x46, 0x33, 0x5b, 0x3e, 0xeb, 0xf5, + 0x6c, 0x79, 0xa1, 0xea, 0x67, 0xa3, 0xc5, 0x98, 0x4c, 0x46, 0x8b, 0x31, 0x7b, 0x87, 0x4d, 0xd0, 0x18, 0x0a, 0xe8, + 0xb4, 0xdb, 0xa5, 0x0b, 0xa7, 0x95, 0x42, 0xb5, 0x92, 0x8d, 0xe6, 0x50, 0x7b, 0xae, 0x6a, 0xcf, 0xa0, 0xf6, 0x7c, + 0x4c, 0xe8, 0xac, 0xd7, 0xa3, 0xf3, 0x6d, 0x6d, 0xbb, 0xb5, 0xa7, 0xa6, 0xf6, 0x4b, 0x8f, 0xd3, 0xc9, 0x68, 0x0e, + 0x99, 0x2a, 0xa0, 0x54, 0x75, 0x56, 0xff, 0x7c, 0xb6, 0x09, 0xda, 0xcc, 0x80, 0x06, 0x9f, 0x63, 0x6b, 0x50, 0xa6, + 0xfa, 0x76, 0x21, 0xad, 0x79, 0x47, 0x52, 0xf6, 0x1b, 0xf7, 0x32, 0xba, 0xa0, 0x73, 0x42, 0x97, 0xf0, 0x5c, 0xd0, + 0x29, 0x9d, 0x11, 0x42, 0x53, 0x8c, 0x08, 0x07, 0x38, 0x09, 0xae, 0x01, 0xf3, 0x7b, 0x36, 0xae, 0x02, 0x6a, 0x50, + 0xdd, 0x46, 0x20, 0x20, 0x19, 0x8a, 0x43, 0xbc, 0x90, 0x41, 0x20, 0x81, 0x38, 0x73, 0xcd, 0x4a, 0xdd, 0xe3, 0xaa, + 0x06, 0x3a, 0x32, 0x7c, 0xe7, 0x49, 0x0d, 0x31, 0x8e, 0x41, 0xaa, 0xd8, 0x0e, 0x3d, 0x1e, 0xd1, 0x1c, 0x0c, 0xd8, + 0x94, 0xe0, 0xa0, 0x35, 0xea, 0x16, 0x8b, 0x6e, 0x57, 0xd5, 0xfe, 0x9e, 0x7b, 0x76, 0x94, 0x4e, 0x89, 0x46, 0x9a, + 0xa2, 0x03, 0x45, 0x01, 0x4e, 0xf7, 0x0a, 0xb7, 0x0d, 0x00, 0xba, 0x5d, 0x00, 0xc1, 0x12, 0xce, 0xd0, 0xc6, 0xc8, + 0x8c, 0xa6, 0xdd, 0xee, 0x78, 0xc8, 0x6d, 0xe0, 0xd2, 0xf7, 0xdc, 0xc9, 0xc4, 0x50, 0x91, 0xec, 0x8f, 0xb0, 0x26, + 0x26, 0x84, 0xbe, 0x29, 0x4b, 0x42, 0x7f, 0x52, 0x0c, 0x2d, 0x0c, 0x3f, 0xd0, 0xdf, 0x59, 0x16, 0x05, 0x60, 0x1a, + 0xa0, 0x17, 0x4b, 0x29, 0x33, 0x41, 0x0b, 0xd4, 0x94, 0x68, 0x22, 0x16, 0x4b, 0xb9, 0xea, 0xf5, 0x16, 0x79, 0x32, + 0x8f, 0xf3, 0xbb, 0xde, 0x24, 0x4b, 0xb3, 0x3c, 0xf8, 0x4b, 0xff, 0x20, 0xfe, 0x7a, 0xf6, 0x68, 0x38, 0xcb, 0x84, + 0xec, 0xcd, 0xe2, 0x79, 0x92, 0xde, 0x05, 0xcb, 0xa4, 0x37, 0xcf, 0x44, 0x56, 0x2c, 0xe2, 0x09, 0xa7, 0xc5, 0x5d, + 0x21, 0xf9, 0xbc, 0xb7, 0x4c, 0xe8, 0x73, 0x9e, 0x5e, 0x73, 0x99, 0x4c, 0x62, 0xfa, 0x2e, 0xbb, 0xc8, 0x64, 0x46, + 0xdf, 0xdc, 0xde, 0x5d, 0x72, 0x41, 0xdf, 0x5f, 0x2c, 0x85, 0x5c, 0xd2, 0x22, 0x16, 0x45, 0xaf, 0xe0, 0x79, 0x32, + 0x1b, 0xca, 0x3c, 0x16, 0x45, 0x82, 0x5a, 0x75, 0x9c, 0xa6, 0x2d, 0xff, 0xe0, 0x71, 0xd1, 0x56, 0x21, 0x05, 0xb1, + 0x90, 0x65, 0x44, 0xff, 0xc1, 0x59, 0x16, 0x69, 0xe8, 0xfc, 0x0b, 0x29, 0x56, 0x93, 0x65, 0x5e, 0x64, 0x79, 0xb0, + 0xc8, 0x12, 0x01, 0xc7, 0x91, 0xea, 0xa0, 0xc1, 0x2e, 0xfa, 0x32, 0xcf, 0x96, 0x62, 0xaa, 0x61, 0x5e, 0x8a, 0x82, + 0x63, 0xec, 0x89, 0xe4, 0x79, 0x0f, 0xa0, 0x4c, 0xc4, 0x65, 0x30, 0xf0, 0xfb, 0x5f, 0x1f, 0x7c, 0xf9, 0x78, 0x71, + 0x3b, 0x04, 0xc6, 0xd7, 0x43, 0x10, 0xe0, 0x14, 0x46, 0xb0, 0x5c, 0x2c, 0x78, 0x0e, 0x29, 0x24, 0x86, 0x17, 0x59, + 0x3e, 0x85, 0xd4, 0x13, 0x99, 0x30, 0xcf, 0xbd, 0x3c, 0x9e, 0x26, 0xcb, 0x22, 0x78, 0xb4, 0xb8, 0x1d, 0xce, 0xe3, + 0xfc, 0x32, 0x11, 0xbd, 0x3c, 0xb9, 0xbc, 0x92, 0x41, 0xef, 0xab, 0xc5, 0xed, 0x70, 0x11, 0x4f, 0x21, 0x16, 0x3e, + 0x80, 0x67, 0xc4, 0x0f, 0x9c, 0x7c, 0x08, 0x06, 0xfb, 0xfe, 0xfe, 0x63, 0x53, 0x72, 0xc3, 0xb1, 0xfa, 0xe3, 0x7e, + 0xbf, 0x54, 0xe3, 0x09, 0x54, 0x1c, 0x37, 0x0e, 0x4b, 0x3f, 0xaf, 0x9c, 0x01, 0x60, 0xe2, 0xa5, 0xe0, 0x2f, 0x5f, + 0xce, 0xe0, 0xbf, 0x83, 0x03, 0x07, 0x53, 0xbd, 0xe9, 0x32, 0x57, 0x1b, 0x91, 0x41, 0x61, 0xda, 0xba, 0xca, 0xae, + 0x79, 0xae, 0x9a, 0xc2, 0xc7, 0xd5, 0x06, 0x2a, 0x3e, 0xda, 0x92, 0x1f, 0xab, 0xb6, 0x5e, 0x14, 0xa7, 0xa0, 0xfe, + 0xaf, 0xf4, 0x67, 0xb3, 0xd9, 0x6c, 0x13, 0xaf, 0x7f, 0xd9, 0xff, 0x2a, 0xfe, 0xf2, 0xd1, 0xe3, 0x8f, 0xe0, 0xc9, + 0x60, 0x65, 0xd0, 0x5f, 0xdc, 0xb6, 0xf6, 0xfb, 0x75, 0xdc, 0x7c, 0x01, 0xf8, 0xaf, 0x66, 0xbf, 0xd9, 0x45, 0xcb, + 0x3f, 0x28, 0xca, 0x88, 0xfe, 0x0c, 0xf3, 0x8f, 0xf4, 0x38, 0x42, 0x6b, 0x26, 0xcc, 0xd8, 0x78, 0x75, 0x93, 0x4c, + 0xe5, 0x55, 0x30, 0xe8, 0xf7, 0x3f, 0xab, 0x88, 0x65, 0x78, 0xa5, 0x10, 0x3c, 0xc8, 0xf9, 0xbc, 0x46, 0x42, 0x7f, + 0xe7, 0x86, 0xcc, 0x57, 0x8b, 0x4c, 0xf7, 0x96, 0xf3, 0x14, 0x33, 0x4b, 0x95, 0x8a, 0xe2, 0x57, 0x9b, 0xb0, 0x57, + 0x5d, 0x94, 0x4e, 0xf7, 0x39, 0x18, 0x06, 0xc6, 0xf4, 0x1e, 0x80, 0x26, 0x71, 0x3a, 0xf1, 0xe0, 0x93, 0x56, 0xaf, + 0x75, 0x90, 0xf3, 0x39, 0x31, 0x30, 0xf9, 0x5f, 0x3e, 0xce, 0xf9, 0xbc, 0xf4, 0xf1, 0xf3, 0x15, 0x52, 0x5d, 0x9c, + 0x26, 0x97, 0x22, 0x98, 0x70, 0xa0, 0xe2, 0xd2, 0xe7, 0x42, 0x26, 0xf2, 0xae, 0x97, 0x67, 0x37, 0xab, 0x59, 0xca, + 0x6f, 0x7b, 0x53, 0xa5, 0x25, 0x03, 0xa4, 0xd9, 0xcd, 0x10, 0xeb, 0xf6, 0x12, 0xc9, 0xe7, 0x85, 0xfe, 0x62, 0x38, + 0x4f, 0x44, 0x4f, 0x37, 0xfe, 0xa8, 0x5f, 0xc7, 0xa4, 0x5a, 0x47, 0x45, 0x8b, 0xc7, 0x05, 0xef, 0x65, 0x4b, 0x39, + 0x9c, 0x26, 0xc5, 0x22, 0x8d, 0xef, 0x02, 0x68, 0x79, 0xb8, 0x89, 0x02, 0xa7, 0x73, 0x9f, 0xdf, 0x2e, 0x62, 0x31, + 0xe5, 0xd3, 0x95, 0xd3, 0xfe, 0x3e, 0x74, 0xe0, 0xd6, 0x0a, 0x84, 0xbc, 0xea, 0x61, 0x34, 0xa5, 0xb7, 0x2f, 0xc8, + 0x16, 0x4a, 0x7b, 0x1c, 0xc3, 0x7f, 0x83, 0xd8, 0xfd, 0xa8, 0x05, 0x79, 0xc5, 0x92, 0xd9, 0x5d, 0x0f, 0xfe, 0xae, + 0xc0, 0xf0, 0x92, 0x4c, 0xe2, 0x54, 0xa3, 0x61, 0x9e, 0x4c, 0xa7, 0x69, 0x0d, 0x92, 0xc3, 0x00, 0x2d, 0x87, 0xaa, + 0x1b, 0x43, 0x8a, 0x8f, 0x1e, 0x7d, 0x79, 0xf0, 0x35, 0x1f, 0x6e, 0xe0, 0x6f, 0x08, 0x23, 0x0b, 0xfa, 0xad, 0x7e, + 0x0b, 0x71, 0x91, 0x26, 0x82, 0xbb, 0xc8, 0xa9, 0xb7, 0xeb, 0x00, 0x4f, 0xd4, 0x54, 0x80, 0xbd, 0x24, 0x10, 0x19, + 0xfc, 0x51, 0x6d, 0xc3, 0x02, 0x9a, 0xa5, 0xd9, 0x4d, 0xc0, 0xd3, 0x34, 0x59, 0x14, 0x49, 0xa1, 0x3a, 0x78, 0xd4, + 0xff, 0x0c, 0xf1, 0xae, 0x49, 0xe3, 0x71, 0xbf, 0x62, 0x05, 0x29, 0x9f, 0x49, 0x45, 0xd2, 0x35, 0xde, 0x00, 0xec, + 0xc0, 0x36, 0x76, 0x95, 0x4c, 0xa7, 0x5c, 0xdc, 0x07, 0xcc, 0x01, 0x71, 0xe9, 0x02, 0x3f, 0x57, 0xbd, 0x3e, 0xee, + 0x7f, 0x36, 0xfc, 0x75, 0x59, 0x48, 0xc0, 0x9d, 0x09, 0xd1, 0x42, 0x7e, 0xdb, 0xbb, 0xe0, 0xf2, 0x86, 0x73, 0x51, + 0x83, 0x61, 0xbf, 0xbf, 0x0d, 0x06, 0x97, 0x02, 0xee, 0x07, 0xe0, 0x30, 0x00, 0xc5, 0x50, 0xa3, 0xdc, 0x6d, 0x34, + 0x5e, 0xca, 0xac, 0xf4, 0x2f, 0x12, 0x11, 0xe7, 0x77, 0xe7, 0x05, 0x17, 0x45, 0x96, 0x9f, 0x67, 0xb3, 0xd9, 0xaa, + 0xc6, 0x58, 0x2e, 0x0e, 0x4a, 0xbf, 0x48, 0xc4, 0x65, 0xca, 0x15, 0x1b, 0xc1, 0x49, 0x57, 0x8f, 0xba, 0x31, 0x6c, + 0xa7, 0x01, 0xcb, 0x24, 0x4d, 0xe6, 0xb1, 0xe4, 0x38, 0x07, 0xce, 0xb2, 0xd6, 0x43, 0x50, 0x9c, 0xa3, 0x5f, 0x55, + 0x83, 0x05, 0xe2, 0xa0, 0x09, 0xa0, 0x43, 0x2c, 0xa9, 0x39, 0xc4, 0x19, 0x74, 0x1a, 0x31, 0x5d, 0x25, 0x02, 0x49, + 0xa2, 0xde, 0x23, 0x0c, 0x5f, 0xaf, 0x7e, 0xf5, 0xc9, 0xe3, 0xfe, 0x67, 0xf5, 0xb7, 0x69, 0x7c, 0xc1, 0xd3, 0x95, + 0x5a, 0x7c, 0x06, 0xf3, 0x9a, 0xe0, 0x1c, 0x12, 0x70, 0xd9, 0x03, 0x22, 0x64, 0x1c, 0x04, 0xbd, 0x1b, 0x7e, 0xf1, + 0x21, 0x91, 0x6a, 0x3d, 0xf4, 0x8a, 0x1b, 0x38, 0x0c, 0xd6, 0x53, 0x66, 0xb9, 0x7c, 0x65, 0xb8, 0x62, 0xbf, 0xc6, + 0xa5, 0x76, 0x81, 0x4b, 0xf9, 0x32, 0xbe, 0xe8, 0x41, 0x3e, 0xbe, 0xaa, 0x5a, 0x4f, 0x01, 0x1f, 0x0c, 0xfc, 0xc7, + 0x7c, 0x3e, 0x5c, 0x16, 0x20, 0xc7, 0x10, 0x6a, 0xcd, 0x74, 0xef, 0x61, 0xf3, 0x8f, 0xa6, 0x0d, 0x7e, 0x3c, 0xd8, + 0x5f, 0xdc, 0xb6, 0xf0, 0x9f, 0x7e, 0xab, 0xbf, 0x95, 0xa3, 0xc4, 0xb7, 0x9a, 0xb2, 0xbf, 0xb6, 0xf8, 0xef, 0xc9, + 0x6c, 0x11, 0x0c, 0xf8, 0xdc, 0x70, 0x72, 0xfc, 0x8d, 0x80, 0x98, 0x82, 0x8b, 0x4c, 0xca, 0x6c, 0xae, 0xca, 0x5c, + 0x31, 0xf7, 0xa8, 0xdf, 0xdf, 0x8e, 0x7e, 0x18, 0x21, 0x20, 0x33, 0x4e, 0x04, 0x48, 0x29, 0x25, 0x3f, 0x00, 0xac, + 0x22, 0x83, 0x73, 0x18, 0xf7, 0x81, 0xdf, 0x6f, 0xd9, 0x01, 0x94, 0x51, 0x65, 0x0e, 0x7a, 0x5a, 0xc5, 0x9e, 0x81, + 0xed, 0x22, 0x61, 0xd6, 0x0f, 0x62, 0x0e, 0x04, 0xc4, 0x2c, 0x79, 0x72, 0x10, 0xca, 0x20, 0x37, 0x39, 0xa4, 0x72, + 0xf6, 0x49, 0xf6, 0xb2, 0x9c, 0x66, 0x4e, 0xae, 0x37, 0x6d, 0xc5, 0x62, 0x9b, 0x87, 0x8b, 0x9a, 0xf6, 0x2d, 0xd7, + 0xfd, 0x47, 0x62, 0xd6, 0x7c, 0x6d, 0xe1, 0xad, 0xb2, 0xb0, 0x01, 0xe0, 0x85, 0x1b, 0xd6, 0x5c, 0x1c, 0xb2, 0xfe, + 0xb0, 0xe8, 0xf5, 0x88, 0x97, 0x31, 0x3e, 0x2a, 0xf0, 0x1c, 0x45, 0xcc, 0x3c, 0x18, 0x47, 0xe6, 0xc5, 0x24, 0x48, + 0x0e, 0xe1, 0x01, 0x9a, 0x89, 0x49, 0x80, 0x0f, 0x84, 0xac, 0xd7, 0xb1, 0xdd, 0x3f, 0x26, 0x87, 0x07, 0x9d, 0x4e, + 0x7c, 0x9f, 0x51, 0x4d, 0x7d, 0x47, 0x63, 0x34, 0xf6, 0x70, 0xc9, 0xbe, 0xfe, 0x82, 0x4a, 0xd9, 0x70, 0x33, 0xbd, + 0xae, 0xed, 0x34, 0xc1, 0x24, 0xe8, 0xb8, 0x9a, 0x8c, 0x5f, 0x05, 0x72, 0x41, 0x4a, 0x0c, 0xa3, 0x1a, 0x8d, 0xff, + 0x94, 0xdb, 0x24, 0x5e, 0x2c, 0xd2, 0xbb, 0x13, 0x2d, 0x71, 0x74, 0x82, 0x14, 0x32, 0x74, 0xf3, 0xd6, 0xa0, 0x4d, + 0x44, 0x1b, 0xf7, 0x87, 0x55, 0x34, 0x98, 0xce, 0x4e, 0xa5, 0xf7, 0xd6, 0x4b, 0x89, 0x2a, 0xcc, 0x1b, 0x5d, 0x88, + 0xc6, 0xba, 0x07, 0x3a, 0x30, 0xbd, 0x9b, 0x46, 0x7c, 0xfd, 0xe0, 0x71, 0x5a, 0xf9, 0x0a, 0x8a, 0x9a, 0xf1, 0xf3, + 0x9b, 0x24, 0x05, 0x37, 0xc1, 0x28, 0x42, 0x2c, 0x45, 0xe3, 0x92, 0xdc, 0xeb, 0xdd, 0xa9, 0xb7, 0x1d, 0x3a, 0x7e, + 0x1e, 0xaf, 0xd9, 0xb1, 0xf1, 0xc6, 0x3e, 0xe4, 0x10, 0x2a, 0xb7, 0x8f, 0x61, 0x75, 0x1f, 0x92, 0x42, 0x1f, 0x41, + 0x04, 0x4f, 0xb6, 0xaf, 0x57, 0x59, 0xe1, 0x45, 0x46, 0xaa, 0x47, 0xda, 0xc9, 0x86, 0x67, 0xbd, 0x7c, 0x25, 0x21, + 0x19, 0x0f, 0x23, 0x94, 0xf0, 0x51, 0x10, 0x3d, 0xda, 0x5f, 0xdc, 0x46, 0xd4, 0xa9, 0x92, 0x81, 0xc6, 0x2c, 0xef, + 0xa0, 0x4e, 0xdf, 0x7f, 0x1c, 0x05, 0x51, 0xdf, 0x1f, 0x44, 0xe5, 0xb9, 0xda, 0x48, 0x7b, 0x95, 0xcd, 0xbb, 0x46, + 0x0e, 0xeb, 0x35, 0xf8, 0x7c, 0x66, 0x88, 0x33, 0x4f, 0x25, 0x6b, 0xf3, 0x93, 0xe2, 0x1b, 0xf0, 0x01, 0xc0, 0xd9, + 0x52, 0xd4, 0xdc, 0x0b, 0x6d, 0xbe, 0x70, 0x12, 0x34, 0xf6, 0xf5, 0x56, 0x3b, 0x8a, 0x86, 0x6a, 0x3b, 0x84, 0x07, + 0x08, 0xe7, 0x89, 0xd0, 0x34, 0x27, 0x74, 0x41, 0x7c, 0xab, 0x0a, 0x7a, 0x12, 0x02, 0x0c, 0x4c, 0x5c, 0xcf, 0x20, + 0x1c, 0xf4, 0xfb, 0x7b, 0x5e, 0xb5, 0x8a, 0x48, 0xd0, 0xb7, 0x07, 0xb7, 0x31, 0x47, 0x22, 0xf8, 0x51, 0x8c, 0x55, + 0x26, 0x73, 0x3f, 0x8c, 0x3f, 0xcf, 0x83, 0xc7, 0x18, 0x8c, 0x7c, 0xd8, 0x0f, 0xb9, 0xec, 0x79, 0x49, 0x4f, 0x92, + 0x3d, 0xf1, 0xf9, 0xd7, 0xfb, 0xc1, 0x63, 0xd3, 0x46, 0xb4, 0xbb, 0xca, 0xec, 0x19, 0xc6, 0x7d, 0x52, 0xd2, 0xdd, + 0x55, 0xe1, 0xfe, 0x8e, 0x4a, 0xe2, 0xff, 0x9a, 0x25, 0xc2, 0x8b, 0x5a, 0x11, 0x29, 0xcf, 0x51, 0x72, 0x38, 0x76, + 0x75, 0x27, 0x9a, 0x32, 0x8a, 0x6c, 0x02, 0x3b, 0x5f, 0x66, 0x6f, 0x73, 0x3e, 0x49, 0xc0, 0xe6, 0xe2, 0x3d, 0x22, + 0x8e, 0x87, 0xcf, 0x8d, 0x5e, 0x35, 0xc8, 0xb6, 0x71, 0xab, 0xba, 0x71, 0x13, 0xe7, 0x56, 0x47, 0x53, 0x60, 0x4e, + 0xdb, 0x8b, 0x87, 0x6a, 0x1b, 0x1c, 0x9a, 0xda, 0x06, 0x53, 0xcf, 0xf0, 0x60, 0x5a, 0xeb, 0x3a, 0xe1, 0x37, 0x4f, + 0xb3, 0x5b, 0xb6, 0x03, 0x2a, 0xd5, 0xa0, 0x8f, 0xff, 0xdf, 0x69, 0x81, 0x79, 0x08, 0x08, 0xf7, 0xa8, 0x58, 0xf0, + 0x89, 0x7c, 0x07, 0x8b, 0x8e, 0xed, 0x80, 0x10, 0xda, 0x39, 0x7c, 0xb2, 0xc8, 0xd2, 0x3b, 0x60, 0xf2, 0x2d, 0x35, + 0xbb, 0x6c, 0x67, 0x57, 0xaf, 0x04, 0x3b, 0xdb, 0xe5, 0x4e, 0xeb, 0x1a, 0xad, 0xf0, 0x3d, 0x3e, 0x9b, 0x01, 0x2b, + 0x85, 0x4f, 0x7b, 0xc5, 0x24, 0x06, 0x33, 0x5e, 0xaf, 0x90, 0x79, 0xf6, 0x01, 0x1a, 0xda, 0x33, 0x2d, 0x1d, 0xaa, + 0xa3, 0x4c, 0x4f, 0xa6, 0xc9, 0x75, 0x0b, 0x69, 0x9a, 0xed, 0xc4, 0xb7, 0x49, 0xb1, 0x73, 0xf8, 0xa4, 0x58, 0xc4, + 0xe2, 0x70, 0x77, 0x25, 0xca, 0x27, 0x7b, 0xf8, 0xd8, 0x32, 0x25, 0xd2, 0x94, 0x3c, 0xd9, 0x9b, 0x26, 0xd7, 0x87, + 0x91, 0x9b, 0xd0, 0xae, 0x30, 0x2b, 0xc7, 0x9c, 0xe7, 0xd3, 0x3b, 0x82, 0xdf, 0x7b, 0xea, 0xcc, 0x44, 0x6f, 0xd0, + 0xef, 0x0f, 0x37, 0xb5, 0x78, 0x58, 0x11, 0x56, 0x8b, 0x87, 0x1f, 0x95, 0xfe, 0x1c, 0x5f, 0x14, 0x59, 0x0a, 0x49, + 0x92, 0x94, 0xde, 0xf5, 0x68, 0x71, 0x5b, 0x16, 0xd7, 0x97, 0xae, 0x0e, 0x63, 0x36, 0x24, 0xae, 0x2a, 0x72, 0x91, + 0x66, 0x93, 0x0f, 0xa5, 0x19, 0xe4, 0x0a, 0xfc, 0xaa, 0x4a, 0x90, 0x2b, 0x0c, 0x04, 0xd7, 0x71, 0xee, 0x35, 0x36, + 0xde, 0x54, 0xef, 0x6e, 0x89, 0xae, 0x63, 0xf4, 0xcf, 0xc5, 0xad, 0x29, 0x80, 0xa6, 0x26, 0xf1, 0x22, 0x40, 0x3d, + 0xc0, 0x2d, 0x04, 0x92, 0x54, 0xa5, 0xa5, 0x0f, 0xd8, 0x5b, 0xe9, 0x6d, 0x73, 0x8f, 0x43, 0x50, 0x49, 0xa1, 0x7a, + 0x6e, 0x6c, 0x38, 0x26, 0x59, 0xba, 0x9c, 0x8b, 0x8f, 0xa8, 0x9c, 0xae, 0xfe, 0x80, 0xdf, 0x73, 0x31, 0xad, 0x8d, + 0xd7, 0xd9, 0xe8, 0x35, 0x55, 0xf2, 0xc1, 0x3d, 0x1b, 0x12, 0x8b, 0x50, 0x50, 0x32, 0xfa, 0x43, 0xa5, 0xbd, 0xf6, + 0xcb, 0xa8, 0x2c, 0x87, 0x4f, 0xbd, 0xd1, 0x37, 0xfa, 0x90, 0x0b, 0x1a, 0xe6, 0x4a, 0x32, 0xa6, 0xd2, 0xcd, 0xe4, + 0x1b, 0x59, 0xee, 0x63, 0x12, 0xc2, 0x12, 0x90, 0x6a, 0x4f, 0xbd, 0xd1, 0x5b, 0x2f, 0xe2, 0xc5, 0xa2, 0xa7, 0x75, + 0x5e, 0xac, 0x16, 0xe1, 0xd7, 0xca, 0x11, 0x2d, 0x6c, 0xc6, 0xc0, 0x59, 0xce, 0xf9, 0xef, 0xdc, 0x5b, 0xe1, 0x74, + 0xf6, 0x29, 0x02, 0x41, 0x35, 0xaa, 0xbf, 0xa0, 0x06, 0xf6, 0x2f, 0x4a, 0x42, 0xf3, 0x8d, 0x6f, 0xf2, 0x0c, 0x1d, + 0x66, 0x7d, 0x7a, 0xfd, 0x4d, 0x9a, 0x2c, 0xd0, 0x8b, 0xac, 0x1f, 0x4a, 0x42, 0x7f, 0x68, 0xd6, 0x86, 0x83, 0xb4, + 0x78, 0x9c, 0x36, 0x07, 0xc7, 0x47, 0xb2, 0xd1, 0x9a, 0xef, 0xfb, 0x3f, 0xd0, 0x8b, 0x6c, 0x7a, 0x07, 0x07, 0x42, + 0xd5, 0xae, 0x41, 0xb5, 0x14, 0x6f, 0x54, 0x55, 0xf0, 0x61, 0xde, 0x2b, 0x0d, 0x21, 0x66, 0x52, 0x21, 0x34, 0xdb, + 0xd6, 0x6a, 0x6c, 0x7b, 0xad, 0x34, 0xa8, 0x02, 0x8d, 0xa8, 0xac, 0x5f, 0xf9, 0xa1, 0xf4, 0xc1, 0x39, 0x6f, 0xef, + 0x9f, 0xbd, 0x70, 0xd4, 0xef, 0x7d, 0xed, 0x8f, 0x3f, 0xdf, 0xa3, 0x51, 0xe4, 0x7c, 0x83, 0xc6, 0x67, 0x65, 0x9e, + 0x7f, 0xd2, 0x1f, 0x12, 0xde, 0x65, 0x8f, 0x2c, 0xaf, 0xfd, 0xec, 0x51, 0xa9, 0x2d, 0x6b, 0x51, 0x64, 0x0c, 0x5b, + 0x98, 0x7f, 0xf3, 0x05, 0x46, 0x31, 0x59, 0x1d, 0xa5, 0x78, 0x1d, 0xbf, 0x86, 0xc3, 0x3e, 0xfd, 0x20, 0xd7, 0x6e, + 0x00, 0xf0, 0x6a, 0x39, 0x27, 0x21, 0x74, 0xaa, 0x50, 0xa1, 0x52, 0x85, 0x46, 0x9f, 0xc1, 0xa1, 0xc6, 0xfd, 0xc7, + 0x4e, 0xce, 0xcf, 0x68, 0xca, 0x2f, 0xa1, 0xf0, 0xeb, 0x7e, 0x69, 0xfd, 0x79, 0xad, 0x44, 0x75, 0xf6, 0x4d, 0x9a, + 0xc5, 0x18, 0x7c, 0xac, 0x8f, 0x58, 0x5a, 0xb9, 0x60, 0xc2, 0x3a, 0x49, 0x03, 0x92, 0x04, 0x20, 0xf1, 0x92, 0x3d, + 0x26, 0x69, 0xf2, 0xd9, 0x80, 0xb1, 0x7e, 0x98, 0x7b, 0x09, 0x09, 0xfa, 0xc4, 0x3a, 0x11, 0xd4, 0x79, 0x9e, 0x89, + 0x64, 0x7b, 0xa3, 0x5f, 0x0a, 0x3a, 0xee, 0xee, 0x55, 0xf8, 0x48, 0xf5, 0x31, 0x2a, 0x73, 0x4e, 0x6d, 0x22, 0x89, + 0xcd, 0x3f, 0x20, 0xd9, 0xa1, 0x4d, 0xbc, 0xea, 0xcb, 0x3c, 0x99, 0x7b, 0x44, 0x8f, 0xe8, 0x2a, 0xcb, 0x93, 0xdf, + 0x41, 0x46, 0xa7, 0x51, 0xc0, 0x7d, 0x24, 0x18, 0x48, 0x5c, 0xe2, 0x0c, 0xd0, 0xec, 0x92, 0xe1, 0xfd, 0xb5, 0x7e, + 0x5f, 0x6a, 0x37, 0xec, 0x52, 0x32, 0x98, 0xd2, 0x4c, 0xd2, 0x2d, 0x7c, 0x39, 0x88, 0x22, 0xc7, 0x3d, 0x3d, 0x95, + 0x55, 0xc8, 0x0d, 0x7c, 0xb3, 0x94, 0x25, 0x15, 0x4c, 0x7b, 0xaa, 0x79, 0xfd, 0xc4, 0x21, 0xe6, 0xbd, 0xa9, 0x9c, + 0xcf, 0x48, 0x5f, 0x4c, 0x78, 0x11, 0x3e, 0x44, 0x14, 0xad, 0xa5, 0x54, 0x1a, 0xdd, 0x41, 0x78, 0x91, 0x7a, 0xaa, + 0xde, 0xa8, 0xa5, 0xc0, 0x0a, 0xe9, 0x09, 0x2f, 0x52, 0x3f, 0x22, 0x8a, 0xc7, 0x4f, 0x53, 0x34, 0xb4, 0x7b, 0xd1, + 0x2c, 0x4d, 0x16, 0xba, 0x08, 0x96, 0xf0, 0xa6, 0x50, 0x11, 0x90, 0xcb, 0x70, 0xa3, 0x38, 0xa2, 0x4e, 0x79, 0x8c, + 0xe5, 0xb9, 0x2a, 0x57, 0x4d, 0x55, 0x1e, 0xed, 0x99, 0x9e, 0x8e, 0xea, 0x2c, 0x4d, 0x22, 0x5a, 0x4b, 0x89, 0xc7, + 0x2f, 0x47, 0x02, 0x02, 0x7e, 0x25, 0xa4, 0x1a, 0x33, 0xa9, 0x24, 0x6c, 0x96, 0x3b, 0xc4, 0xeb, 0x42, 0xb2, 0xbd, + 0x7f, 0xc2, 0x89, 0xfd, 0x7e, 0xef, 0xeb, 0x71, 0xd7, 0xeb, 0xd9, 0x47, 0xf2, 0xf9, 0xee, 0x1e, 0x7d, 0xce, 0x6c, + 0x5a, 0xa2, 0x28, 0x32, 0xda, 0x04, 0x24, 0x45, 0x56, 0x13, 0x1f, 0x05, 0x11, 0xd1, 0x99, 0x4f, 0x34, 0xe1, 0x0d, + 0x88, 0x3a, 0x4e, 0xa9, 0x4f, 0x01, 0xea, 0x73, 0xa5, 0xfb, 0xeb, 0xb5, 0x79, 0x3e, 0x3c, 0x30, 0x2e, 0x06, 0x15, + 0x4e, 0xc6, 0x12, 0x5f, 0xe5, 0xf2, 0x33, 0x89, 0x12, 0x06, 0xb8, 0x38, 0xaa, 0xea, 0xeb, 0x75, 0xdb, 0xfc, 0xa8, + 0x7d, 0xe9, 0x56, 0x1a, 0x54, 0xa7, 0x28, 0x17, 0xd9, 0xc2, 0x23, 0x78, 0xb2, 0x54, 0x3d, 0xc5, 0x6c, 0xb5, 0xc8, + 0xb3, 0xeb, 0x04, 0xb6, 0x5d, 0xb6, 0x7e, 0x3f, 0x84, 0x30, 0xe1, 0x20, 0x07, 0x5a, 0x9a, 0x25, 0xb7, 0x81, 0x50, + 0xa7, 0x47, 0x79, 0x69, 0x29, 0xa1, 0xd3, 0x69, 0xcf, 0xa5, 0x17, 0x13, 0x65, 0x40, 0x8f, 0x4b, 0x9d, 0xfa, 0x49, + 0x05, 0x17, 0xc7, 0x66, 0xf8, 0x3d, 0x35, 0xfc, 0x6c, 0x03, 0x8e, 0xaa, 0x4f, 0xdb, 0x47, 0x66, 0xc6, 0xa9, 0xfa, + 0xca, 0xb4, 0xfe, 0xd4, 0x8b, 0x48, 0xb3, 0x57, 0xae, 0x7b, 0xe5, 0xc8, 0x25, 0x3a, 0x9d, 0xdc, 0x61, 0x2e, 0x5b, + 0x9b, 0x8e, 0x22, 0xd5, 0x66, 0xbc, 0xd1, 0x12, 0x15, 0xb6, 0x2d, 0x07, 0x77, 0x25, 0x9d, 0x4b, 0x9b, 0x3a, 0x39, + 0x6c, 0xb7, 0x3d, 0x4c, 0x9a, 0xee, 0xab, 0xd6, 0x98, 0x0a, 0x15, 0x37, 0x3f, 0x09, 0xbc, 0x51, 0xf1, 0xc7, 0xed, + 0x41, 0xb5, 0xc6, 0xae, 0x6a, 0x27, 0x29, 0xb9, 0x0f, 0x56, 0xae, 0x02, 0x15, 0xd4, 0x38, 0x4d, 0xe2, 0x82, 0x17, + 0xeb, 0x75, 0x3d, 0x50, 0x47, 0xad, 0x97, 0x84, 0x6d, 0x29, 0xad, 0x5a, 0x8d, 0xb5, 0x9a, 0x2c, 0x20, 0x65, 0x89, + 0xe1, 0x57, 0x10, 0x50, 0xa0, 0xd2, 0x47, 0xb6, 0x3d, 0xc8, 0x92, 0xdd, 0x4a, 0xc0, 0x0d, 0x02, 0xa5, 0x48, 0x07, + 0x6a, 0x9d, 0xe7, 0x23, 0x3e, 0xee, 0x74, 0xe0, 0x5f, 0xbd, 0x41, 0x00, 0x85, 0xb0, 0xd3, 0x81, 0x04, 0xd8, 0x43, + 0x01, 0x27, 0xd4, 0xb0, 0x15, 0x39, 0x86, 0x5d, 0xc2, 0x24, 0xc6, 0x5c, 0xef, 0xa5, 0xd3, 0x81, 0x79, 0xd6, 0xd0, + 0x61, 0x56, 0x3f, 0x41, 0x4c, 0x65, 0xb7, 0x34, 0x27, 0x15, 0xaf, 0x83, 0x93, 0x12, 0xd5, 0x32, 0xbc, 0xac, 0xa1, + 0x64, 0x55, 0x0e, 0xdb, 0x9a, 0xcb, 0xb5, 0x59, 0x5b, 0xaa, 0x27, 0x3c, 0x03, 0x63, 0x38, 0x1f, 0xa1, 0x6d, 0xcd, + 0xe6, 0xb0, 0xc2, 0xb5, 0xad, 0x60, 0x58, 0x9f, 0xda, 0x1b, 0xe6, 0xcc, 0xf3, 0xb8, 0x66, 0x33, 0xeb, 0x75, 0x1f, + 0xce, 0xbe, 0x3b, 0xbf, 0xc8, 0x67, 0x56, 0x14, 0xe5, 0xf8, 0xb1, 0xe6, 0x47, 0x39, 0x44, 0x42, 0x58, 0xd0, 0xce, + 0x6b, 0xa0, 0x69, 0x40, 0xad, 0xc3, 0x32, 0x47, 0xa4, 0x4a, 0x82, 0x7f, 0x73, 0x19, 0xe2, 0x5f, 0x0e, 0x79, 0xb4, + 0xf0, 0x09, 0xf3, 0x18, 0x0a, 0x38, 0x11, 0x9a, 0xcb, 0x51, 0x3e, 0x26, 0x01, 0x96, 0xca, 0x10, 0x8b, 0xa0, 0x24, + 0x30, 0x1f, 0xa8, 0x5a, 0x1c, 0x2a, 0xd9, 0x90, 0x8e, 0x0a, 0x88, 0xeb, 0xba, 0x8b, 0xd5, 0x12, 0x4d, 0xf2, 0x31, + 0xa2, 0x89, 0x01, 0x99, 0xb6, 0x99, 0x0c, 0x68, 0x24, 0x66, 0xe7, 0xd2, 0x83, 0xd9, 0x5e, 0xaf, 0x61, 0xfa, 0x68, + 0x6c, 0x67, 0x33, 0x83, 0x63, 0x3d, 0xc2, 0x4e, 0x51, 0x46, 0x28, 0x0e, 0x3e, 0x76, 0x22, 0x80, 0xee, 0x6a, 0xd8, + 0x50, 0xa4, 0xb5, 0x99, 0x4e, 0xa5, 0xca, 0x8d, 0xa2, 0xe0, 0xac, 0xde, 0x58, 0x36, 0x34, 0x84, 0xe3, 0x63, 0xf2, + 0x7c, 0x06, 0x0a, 0xa7, 0x9b, 0xbe, 0x1d, 0x75, 0x36, 0x5c, 0x37, 0xe6, 0xad, 0x9b, 0x9e, 0x67, 0x85, 0xeb, 0x12, + 0x47, 0x26, 0x6c, 0x2e, 0x6a, 0x33, 0xd7, 0x57, 0xa8, 0x34, 0x58, 0xdf, 0x39, 0xce, 0x88, 0xcd, 0x5c, 0x3c, 0x4a, + 0xc6, 0x43, 0x3c, 0x07, 0xe1, 0x25, 0x14, 0xb1, 0x09, 0x5b, 0x3c, 0xdb, 0x4a, 0x52, 0x91, 0xb4, 0x50, 0x09, 0x3a, + 0xa4, 0xc3, 0x2c, 0xa2, 0x88, 0x6a, 0x24, 0x07, 0xab, 0x92, 0x5a, 0xc0, 0xe0, 0x07, 0xea, 0x67, 0x0e, 0x86, 0x6f, + 0xb7, 0xc9, 0x13, 0x14, 0x27, 0x42, 0x4f, 0xb4, 0xc1, 0x0c, 0x4a, 0x17, 0x13, 0xdf, 0xe4, 0xc8, 0x98, 0x81, 0x91, + 0x31, 0xfd, 0x0a, 0xeb, 0xa7, 0x52, 0x2f, 0xee, 0x6d, 0xa8, 0x6e, 0xf3, 0x1a, 0x6f, 0x57, 0x6b, 0x9a, 0x3b, 0x13, + 0x23, 0x35, 0x3b, 0x6a, 0xdb, 0x84, 0xab, 0x98, 0xf1, 0x04, 0x67, 0xe6, 0xfe, 0x99, 0x5a, 0xaf, 0xdb, 0x38, 0x98, + 0x0b, 0x49, 0x36, 0xda, 0x87, 0xcc, 0xaf, 0x58, 0xdd, 0x49, 0x2f, 0x8b, 0xd4, 0x6e, 0xa2, 0x43, 0x46, 0x5c, 0x31, + 0x1d, 0x6e, 0xdb, 0x97, 0x3e, 0x68, 0xa9, 0x35, 0x10, 0x6e, 0x41, 0xc8, 0x27, 0xf5, 0xe6, 0x4b, 0x13, 0xe5, 0xf6, + 0x10, 0x55, 0xd7, 0x7b, 0xcd, 0x4d, 0xaf, 0x40, 0xd3, 0x10, 0x10, 0xa3, 0xb9, 0x58, 0x03, 0x80, 0xa4, 0xd6, 0x37, + 0x1c, 0xda, 0x82, 0x63, 0x25, 0xa3, 0x64, 0x7c, 0x1f, 0x24, 0x35, 0x5d, 0xee, 0xb8, 0x99, 0x2d, 0xbc, 0xc1, 0x7d, + 0x6f, 0xa4, 0x1b, 0x02, 0x54, 0x91, 0x0e, 0x37, 0x72, 0x46, 0x52, 0x44, 0x58, 0xb0, 0x6d, 0x91, 0xce, 0x93, 0x02, + 0xac, 0xe1, 0x81, 0xce, 0x5e, 0x57, 0x56, 0x13, 0xff, 0xde, 0x5d, 0x6d, 0xc7, 0x12, 0x17, 0xad, 0x87, 0x7f, 0xb7, + 0x81, 0x53, 0x71, 0x8e, 0x91, 0x84, 0x8a, 0xf0, 0x87, 0x69, 0xc8, 0x9c, 0x35, 0x7c, 0x56, 0x83, 0x15, 0x88, 0x4b, + 0x92, 0xf0, 0x0e, 0x50, 0x60, 0xa3, 0x6c, 0x43, 0x4d, 0x0e, 0xe8, 0xa9, 0x0e, 0xb8, 0xaf, 0x21, 0xc4, 0xb4, 0x7a, + 0x10, 0x2e, 0x1b, 0x8c, 0xc6, 0x55, 0x7b, 0x27, 0x96, 0x39, 0x41, 0xfa, 0xb4, 0x8a, 0xee, 0x04, 0x4e, 0x79, 0x95, + 0xe6, 0xb7, 0xba, 0x20, 0xc3, 0xb6, 0x8d, 0xfb, 0x9b, 0x92, 0xb6, 0xfb, 0x3a, 0xdd, 0x7e, 0x69, 0xf5, 0x2b, 0xdb, + 0xfa, 0xb3, 0x26, 0xc7, 0x31, 0x86, 0xa4, 0xcd, 0x34, 0xc2, 0x23, 0x3e, 0x0e, 0x5c, 0x79, 0x73, 0x2c, 0x1d, 0x81, + 0x03, 0xdc, 0x63, 0xcb, 0x47, 0x55, 0x8c, 0xa1, 0xdb, 0x90, 0x6c, 0x36, 0x84, 0x98, 0x5f, 0x95, 0xa4, 0xae, 0xac, + 0x2b, 0x62, 0x7d, 0xaf, 0x13, 0x43, 0x33, 0xb1, 0x55, 0xe8, 0xa9, 0xd1, 0x12, 0x34, 0x2c, 0x09, 0x08, 0x28, 0x52, + 0xa7, 0x73, 0xa3, 0x28, 0x88, 0xfe, 0x86, 0x97, 0x7c, 0x04, 0x11, 0xe9, 0x4a, 0xf8, 0xd3, 0x05, 0xc9, 0x4a, 0x4a, + 0x10, 0x3f, 0x40, 0x73, 0x3f, 0x32, 0x57, 0x6b, 0x78, 0x23, 0xdd, 0xd3, 0xb2, 0xd5, 0x38, 0x2e, 0xd4, 0xbd, 0x08, + 0x10, 0xe1, 0xfb, 0x23, 0x24, 0x24, 0xfe, 0xb1, 0x42, 0xdd, 0xb7, 0x4e, 0xf8, 0xfc, 0x26, 0xb6, 0x9e, 0x7b, 0x18, + 0xd0, 0xfa, 0x23, 0x09, 0x78, 0x15, 0xe4, 0xd8, 0xe2, 0xec, 0xbd, 0x87, 0xbb, 0x65, 0xa4, 0x5f, 0x6a, 0x78, 0x07, + 0x1a, 0x89, 0x50, 0x97, 0x19, 0x36, 0x66, 0x11, 0x32, 0xcb, 0x78, 0x15, 0x85, 0x40, 0x78, 0x85, 0x51, 0x9c, 0xf4, + 0xee, 0xda, 0xa1, 0xe7, 0x0f, 0xb5, 0xc9, 0xb4, 0x10, 0xe0, 0x52, 0x15, 0x15, 0x07, 0x34, 0x78, 0x15, 0x15, 0x20, + 0xc2, 0x00, 0x62, 0xd5, 0xb4, 0xf0, 0x44, 0x7a, 0x50, 0xae, 0x0e, 0xdf, 0x90, 0xc0, 0xcb, 0x6b, 0x64, 0xaa, 0x5e, + 0x40, 0xda, 0x48, 0x87, 0xf4, 0x8f, 0xa4, 0xcd, 0xfd, 0xb4, 0xc9, 0x4a, 0xab, 0xfe, 0x1d, 0xde, 0xd9, 0x76, 0x28, + 0x05, 0xc3, 0xd3, 0x0c, 0x44, 0xeb, 0x35, 0xc4, 0xe8, 0xfd, 0x08, 0xa9, 0x3c, 0x3b, 0x9d, 0xb6, 0x55, 0xf9, 0x34, + 0xbe, 0x2d, 0x1b, 0x57, 0xbc, 0x1b, 0xb3, 0x19, 0x6b, 0x1d, 0x31, 0x8a, 0x28, 0x4a, 0x51, 0xd4, 0x30, 0xd9, 0xe1, + 0xea, 0x83, 0xd2, 0x35, 0xb1, 0x79, 0x00, 0x16, 0x37, 0x28, 0x46, 0x37, 0x54, 0xdf, 0x98, 0xb6, 0xe6, 0xd2, 0x5b, + 0xd5, 0xd5, 0xee, 0x28, 0x8e, 0x4a, 0x12, 0xb6, 0xdb, 0x67, 0xd2, 0x7b, 0x6f, 0x62, 0xd4, 0x02, 0x77, 0xf9, 0xfc, + 0xea, 0x90, 0x4d, 0xbb, 0x0d, 0x14, 0x51, 0xbd, 0x7b, 0xe5, 0x6c, 0xf6, 0xbe, 0x75, 0x36, 0xdc, 0xb2, 0xd3, 0x51, + 0x86, 0x05, 0x88, 0x5e, 0x74, 0x66, 0xef, 0xb5, 0xc6, 0x1e, 0xaf, 0x2d, 0x2a, 0x9b, 0xc0, 0x2a, 0x03, 0x5f, 0x94, + 0xb1, 0x47, 0x17, 0xa8, 0x3a, 0x6e, 0x94, 0x32, 0x61, 0xac, 0xbd, 0x18, 0x29, 0x97, 0x4c, 0x61, 0x87, 0x85, 0x54, + 0x6f, 0x7b, 0x79, 0x8b, 0x50, 0x71, 0x7f, 0xa1, 0x72, 0x06, 0xda, 0x4f, 0xbf, 0x49, 0xe3, 0x4b, 0x24, 0xb5, 0x6d, + 0x2f, 0x20, 0x7c, 0xb8, 0xe0, 0xf2, 0x2c, 0x99, 0xf3, 0x6c, 0x29, 0x55, 0x10, 0xee, 0x7d, 0x35, 0x07, 0x46, 0x46, + 0x36, 0x81, 0x0b, 0x37, 0x4a, 0xcc, 0xde, 0x0c, 0x18, 0x9e, 0x4a, 0xa8, 0x59, 0xdf, 0x4e, 0x69, 0x69, 0xd8, 0x1e, + 0xa0, 0xfa, 0x6e, 0x89, 0x35, 0xa9, 0x66, 0x4e, 0x6e, 0x30, 0x8c, 0xd8, 0x08, 0x4f, 0xdc, 0x0d, 0x69, 0x10, 0x75, + 0xb3, 0x43, 0x5b, 0xe0, 0xbc, 0xd2, 0x08, 0x93, 0xfa, 0x72, 0x1f, 0x2b, 0xcd, 0x59, 0x52, 0xed, 0x4b, 0x95, 0xa5, + 0x5a, 0xaf, 0x50, 0xdc, 0x55, 0xaa, 0xd5, 0x99, 0x8d, 0x49, 0xac, 0x06, 0x35, 0xd5, 0xe9, 0x5f, 0x36, 0xb7, 0x40, + 0x89, 0xde, 0x55, 0xe9, 0xb4, 0x32, 0x2d, 0xfc, 0xdc, 0x5d, 0xcf, 0x19, 0x21, 0xb1, 0x2d, 0xf8, 0xd4, 0x56, 0x6c, + 0x5c, 0x72, 0xbb, 0x4f, 0xdd, 0x8d, 0x33, 0x9c, 0x33, 0xa8, 0x0f, 0xba, 0xcd, 0x58, 0x06, 0x0a, 0xf0, 0x7a, 0xfd, + 0x5a, 0x7a, 0x20, 0xc3, 0xa5, 0x9f, 0x4c, 0x61, 0xc3, 0x3f, 0x31, 0xbe, 0x0d, 0x3b, 0x04, 0x33, 0x1d, 0xb4, 0x82, + 0xc7, 0x29, 0x32, 0xcd, 0xda, 0x22, 0xe9, 0xc7, 0x17, 0x59, 0xae, 0xe8, 0x8b, 0xe8, 0x90, 0x74, 0xcc, 0x9c, 0x61, + 0x43, 0xc4, 0x1b, 0x7a, 0xf5, 0x37, 0xb2, 0xdb, 0xa5, 0x09, 0x7b, 0x2d, 0xc1, 0x83, 0x3d, 0x45, 0xa9, 0x5a, 0xc5, + 0xfb, 0xc9, 0x06, 0xdc, 0x76, 0x97, 0xa5, 0x53, 0x5c, 0xad, 0x12, 0x38, 0xea, 0xa1, 0xc4, 0xbc, 0xa4, 0x06, 0xf8, + 0x80, 0x53, 0x04, 0x22, 0x48, 0xec, 0x0e, 0x53, 0xd4, 0x85, 0xd2, 0x06, 0xd5, 0xad, 0xd7, 0xd5, 0x51, 0x98, 0x18, + 0xe4, 0x81, 0xb3, 0x53, 0x7a, 0xe9, 0x1a, 0x68, 0x14, 0x56, 0x82, 0xd1, 0xd8, 0xaa, 0x10, 0xa3, 0x31, 0xd5, 0x40, + 0x82, 0x88, 0xa6, 0x62, 0xab, 0xd6, 0xc2, 0xfd, 0x22, 0xcb, 0xa5, 0x67, 0x76, 0xb1, 0x96, 0x6e, 0x21, 0xb9, 0xb0, + 0xfd, 0x11, 0x3a, 0x9b, 0x5a, 0x43, 0x73, 0xa1, 0xda, 0xce, 0xfa, 0x70, 0xba, 0x21, 0xc5, 0x5c, 0x9c, 0x71, 0x0e, + 0x07, 0xd8, 0xd4, 0x1e, 0xd7, 0x7c, 0xb0, 0xf1, 0x5a, 0xb3, 0xc6, 0xa0, 0xea, 0x69, 0x4b, 0x15, 0xf5, 0x82, 0x18, + 0x65, 0xbe, 0xa6, 0x7d, 0x37, 0xf6, 0xea, 0x60, 0xb1, 0xb2, 0x52, 0xc8, 0x45, 0x25, 0x9c, 0x03, 0x51, 0x27, 0xbc, + 0xe1, 0x72, 0x2e, 0x78, 0x80, 0x13, 0xf7, 0x76, 0x18, 0x06, 0x40, 0x55, 0x68, 0xc7, 0x5c, 0x81, 0x65, 0x56, 0x75, + 0xce, 0xf8, 0xd0, 0x58, 0x6b, 0xec, 0xa2, 0x8e, 0xed, 0xf7, 0x34, 0xd3, 0xad, 0x63, 0x52, 0x97, 0x44, 0xa9, 0x5a, + 0xc9, 0x76, 0x95, 0x8c, 0x4e, 0x58, 0x31, 0x8a, 0xa1, 0x0a, 0xfc, 0x61, 0xef, 0x3d, 0xb5, 0xef, 0x48, 0x87, 0x29, + 0xcb, 0x40, 0x7b, 0x9d, 0xa8, 0x85, 0x1a, 0x4a, 0x4d, 0xe2, 0x41, 0xac, 0x8d, 0x08, 0x93, 0xc6, 0x12, 0x0c, 0xa5, + 0x29, 0x08, 0x2c, 0x21, 0x22, 0x90, 0x4b, 0xd7, 0x4a, 0x63, 0x50, 0x15, 0x9b, 0xd5, 0x38, 0x4c, 0x15, 0x1d, 0x2d, + 0x81, 0x8e, 0x94, 0x2e, 0xfb, 0xee, 0x23, 0xba, 0xec, 0xef, 0x9a, 0xcd, 0xbf, 0x93, 0xea, 0x3c, 0x42, 0xe5, 0x41, + 0x77, 0x55, 0x90, 0x77, 0x4a, 0x27, 0x7a, 0x27, 0x47, 0x51, 0xe4, 0x28, 0x83, 0x3f, 0x28, 0x1b, 0x31, 0x9c, 0xee, + 0x80, 0x5b, 0x79, 0xf4, 0xba, 0xb2, 0x6a, 0x5b, 0x6b, 0x53, 0x76, 0x24, 0xf7, 0x29, 0x27, 0xe8, 0x5b, 0xe7, 0xc3, + 0x04, 0xa7, 0x4b, 0xed, 0xd2, 0xc0, 0xa2, 0x5e, 0xf5, 0xf5, 0xbc, 0x5a, 0x0b, 0xee, 0x3e, 0xd4, 0xcf, 0x79, 0x91, + 0x2d, 0xf3, 0x09, 0x2f, 0x1c, 0xdd, 0x53, 0xb2, 0x91, 0xf3, 0x62, 0x6c, 0x39, 0x9d, 0x64, 0x4e, 0x31, 0x6d, 0x7b, + 0x72, 0x63, 0x33, 0x0a, 0xf9, 0x21, 0xe5, 0x36, 0x2b, 0x9a, 0xd6, 0xf5, 0xed, 0xd7, 0x81, 0xa4, 0x8b, 0x58, 0x5e, + 0x01, 0x99, 0xc7, 0xf2, 0x6a, 0xbd, 0x8e, 0xf6, 0x22, 0x3a, 0x8f, 0x6f, 0xdf, 0xbf, 0x7b, 0x09, 0x1a, 0x34, 0x3e, + 0xac, 0xd7, 0x8f, 0xfb, 0x7d, 0xaa, 0x5d, 0x00, 0x95, 0x65, 0xe2, 0xcb, 0xc7, 0x7d, 0x2a, 0x95, 0xe8, 0x0a, 0xb8, + 0xaf, 0x9f, 0xd6, 0xeb, 0xc7, 0xfc, 0x80, 0xaa, 0xac, 0xa8, 0x50, 0x17, 0x1f, 0x18, 0x03, 0xd4, 0x2a, 0x3f, 0x14, + 0x57, 0x39, 0x84, 0xd6, 0xeb, 0x3e, 0x05, 0x6f, 0xc6, 0xd1, 0x4c, 0xf2, 0xfc, 0xcc, 0xb6, 0xd2, 0x2c, 0x6a, 0x33, + 0xc8, 0xbe, 0x5b, 0x9a, 0x28, 0x82, 0xf7, 0x5b, 0x89, 0x80, 0xfe, 0x28, 0xd9, 0x28, 0xba, 0x92, 0x72, 0x51, 0x04, + 0x7b, 0x7b, 0xf1, 0x22, 0xf1, 0x8b, 0x04, 0x12, 0xee, 0x16, 0xd7, 0x97, 0xfe, 0x24, 0x9b, 0x47, 0xb4, 0xf6, 0x6e, + 0x29, 0x12, 0xf3, 0x62, 0x4c, 0xbf, 0xc5, 0x8b, 0x4a, 0x7e, 0x94, 0xd6, 0x4e, 0x38, 0x24, 0xf6, 0x07, 0x24, 0xc7, + 0x59, 0xaf, 0x6b, 0x59, 0x5e, 0x0f, 0xfd, 0xc7, 0xe1, 0xb7, 0xfa, 0xb2, 0x91, 0x1f, 0xa5, 0xb1, 0xef, 0x91, 0xc0, + 0x29, 0x43, 0x23, 0x24, 0x19, 0xbe, 0x47, 0x0a, 0x63, 0xcf, 0xa5, 0xe7, 0xa0, 0xba, 0x0e, 0xa4, 0x8e, 0x17, 0xf3, + 0xa7, 0xbc, 0x48, 0x2e, 0x45, 0x64, 0x2d, 0x55, 0xdf, 0xc2, 0x5e, 0xa5, 0x22, 0xec, 0xef, 0xeb, 0xda, 0x27, 0xec, + 0x7b, 0x2c, 0x4b, 0xb6, 0x71, 0xb1, 0xde, 0x7b, 0x24, 0x7b, 0x51, 0x57, 0x1c, 0x7f, 0x73, 0x49, 0x1f, 0x6b, 0x54, + 0xef, 0xbe, 0x73, 0x4e, 0xc8, 0xb8, 0x9a, 0xff, 0x7b, 0x9d, 0xec, 0xf3, 0x27, 0xc9, 0x5c, 0xc8, 0xc7, 0x7a, 0xfa, + 0xaa, 0x29, 0xdf, 0x87, 0x79, 0x56, 0x34, 0x01, 0x94, 0xa0, 0xa7, 0xbc, 0x3d, 0xd8, 0x9c, 0xd6, 0xf6, 0xc0, 0xb1, + 0x35, 0xfc, 0x43, 0x56, 0x11, 0x2d, 0x86, 0x5b, 0xd9, 0x7e, 0xaa, 0x98, 0x16, 0x43, 0x3a, 0xca, 0x9f, 0x3b, 0x4b, + 0xb3, 0x2c, 0xf7, 0x6a, 0x53, 0xf1, 0x79, 0x42, 0x0c, 0x2d, 0xa9, 0x40, 0x16, 0xf3, 0x85, 0x91, 0x33, 0x6e, 0xb3, + 0x46, 0xb6, 0xe2, 0x1e, 0x3c, 0x83, 0x29, 0xb7, 0x33, 0x3e, 0xb0, 0xc1, 0xc6, 0xf7, 0xf6, 0x64, 0xd7, 0xd1, 0x30, + 0xd3, 0x89, 0xb1, 0x30, 0x6d, 0x3c, 0xdc, 0xf5, 0x67, 0xdd, 0x2f, 0xd6, 0x74, 0x68, 0xca, 0x30, 0x89, 0x5d, 0x99, + 0xb1, 0xcc, 0xbe, 0xd0, 0x59, 0x05, 0xb3, 0x2d, 0x90, 0xc5, 0xf6, 0xf3, 0x2d, 0x50, 0x03, 0xeb, 0xd5, 0x21, 0xf9, + 0xcf, 0x62, 0x09, 0x36, 0xa6, 0x1b, 0xc8, 0xdd, 0xc7, 0x22, 0xcd, 0x4f, 0x23, 0x9a, 0xb2, 0x3e, 0x46, 0xe6, 0xa3, + 0xe4, 0x9f, 0x41, 0xa4, 0xfe, 0x02, 0xc7, 0x58, 0x9d, 0xf6, 0xb2, 0x11, 0x3b, 0x9d, 0xce, 0x42, 0xa7, 0x8d, 0x71, + 0x48, 0x6c, 0xee, 0x91, 0xd5, 0xb4, 0xd3, 0x61, 0xde, 0x24, 0xe5, 0xb1, 0x99, 0x36, 0x6f, 0x4a, 0x94, 0xd1, 0xaa, + 0xa2, 0x99, 0x2b, 0x8f, 0xac, 0x26, 0xc0, 0xe9, 0x4d, 0xcf, 0x90, 0x12, 0x91, 0x45, 0xa8, 0x29, 0x40, 0xf0, 0x05, + 0x9d, 0x7b, 0x84, 0xce, 0x6a, 0xbc, 0x12, 0x73, 0x28, 0xca, 0x65, 0xd1, 0xf8, 0xca, 0x16, 0x57, 0x1f, 0x97, 0x04, + 0x41, 0xaf, 0x7a, 0xe3, 0xfa, 0x80, 0x12, 0xdc, 0xd8, 0x09, 0xe3, 0x21, 0xd4, 0x61, 0xb9, 0x9b, 0x03, 0x72, 0xf7, + 0x08, 0x4e, 0xaa, 0xed, 0x15, 0x66, 0xb1, 0x82, 0x31, 0x05, 0x05, 0x5d, 0xc4, 0x77, 0x20, 0xb0, 0x02, 0x49, 0x55, + 0xf7, 0xc1, 0x84, 0xc2, 0x01, 0xba, 0x84, 0x17, 0xa7, 0xe0, 0x02, 0x4e, 0xcd, 0x2f, 0x9d, 0xf9, 0x3b, 0x98, 0xd9, + 0xac, 0xab, 0xcb, 0x0b, 0x88, 0x9e, 0xba, 0xe0, 0x01, 0x37, 0x9a, 0xd1, 0x95, 0xb3, 0xc7, 0xb8, 0x44, 0xc4, 0x44, + 0xb3, 0x38, 0x49, 0xf9, 0x34, 0xa2, 0x8b, 0x3a, 0x0a, 0x3c, 0x1d, 0x07, 0xb3, 0xac, 0xed, 0x18, 0xe0, 0x3a, 0x9a, + 0x7f, 0x1b, 0xae, 0xae, 0xbd, 0xda, 0x92, 0x02, 0xc6, 0x10, 0x15, 0x4b, 0x3c, 0x05, 0x1b, 0x19, 0x47, 0xe3, 0x8c, + 0xcd, 0xdc, 0x6d, 0x0c, 0xee, 0x61, 0xe8, 0x44, 0xfb, 0xea, 0x4c, 0x7f, 0x81, 0xe3, 0x9d, 0xd3, 0xc3, 0x09, 0xc0, + 0xf1, 0x82, 0xc6, 0xb7, 0xe6, 0xca, 0x36, 0x9a, 0x87, 0xfa, 0x66, 0xaa, 0xaf, 0x6a, 0x50, 0x85, 0xd6, 0x49, 0x8a, + 0x40, 0x47, 0x64, 0xb5, 0x64, 0x39, 0xbd, 0xb4, 0x47, 0x04, 0xd1, 0xe5, 0xa3, 0x0a, 0x0d, 0x92, 0xd7, 0x6b, 0xeb, + 0x57, 0x09, 0xef, 0x3c, 0x12, 0x5c, 0x7a, 0xc4, 0xad, 0x0d, 0xb4, 0x05, 0xb7, 0x13, 0xb5, 0xeb, 0x0b, 0x5d, 0xd4, + 0x96, 0x93, 0x49, 0x22, 0x29, 0x6d, 0x99, 0xba, 0xfb, 0xaa, 0x37, 0x50, 0x49, 0x3a, 0xb8, 0xcd, 0x60, 0xa7, 0x9f, + 0x98, 0x20, 0xe5, 0x84, 0x45, 0x13, 0x9d, 0xa1, 0x7d, 0xcb, 0xe4, 0xe5, 0xb5, 0x59, 0xbb, 0x53, 0x77, 0x18, 0x40, + 0xa2, 0x61, 0x8b, 0x33, 0x83, 0x86, 0xb9, 0x67, 0xf4, 0x40, 0xeb, 0xfa, 0x19, 0xea, 0x43, 0xbe, 0x26, 0xd1, 0x42, + 0x32, 0xf3, 0xcc, 0x70, 0xc9, 0x6a, 0xca, 0x9a, 0x9b, 0xbf, 0x39, 0x2e, 0xec, 0xfa, 0xf4, 0xc3, 0x98, 0x01, 0x15, + 0x25, 0xb5, 0x42, 0xd6, 0xa2, 0xc5, 0xc1, 0xa7, 0x9a, 0xf8, 0x95, 0xa6, 0xeb, 0x8a, 0x37, 0x18, 0x3c, 0x04, 0x79, + 0xa5, 0xdc, 0x9b, 0x2c, 0xce, 0xd7, 0x5e, 0x82, 0xc7, 0x91, 0x21, 0xcb, 0xa5, 0x51, 0x56, 0x68, 0xda, 0xed, 0xd2, + 0x1a, 0x64, 0x77, 0xd4, 0xc8, 0x7c, 0x42, 0x05, 0xe4, 0xd8, 0xa2, 0x89, 0xdd, 0xe4, 0x58, 0x03, 0xb4, 0x5b, 0x9f, + 0x50, 0xc9, 0x2b, 0x8c, 0xfd, 0xdc, 0x70, 0xce, 0xfe, 0x84, 0x3e, 0x7a, 0x0e, 0x6a, 0xfe, 0x68, 0xec, 0xba, 0xdc, + 0x09, 0xdc, 0x5b, 0xe9, 0x52, 0x28, 0x78, 0x08, 0x37, 0x16, 0x84, 0x33, 0x17, 0x89, 0x36, 0x88, 0xeb, 0x88, 0xa7, + 0x7f, 0x80, 0x31, 0x10, 0x4a, 0xcc, 0xf0, 0xe0, 0xde, 0xad, 0x18, 0x5c, 0x42, 0xea, 0xb4, 0x7c, 0xb5, 0x91, 0xc1, + 0xa1, 0xc2, 0xa9, 0xac, 0xaa, 0xad, 0xd8, 0x91, 0x94, 0x00, 0x84, 0x98, 0xc2, 0xd6, 0x15, 0xaf, 0x3d, 0x58, 0xaf, + 0x1d, 0xcb, 0xea, 0x0a, 0x0f, 0xdc, 0x06, 0x09, 0x85, 0x2a, 0x41, 0x0c, 0xdb, 0xf7, 0x17, 0x4a, 0xaf, 0x01, 0x3b, + 0xbf, 0xa6, 0x29, 0x5e, 0xc2, 0xe5, 0xa8, 0xaa, 0x1c, 0x83, 0xf5, 0xb4, 0x9c, 0x02, 0xf6, 0x2a, 0x96, 0x8b, 0x20, + 0x77, 0x58, 0xc7, 0xdf, 0x41, 0x0e, 0xa3, 0xc4, 0xdd, 0xfd, 0x88, 0x86, 0xcb, 0x85, 0xb6, 0xa7, 0xb7, 0x77, 0x51, + 0x00, 0x69, 0x9c, 0xfe, 0x66, 0x2e, 0xd8, 0x69, 0xdb, 0xf5, 0x88, 0xef, 0xd9, 0x4a, 0x9d, 0x5c, 0x0e, 0x24, 0x85, + 0x1b, 0x81, 0xc5, 0x34, 0x16, 0x93, 0xbb, 0xe0, 0x67, 0x14, 0x44, 0x66, 0xd6, 0x76, 0xeb, 0x3a, 0x81, 0x14, 0xb5, + 0x8d, 0x25, 0x4d, 0x1a, 0x97, 0x01, 0x1b, 0xb5, 0x54, 0xf7, 0xfc, 0x74, 0xa3, 0xe7, 0x96, 0x30, 0xbc, 0xee, 0xd1, + 0xfe, 0x23, 0x42, 0xff, 0x2e, 0x87, 0x60, 0xd9, 0x2e, 0x20, 0x76, 0x46, 0xed, 0x36, 0x71, 0x0c, 0xe8, 0xd2, 0xc8, + 0x59, 0xec, 0x57, 0x70, 0x29, 0xd9, 0xa8, 0xdb, 0x7d, 0x6e, 0xef, 0xcf, 0x23, 0xab, 0x9c, 0x21, 0xc4, 0xda, 0x64, + 0xf1, 0xb4, 0x26, 0x20, 0x43, 0xe7, 0x19, 0xbc, 0xbb, 0x10, 0xc2, 0x81, 0xae, 0x3f, 0x48, 0x07, 0xc9, 0xc5, 0xd4, + 0x8e, 0xb3, 0x9d, 0x83, 0x4f, 0x39, 0xf4, 0x9a, 0xd0, 0x91, 0x20, 0x57, 0x07, 0xa8, 0xc1, 0x90, 0x4e, 0x05, 0xf1, + 0x88, 0xda, 0x7a, 0x57, 0x18, 0x11, 0x02, 0x66, 0xa7, 0x22, 0x52, 0xa1, 0xac, 0x3c, 0xb8, 0xfb, 0x79, 0x89, 0xfb, + 0x5f, 0x6b, 0xe0, 0x69, 0x94, 0x6d, 0xb7, 0xed, 0x6c, 0x54, 0x1a, 0x50, 0xb4, 0x1c, 0x95, 0xae, 0xa9, 0x3b, 0x16, + 0xee, 0x35, 0x7a, 0x54, 0xdc, 0xbb, 0x11, 0x01, 0x8b, 0x07, 0x5e, 0xc3, 0xb1, 0x90, 0x24, 0x94, 0x81, 0xa8, 0x6e, + 0x3a, 0x55, 0x87, 0x01, 0x13, 0x90, 0x74, 0x3a, 0x01, 0x7c, 0x20, 0x1c, 0xa2, 0xfb, 0xde, 0xcc, 0x73, 0x6d, 0xf9, + 0x59, 0xf3, 0x9d, 0x5a, 0x6a, 0x2f, 0xd0, 0x57, 0x52, 0x37, 0x05, 0x09, 0x38, 0xd9, 0xaa, 0x6f, 0x55, 0x83, 0xeb, + 0x45, 0xac, 0x51, 0x1c, 0xfc, 0xc7, 0x4d, 0x7b, 0xbb, 0xf6, 0x66, 0x6f, 0xa6, 0x0a, 0x20, 0xda, 0xe4, 0xde, 0x3e, + 0x53, 0x56, 0x44, 0xcb, 0x11, 0xf3, 0x8a, 0x9f, 0x55, 0x77, 0xd9, 0x40, 0x0f, 0x59, 0xca, 0x7d, 0x8e, 0x07, 0x3d, + 0xe1, 0xf8, 0x17, 0xdc, 0x54, 0x2a, 0x6a, 0x02, 0x3f, 0x13, 0xda, 0xc8, 0xe7, 0x6e, 0x84, 0xf4, 0x25, 0x38, 0x70, + 0x51, 0xdf, 0x15, 0x10, 0x9e, 0xf2, 0xc4, 0x91, 0x92, 0xf8, 0xaa, 0x6d, 0x9c, 0x13, 0xa9, 0x96, 0x59, 0x49, 0x02, + 0x59, 0x6b, 0xb1, 0x30, 0x2d, 0xaa, 0x21, 0x9e, 0x65, 0x30, 0x6b, 0xac, 0xf6, 0x2b, 0xac, 0xfd, 0xaa, 0xf4, 0x3c, + 0x65, 0xa8, 0x20, 0x81, 0x34, 0xf8, 0xf9, 0xfb, 0x92, 0x2f, 0x79, 0x9d, 0x50, 0x6c, 0xd1, 0x03, 0x74, 0xe2, 0xd4, + 0x41, 0xeb, 0x5f, 0xb5, 0x63, 0x96, 0x36, 0x8e, 0x41, 0x25, 0x66, 0xac, 0x01, 0x02, 0x2b, 0x47, 0x5f, 0x3a, 0x57, + 0x2b, 0xa7, 0xb8, 0x0c, 0xf2, 0x2d, 0xb6, 0xc0, 0x44, 0x5b, 0x15, 0x61, 0xc6, 0x95, 0x2a, 0x6d, 0x7e, 0x15, 0xb0, + 0x52, 0xad, 0xaa, 0x0c, 0xab, 0x88, 0x90, 0x15, 0x20, 0xbb, 0xaa, 0x01, 0xe6, 0x6c, 0x4c, 0x69, 0xc1, 0x0e, 0x57, + 0x40, 0x57, 0xb9, 0xcb, 0x6c, 0xb5, 0x98, 0xcf, 0x2d, 0x11, 0xe5, 0xec, 0x10, 0xbe, 0x4f, 0x9a, 0x5f, 0x41, 0x76, + 0x64, 0x19, 0x56, 0x76, 0x62, 0x65, 0x90, 0x5a, 0x81, 0xb3, 0x59, 0x96, 0x65, 0xa0, 0xe7, 0xa8, 0x74, 0xc5, 0x9d, + 0xa6, 0xf0, 0xd8, 0x52, 0x78, 0x56, 0xb2, 0x58, 0x78, 0x79, 0x2d, 0x42, 0xa3, 0xd3, 0x81, 0xd6, 0x33, 0xed, 0x7e, + 0x6d, 0xc7, 0x5b, 0x46, 0x0f, 0xe6, 0xdd, 0x6a, 0x19, 0x3d, 0x85, 0x19, 0x0c, 0x4c, 0xc0, 0x49, 0xbb, 0x20, 0x08, + 0x5e, 0xac, 0x1a, 0x30, 0xbd, 0xc3, 0x8d, 0xa3, 0x5c, 0x19, 0x81, 0x30, 0xd8, 0xdc, 0x0e, 0x4f, 0x00, 0x45, 0x61, + 0x8e, 0x0c, 0x3b, 0x32, 0xa1, 0xed, 0xa6, 0xb8, 0x22, 0xac, 0x45, 0x6f, 0x22, 0x1a, 0x77, 0x29, 0xbc, 0x94, 0x1e, + 0x5a, 0x21, 0xda, 0x7d, 0xfa, 0x06, 0xf6, 0x94, 0xda, 0xbd, 0xd0, 0xb4, 0xde, 0xe9, 0xbd, 0x8a, 0xb5, 0x4d, 0x82, + 0xd9, 0x7b, 0x83, 0x7c, 0x3a, 0x1d, 0xc8, 0x88, 0xa2, 0x4c, 0x33, 0x54, 0x98, 0x75, 0x49, 0x6d, 0x63, 0x54, 0x08, + 0x60, 0x11, 0xaa, 0x32, 0x6e, 0xb0, 0x95, 0xda, 0xb2, 0x3d, 0x80, 0x03, 0x8e, 0x3c, 0xd3, 0xcc, 0x91, 0x9e, 0xc6, + 0xc2, 0x5b, 0x37, 0x89, 0xdc, 0x43, 0x9d, 0xe6, 0x18, 0x6a, 0xd6, 0xe9, 0xc0, 0x29, 0xd5, 0xd8, 0x60, 0x3e, 0x66, + 0x92, 0x66, 0x4c, 0xd0, 0x44, 0xf1, 0x2c, 0xe5, 0x07, 0x30, 0xfb, 0x9c, 0x5c, 0xb9, 0x02, 0xe1, 0xcf, 0x76, 0x97, + 0xa1, 0xf6, 0xe0, 0xc0, 0x1f, 0xd8, 0x19, 0x94, 0x84, 0xfe, 0x21, 0xb8, 0x94, 0x9d, 0x29, 0x81, 0xc5, 0x13, 0x33, + 0xed, 0x82, 0x70, 0xec, 0xda, 0x2f, 0x94, 0x93, 0xd9, 0x5c, 0xcc, 0x35, 0xcc, 0xd0, 0x9a, 0x95, 0x10, 0xd4, 0x50, + 0x81, 0xbb, 0x41, 0xea, 0x81, 0x91, 0x1c, 0x8f, 0xc4, 0xb8, 0xf2, 0xc4, 0x43, 0xce, 0xed, 0xa6, 0x95, 0x08, 0xdd, + 0xbb, 0xd6, 0x18, 0x37, 0x1e, 0x19, 0x5b, 0x5c, 0xb5, 0xff, 0xec, 0x74, 0x34, 0xa3, 0x01, 0x43, 0x57, 0xf8, 0x42, + 0x1d, 0xd5, 0x4e, 0x48, 0x20, 0x44, 0x49, 0x53, 0xb8, 0x18, 0xfc, 0xd0, 0xbd, 0xd1, 0xd3, 0xab, 0x67, 0x55, 0xb9, + 0xcf, 0x3d, 0xa6, 0x9d, 0x63, 0xed, 0x9c, 0xac, 0x44, 0xe5, 0x21, 0x29, 0x27, 0xc2, 0x1b, 0xe5, 0xeb, 0x35, 0xfa, + 0x9b, 0x0f, 0xdd, 0x70, 0xad, 0x4e, 0xc7, 0x5e, 0xc2, 0xf7, 0xad, 0x5e, 0x3f, 0x90, 0xf7, 0xcd, 0xb3, 0xfe, 0x14, + 0x5e, 0x2d, 0xbc, 0x12, 0x19, 0x6f, 0xcd, 0x42, 0xb1, 0x44, 0x79, 0x05, 0x3c, 0xfd, 0x5e, 0xb7, 0x5d, 0xed, 0x96, + 0xf2, 0xa0, 0xee, 0xe7, 0xdf, 0xea, 0x6f, 0x5d, 0x29, 0x2f, 0x8e, 0x76, 0xb0, 0x56, 0x6c, 0x79, 0x2a, 0x36, 0x7c, + 0x61, 0xac, 0xe9, 0x0b, 0x5b, 0x61, 0xd2, 0x22, 0x84, 0x4a, 0x25, 0xe0, 0x80, 0x38, 0xaf, 0xba, 0xf3, 0xac, 0xd1, + 0x99, 0x5b, 0x0b, 0x36, 0x06, 0x93, 0x74, 0x39, 0xe5, 0x85, 0x17, 0xad, 0xa2, 0xea, 0xc0, 0xb5, 0xb0, 0x4a, 0x89, + 0xdb, 0x8b, 0xb4, 0x3d, 0x94, 0x35, 0xf7, 0x20, 0x04, 0xf3, 0xb8, 0xfe, 0xc1, 0xaa, 0x0b, 0x35, 0x77, 0xdf, 0x3a, + 0x29, 0x70, 0xaa, 0x9b, 0x11, 0xc1, 0xc7, 0x6f, 0xac, 0xd6, 0xe6, 0x0b, 0x45, 0xab, 0x02, 0xcd, 0x2a, 0x41, 0x5e, + 0x06, 0xcd, 0x72, 0x58, 0xe6, 0xb0, 0x57, 0x85, 0xd9, 0x15, 0x63, 0x5c, 0xd4, 0x28, 0x55, 0x29, 0x74, 0x41, 0x74, + 0xce, 0x93, 0x19, 0xd8, 0x35, 0xf1, 0xa2, 0xb0, 0x99, 0x60, 0x22, 0xbe, 0x4e, 0x2e, 0x21, 0xe1, 0x8f, 0x7f, 0xcd, + 0xc5, 0x34, 0xcb, 0xed, 0xae, 0x29, 0x3a, 0x5a, 0x2c, 0x52, 0x1e, 0x41, 0x44, 0x9f, 0xf5, 0x6d, 0x5b, 0xcc, 0x2f, + 0x34, 0xe6, 0xeb, 0x37, 0xdc, 0x47, 0xc5, 0xf5, 0x65, 0x84, 0xb7, 0xd2, 0x47, 0x17, 0xe6, 0x61, 0x1e, 0x17, 0x1f, + 0xa2, 0xc0, 0x46, 0x22, 0x98, 0x07, 0xdc, 0x93, 0x42, 0x94, 0x3a, 0xec, 0x6a, 0x66, 0x02, 0x34, 0x06, 0xdb, 0xf1, + 0x93, 0x18, 0x7b, 0xed, 0x0d, 0x48, 0xa8, 0x5a, 0x74, 0xde, 0xe9, 0x74, 0xe2, 0xc7, 0x10, 0x2a, 0xae, 0x6b, 0x85, + 0xd8, 0x99, 0xea, 0x08, 0xc7, 0x37, 0x17, 0x6c, 0xcf, 0xb3, 0xd1, 0xbc, 0x23, 0x8c, 0x67, 0xd4, 0x3f, 0xe0, 0x16, + 0xa2, 0x2b, 0xc1, 0x9c, 0x60, 0xdf, 0xda, 0xeb, 0xdd, 0xbd, 0xcb, 0x8a, 0x92, 0x2f, 0xad, 0x02, 0xac, 0xf3, 0xfb, + 0x0f, 0xac, 0xfb, 0x1f, 0xf9, 0xd8, 0x7a, 0xcd, 0x06, 0xfd, 0xbe, 0x6b, 0x87, 0xd0, 0x79, 0x90, 0x4d, 0x35, 0x34, + 0x1c, 0x4d, 0x78, 0x92, 0x7a, 0xfc, 0x73, 0xf9, 0xb9, 0x20, 0x7b, 0xe2, 0x41, 0xc2, 0x6b, 0xf1, 0xa1, 0x09, 0x8d, + 0x52, 0x01, 0x86, 0x73, 0x61, 0xb7, 0x8c, 0x2a, 0xff, 0x4d, 0x53, 0x5e, 0xb7, 0xb8, 0x9b, 0x88, 0x22, 0xb7, 0x21, + 0x86, 0x19, 0xbb, 0x12, 0xea, 0xa6, 0x89, 0x58, 0x59, 0xb9, 0x86, 0x2a, 0xcb, 0xbc, 0xcd, 0x39, 0xe2, 0x44, 0x0d, + 0xc7, 0x64, 0xa8, 0x62, 0x82, 0x39, 0x09, 0x13, 0xe3, 0xb0, 0x09, 0xf4, 0xd3, 0xe6, 0x08, 0xb4, 0xdd, 0xca, 0xd6, + 0x54, 0x19, 0xbe, 0xaa, 0xae, 0xab, 0x6c, 0x5f, 0xd6, 0xb7, 0xa4, 0x43, 0x1d, 0x23, 0x32, 0xcc, 0x58, 0x3b, 0x73, + 0x96, 0xef, 0x39, 0x22, 0x98, 0x45, 0x53, 0x3e, 0x2b, 0x22, 0xa3, 0x71, 0x46, 0x91, 0x52, 0x61, 0x2c, 0x31, 0x44, + 0x5d, 0x1d, 0xac, 0x36, 0xcc, 0xe1, 0xa4, 0x58, 0x65, 0x28, 0xb4, 0x55, 0x0e, 0x23, 0xb8, 0x50, 0x25, 0xae, 0x7d, + 0xb5, 0x87, 0x9f, 0xe9, 0xcc, 0x86, 0xbd, 0xc1, 0x7a, 0x1d, 0x2b, 0x8a, 0x52, 0xd6, 0x09, 0x73, 0x2a, 0xc6, 0x6d, + 0x42, 0x8d, 0x25, 0x73, 0xab, 0x89, 0x2e, 0x33, 0xb1, 0xad, 0x49, 0x77, 0x00, 0xa2, 0x5d, 0x85, 0x34, 0x53, 0xce, + 0xaa, 0x98, 0xd7, 0xdc, 0x94, 0x76, 0x4d, 0x59, 0xd6, 0x1d, 0x98, 0xad, 0xf0, 0x0a, 0xc6, 0x06, 0x57, 0x91, 0xe8, + 0x73, 0x05, 0xdc, 0x19, 0xfe, 0xb5, 0xa8, 0x05, 0xb1, 0xf0, 0x30, 0x7a, 0x02, 0xb5, 0x0f, 0x31, 0xa2, 0xe2, 0xc9, + 0x9e, 0x7e, 0x86, 0x54, 0x4d, 0x95, 0xc1, 0xa1, 0xbe, 0x27, 0x63, 0xe7, 0x0e, 0x47, 0x87, 0xf6, 0x72, 0x38, 0xfe, + 0x56, 0x50, 0xd9, 0xcd, 0xcd, 0x2d, 0x31, 0x5d, 0xa1, 0xaf, 0x6b, 0x12, 0xe6, 0x02, 0xb1, 0x08, 0xb3, 0x04, 0x44, + 0x3a, 0xc7, 0xfa, 0x52, 0xa8, 0x03, 0x73, 0x53, 0x53, 0x00, 0x87, 0x24, 0x9c, 0x23, 0x87, 0xb7, 0xa2, 0x16, 0xd6, + 0x58, 0xc9, 0x00, 0x9a, 0x9b, 0x88, 0x6c, 0x64, 0xce, 0x34, 0x61, 0xea, 0x2c, 0x01, 0x84, 0x9c, 0xcf, 0x24, 0x1e, + 0x28, 0x10, 0xbe, 0xcc, 0x16, 0xfa, 0x50, 0x81, 0x50, 0xc1, 0xd5, 0x36, 0x6e, 0x5f, 0xc7, 0x54, 0x97, 0x98, 0x73, + 0x07, 0x98, 0xfe, 0x70, 0x04, 0x39, 0x4c, 0xb6, 0x08, 0x4d, 0xdc, 0xf4, 0xe8, 0x58, 0x4a, 0x24, 0x0d, 0x0c, 0x90, + 0x44, 0x07, 0x96, 0x32, 0x44, 0x0c, 0x45, 0x98, 0x87, 0x59, 0x97, 0xed, 0x07, 0x9e, 0xb6, 0xbc, 0x47, 0x78, 0x3e, + 0x1c, 0xee, 0xf2, 0xf0, 0xa2, 0xae, 0x97, 0xa8, 0xae, 0xbb, 0x09, 0x42, 0x06, 0x97, 0xb3, 0xa9, 0x94, 0x78, 0x1e, + 0xe9, 0x46, 0xad, 0xa8, 0xeb, 0xf5, 0x7b, 0x09, 0x00, 0x5a, 0x7f, 0x41, 0x22, 0x8c, 0xd7, 0xc6, 0xd6, 0xe0, 0xd8, + 0x0e, 0xf7, 0x7a, 0x83, 0xd6, 0x00, 0x4a, 0xb1, 0x32, 0x53, 0x8d, 0xb1, 0x3e, 0x09, 0x20, 0xf0, 0x72, 0x6b, 0xbf, + 0xd0, 0xee, 0xf6, 0x1e, 0x13, 0x3d, 0xfa, 0xee, 0x27, 0x75, 0x3c, 0x68, 0xf5, 0xb6, 0x75, 0xac, 0xb4, 0x23, 0x63, + 0xcf, 0xcb, 0x9e, 0xe0, 0xad, 0x54, 0x3d, 0xd7, 0x70, 0x9d, 0xed, 0x3d, 0x22, 0x9f, 0x3f, 0x22, 0x34, 0xfb, 0x8c, + 0x3d, 0xa2, 0x99, 0x62, 0xd1, 0xad, 0x41, 0x50, 0x30, 0xd3, 0xff, 0xde, 0xbe, 0x82, 0x80, 0x56, 0x77, 0xaa, 0xeb, + 0x20, 0x76, 0xef, 0xeb, 0x7e, 0x2b, 0xea, 0x16, 0x4d, 0xc8, 0x8b, 0x26, 0xa8, 0x4e, 0xfc, 0x7e, 0x6b, 0x3f, 0xd8, + 0x6c, 0x66, 0xf0, 0x55, 0xbf, 0x55, 0x4d, 0x01, 0xf6, 0xf7, 0x30, 0x4a, 0x0c, 0x48, 0x1b, 0x48, 0x71, 0x7b, 0x3a, + 0xc0, 0x31, 0xd4, 0x9b, 0xdc, 0x32, 0x86, 0xde, 0x27, 0x0e, 0xa2, 0xcc, 0x3e, 0xdb, 0x67, 0x0c, 0xae, 0x3e, 0x50, + 0x4d, 0x41, 0x5c, 0x02, 0xc0, 0x80, 0x89, 0xa1, 0x75, 0xeb, 0x1a, 0xed, 0x0a, 0x5d, 0x6a, 0x26, 0xe0, 0xee, 0x13, + 0x05, 0x04, 0x7e, 0xa0, 0xe0, 0xd7, 0xdf, 0x28, 0x62, 0xd7, 0x7f, 0xed, 0x4b, 0x6a, 0x1e, 0x58, 0x81, 0xc7, 0x01, + 0x6c, 0x82, 0xf5, 0x98, 0xdd, 0x09, 0x2f, 0xa6, 0xd1, 0x93, 0xcb, 0x96, 0xcd, 0xcf, 0xc1, 0x76, 0xa2, 0xae, 0xac, + 0x8e, 0xd9, 0x75, 0xa3, 0x9d, 0xc3, 0x88, 0x46, 0x4f, 0xf6, 0x2e, 0x0f, 0x23, 0x62, 0x22, 0x46, 0x33, 0x96, 0xeb, + 0xae, 0x0a, 0x96, 0x9b, 0x4e, 0x26, 0xb6, 0xff, 0xb4, 0xea, 0x79, 0x49, 0xa7, 0xc3, 0xcc, 0x1c, 0x0a, 0xf6, 0xa6, + 0xac, 0x30, 0xcf, 0xd1, 0x80, 0xcf, 0xa3, 0x00, 0xad, 0x6a, 0x70, 0x60, 0x3d, 0x0a, 0xd3, 0xa0, 0xa0, 0x4b, 0x76, + 0x29, 0xbc, 0x29, 0x9d, 0xec, 0xa5, 0x84, 0x04, 0xde, 0x12, 0x2f, 0xf6, 0xd2, 0xaf, 0x27, 0x41, 0x46, 0x9d, 0xcf, + 0x2f, 0x85, 0xb7, 0xa4, 0xe9, 0xde, 0x84, 0x34, 0x9a, 0x50, 0xf0, 0xcd, 0x20, 0xd3, 0xd4, 0xc2, 0x6e, 0x6e, 0x2e, + 0x04, 0x9e, 0xb8, 0xf0, 0x66, 0xe8, 0x95, 0x75, 0xa6, 0x81, 0x94, 0xc3, 0x85, 0x3d, 0x75, 0xb1, 0x24, 0x74, 0x51, + 0x9d, 0xb4, 0x98, 0xaa, 0x96, 0xe6, 0x6c, 0x64, 0x67, 0x02, 0xa6, 0x60, 0x42, 0x53, 0x6b, 0x07, 0x99, 0xf9, 0xe6, + 0x08, 0xdf, 0xbc, 0xc2, 0x57, 0xed, 0x78, 0xeb, 0x8c, 0xea, 0x1a, 0xc1, 0x5c, 0x1d, 0x35, 0x8a, 0x1d, 0x3e, 0x7c, + 0x5a, 0x63, 0x71, 0x8e, 0x50, 0xb8, 0x4d, 0x13, 0xf1, 0x21, 0xb0, 0x5a, 0x46, 0x14, 0x44, 0xad, 0xdb, 0x79, 0x2a, + 0x8a, 0x00, 0x5f, 0xb0, 0x1d, 0xf0, 0xdf, 0x05, 0x7b, 0x7b, 0x37, 0x37, 0x37, 0xfe, 0xcd, 0x81, 0x9f, 0xe5, 0x97, + 0x7b, 0x83, 0xaf, 0xbf, 0xfe, 0x7a, 0x0f, 0xdf, 0xee, 0x44, 0xf5, 0x10, 0x4f, 0x49, 0x44, 0x97, 0x01, 0xf5, 0xf1, + 0x6e, 0x84, 0x33, 0x3b, 0xe2, 0xe3, 0x6e, 0xb4, 0x13, 0x99, 0x13, 0x97, 0x78, 0x12, 0x11, 0x5b, 0xdf, 0xd6, 0xee, + 0x7e, 0xbf, 0xdf, 0x87, 0x03, 0x82, 0x3b, 0x51, 0x57, 0x74, 0x23, 0x23, 0x21, 0xf0, 0xf2, 0xb3, 0x6a, 0x1c, 0xc7, + 0xc2, 0x3d, 0x83, 0x59, 0x1d, 0x6c, 0x82, 0xeb, 0x0f, 0xa3, 0xbf, 0x46, 0xa4, 0x2a, 0xf9, 0x0c, 0x4a, 0x3e, 0xdb, + 0x7f, 0xec, 0x96, 0xfd, 0x45, 0x95, 0x1d, 0xb8, 0x65, 0x4f, 0xb0, 0xec, 0xe0, 0xd8, 0x2d, 0x3b, 0x54, 0x65, 0x27, + 0x6e, 0xd9, 0x2f, 0x45, 0x17, 0x4a, 0x5b, 0xae, 0x3d, 0xf6, 0xc6, 0x81, 0x26, 0x52, 0x89, 0x43, 0x21, 0xc5, 0x0b, + 0x00, 0xdd, 0xbd, 0x9d, 0xa7, 0x34, 0xea, 0x1e, 0xd7, 0xad, 0x36, 0x67, 0xee, 0x07, 0xcb, 0x3c, 0xf5, 0x76, 0xa2, + 0x2e, 0x36, 0xd2, 0x8d, 0x76, 0x88, 0x52, 0xec, 0x4e, 0x04, 0x73, 0x92, 0x13, 0x0e, 0xb5, 0xe1, 0x88, 0xb3, 0x19, + 0x97, 0x93, 0xab, 0xad, 0x0e, 0x21, 0xab, 0x28, 0xd9, 0xcd, 0x03, 0x24, 0x26, 0xac, 0x22, 0x33, 0xb1, 0xcf, 0x13, + 0xc1, 0x1c, 0x13, 0xf5, 0x1b, 0x51, 0xf9, 0x42, 0x4f, 0x9c, 0x00, 0xf6, 0x0f, 0x35, 0x32, 0xa9, 0x0c, 0xad, 0x46, + 0xa9, 0x6f, 0xa9, 0x10, 0xa6, 0x5c, 0x6f, 0xd5, 0x95, 0xb7, 0x9c, 0xe4, 0xac, 0xef, 0xde, 0x4d, 0xd1, 0x1f, 0x0a, + 0xc7, 0x41, 0xe1, 0x1a, 0xd3, 0x78, 0x75, 0xe0, 0x97, 0x5b, 0xd6, 0x60, 0xd6, 0x79, 0xc2, 0x64, 0x37, 0xf2, 0x7f, + 0x2d, 0x32, 0x11, 0xa2, 0xfd, 0x80, 0x45, 0xc3, 0x9c, 0x99, 0x3e, 0x7a, 0xbc, 0x27, 0xd0, 0x5f, 0x6f, 0x4e, 0x7d, + 0x99, 0x9d, 0x9c, 0x51, 0xb6, 0x9d, 0x78, 0x83, 0x23, 0xd1, 0x38, 0xa7, 0xfb, 0xa8, 0xff, 0x08, 0x51, 0xfb, 0xab, + 0xd8, 0x48, 0xe5, 0x06, 0x6e, 0x5e, 0xa6, 0x47, 0x4d, 0x63, 0x16, 0x61, 0xcf, 0x70, 0x67, 0xa3, 0x3a, 0x9a, 0x18, + 0xd3, 0xfb, 0x43, 0x84, 0x21, 0x70, 0xa7, 0x60, 0xfd, 0xcd, 0x68, 0x21, 0x4f, 0xd0, 0x09, 0xf4, 0x50, 0x74, 0xed, + 0xd5, 0x15, 0xdd, 0x01, 0x2d, 0x0e, 0x59, 0xd2, 0xe9, 0x4c, 0x0e, 0x31, 0xbd, 0x5a, 0x65, 0x90, 0xff, 0xe4, 0x8e, + 0xec, 0x31, 0x37, 0x9a, 0x29, 0xfb, 0x8a, 0x6a, 0x03, 0xed, 0x1a, 0x55, 0x7b, 0xb9, 0xe3, 0x78, 0x7e, 0x25, 0x1a, + 0xe1, 0xe8, 0x9b, 0x06, 0xed, 0xdf, 0x64, 0x63, 0x8f, 0x07, 0x51, 0xe8, 0xb1, 0xc5, 0x6a, 0xb4, 0xa7, 0x68, 0xf2, + 0xb5, 0x80, 0xe0, 0x15, 0xb4, 0xff, 0x04, 0xbf, 0x42, 0x4e, 0x29, 0x31, 0x0d, 0x2a, 0x4c, 0x02, 0x2d, 0x9c, 0x08, + 0xd8, 0x79, 0x6b, 0xd7, 0x17, 0x5a, 0x9b, 0x5d, 0x37, 0x4d, 0xce, 0x5e, 0x09, 0x37, 0x7a, 0x68, 0x58, 0x1d, 0x9f, + 0x83, 0x5b, 0xe5, 0xd5, 0xbe, 0x4a, 0xa1, 0x3e, 0x30, 0x27, 0xa5, 0x4d, 0x10, 0x8f, 0x0d, 0x62, 0xd7, 0x6c, 0x8f, + 0x82, 0x96, 0x80, 0x86, 0x8a, 0xf7, 0xef, 0x5e, 0x9e, 0xf2, 0x38, 0x9f, 0x5c, 0xbd, 0x8d, 0xf3, 0x78, 0x5e, 0x78, + 0x2b, 0x85, 0x2e, 0x01, 0x5b, 0xf7, 0x2e, 0xe3, 0x86, 0x98, 0x22, 0x14, 0xb6, 0x86, 0x0b, 0x2b, 0x11, 0x5b, 0x62, + 0x8f, 0x2a, 0xd3, 0xb0, 0xd3, 0xe5, 0x32, 0x4f, 0xf0, 0xd3, 0xc6, 0x59, 0xaf, 0xbd, 0x28, 0xe4, 0xf6, 0xe8, 0x56, + 0xc0, 0x75, 0x13, 0xc6, 0xfb, 0xe7, 0x0c, 0xbb, 0xdf, 0x6f, 0x78, 0xa7, 0x1e, 0xf7, 0x0f, 0x86, 0x27, 0xc2, 0xe3, + 0x5d, 0x50, 0xa0, 0x8d, 0x49, 0xd6, 0x78, 0xeb, 0x95, 0xab, 0x67, 0xa8, 0xd3, 0x25, 0xee, 0xf7, 0xfb, 0x64, 0xd5, + 0x34, 0x6c, 0x09, 0xef, 0x08, 0xc4, 0x49, 0xa8, 0x7b, 0x08, 0x22, 0x48, 0x94, 0x18, 0xd5, 0xec, 0x8d, 0x66, 0x07, + 0xc2, 0x1e, 0xf7, 0x07, 0x94, 0xe3, 0x90, 0x3d, 0xb0, 0xf8, 0xda, 0xee, 0xee, 0x3f, 0x8f, 0xb0, 0xd1, 0x9d, 0x5e, + 0x2c, 0x61, 0x35, 0x24, 0x4e, 0x60, 0x7c, 0xaa, 0xd7, 0xc4, 0xe9, 0x75, 0x13, 0x50, 0xeb, 0x7d, 0xa5, 0xca, 0x5a, + 0xe2, 0x9a, 0x9c, 0x6b, 0x4d, 0xb8, 0x37, 0xcc, 0xbd, 0xb5, 0xba, 0xfe, 0x7b, 0xd8, 0x6b, 0x46, 0x30, 0xb4, 0xca, + 0xd0, 0xea, 0x72, 0xac, 0x6f, 0x1e, 0xaa, 0xc9, 0x38, 0x92, 0xe9, 0x0b, 0xc1, 0x90, 0x0b, 0xf7, 0xd4, 0xa6, 0x9b, + 0xbe, 0x84, 0x9d, 0x56, 0xd5, 0xd9, 0x3b, 0x5c, 0x0f, 0x2f, 0x6b, 0x8c, 0xf0, 0xf7, 0x1a, 0xc3, 0x53, 0xa9, 0x02, + 0x67, 0x79, 0x36, 0xf7, 0x6a, 0x97, 0x4b, 0x2a, 0xf7, 0x98, 0xba, 0xa4, 0xdb, 0xb9, 0x23, 0x12, 0xce, 0xbf, 0xb8, + 0xbf, 0xbd, 0x17, 0x60, 0xd0, 0x13, 0x10, 0x67, 0xc6, 0x1a, 0x09, 0x43, 0xed, 0x05, 0x7c, 0x0a, 0x34, 0xbc, 0x2b, + 0xd4, 0x3d, 0xa4, 0xf9, 0x42, 0xd0, 0x17, 0x10, 0x15, 0xac, 0x2f, 0x21, 0xc4, 0xf4, 0xea, 0x1e, 0x26, 0x7b, 0xad, + 0x5d, 0x84, 0xa8, 0x8f, 0xb8, 0x37, 0xd2, 0xb0, 0xe0, 0x09, 0xf4, 0x61, 0x23, 0x01, 0x53, 0xd4, 0xf5, 0x64, 0x18, + 0xf5, 0xfa, 0xfe, 0x60, 0xff, 0x31, 0x68, 0x3f, 0x51, 0x1f, 0xf4, 0xab, 0x12, 0x4e, 0xd3, 0x53, 0x38, 0xd5, 0x5e, + 0x3b, 0xbe, 0x3e, 0x74, 0xd2, 0xf9, 0x94, 0x51, 0xf7, 0xa5, 0x23, 0x12, 0x9e, 0x82, 0xa8, 0xf8, 0x1d, 0x52, 0x9d, + 0xd2, 0xd7, 0x82, 0x80, 0xa9, 0xd6, 0x1c, 0xdb, 0xe2, 0xfa, 0x1e, 0xf6, 0x9b, 0x44, 0x4c, 0xb3, 0x1b, 0x23, 0x7c, + 0x94, 0x29, 0x0d, 0xcd, 0x4a, 0x2f, 0x54, 0xbc, 0xcf, 0xdb, 0x9c, 0xc3, 0x44, 0xb5, 0xeb, 0xd9, 0xf7, 0x61, 0x05, + 0xd4, 0x2b, 0x50, 0xc1, 0xa2, 0x17, 0xfa, 0xf2, 0xde, 0xfa, 0x9b, 0x56, 0x71, 0x27, 0x64, 0x7c, 0xeb, 0x47, 0x43, + 0xe7, 0x14, 0x40, 0x95, 0xb6, 0x05, 0x36, 0x27, 0x1b, 0xf1, 0x60, 0xa1, 0x0c, 0xe0, 0xea, 0xb4, 0xfa, 0xb1, 0xa4, + 0xfc, 0x6e, 0x75, 0xcf, 0x62, 0x58, 0xaf, 0xf9, 0x46, 0x13, 0x0f, 0x9d, 0xba, 0xb1, 0x6f, 0xb6, 0x1c, 0xda, 0x81, + 0xf0, 0x75, 0x42, 0x3a, 0x9d, 0xba, 0x1f, 0x47, 0xe8, 0x2b, 0xe4, 0x57, 0x1b, 0xc5, 0xca, 0x71, 0xe4, 0xa0, 0x43, + 0xb1, 0xc9, 0xe2, 0x21, 0x8c, 0xe9, 0x2a, 0xae, 0x5d, 0xb1, 0x86, 0x13, 0xd2, 0xd0, 0xcc, 0x8c, 0xe5, 0xa1, 0xd9, + 0xc0, 0x08, 0xf5, 0xac, 0x71, 0x2b, 0x29, 0x5a, 0xda, 0xab, 0x00, 0x58, 0xd6, 0x96, 0xcd, 0x9c, 0x49, 0x7d, 0x44, + 0xc8, 0x44, 0xd6, 0xd4, 0x90, 0x96, 0xaf, 0xd7, 0xb9, 0x1b, 0xc5, 0x67, 0xa0, 0x85, 0x6d, 0x79, 0x22, 0x96, 0x7c, + 0x88, 0x91, 0x5c, 0x39, 0x59, 0xaf, 0x3f, 0x19, 0x13, 0xc6, 0x81, 0x89, 0xbc, 0xfc, 0xa5, 0x0a, 0xb5, 0xfc, 0x55, + 0xa2, 0x73, 0x79, 0x92, 0x89, 0xe0, 0x95, 0xa4, 0x69, 0x52, 0xe0, 0x73, 0x11, 0x3c, 0x93, 0x14, 0xf2, 0xc7, 0x43, + 0xf9, 0x07, 0x7c, 0x3c, 0xce, 0xd2, 0x54, 0xa7, 0x3c, 0x38, 0xc2, 0xc8, 0xde, 0xc9, 0x12, 0xf6, 0xa9, 0xa7, 0x90, + 0xb3, 0xe0, 0x52, 0xd0, 0x8b, 0x65, 0x92, 0xaa, 0xea, 0xb7, 0xca, 0xdd, 0x72, 0x96, 0xe1, 0xc5, 0xe7, 0xa7, 0xb8, + 0x20, 0xce, 0x32, 0x88, 0x00, 0x3c, 0x53, 0xe6, 0x45, 0xd5, 0xc1, 0xa4, 0xfa, 0x11, 0xa4, 0x02, 0x7a, 0x38, 0x7a, + 0xfb, 0xc2, 0x60, 0x2e, 0xf8, 0x5e, 0x82, 0x1b, 0xeb, 0x18, 0x65, 0xc8, 0x0b, 0x03, 0x6d, 0x1e, 0x7c, 0x23, 0xea, + 0xc5, 0xda, 0xf9, 0x19, 0xbc, 0x15, 0x54, 0xaf, 0x6d, 0x7c, 0x85, 0x79, 0x5f, 0x82, 0x77, 0x82, 0x9e, 0xc7, 0x8b, + 0x24, 0x80, 0xfc, 0xcd, 0x47, 0x6f, 0x5f, 0x1c, 0x2b, 0xff, 0xf5, 0x6f, 0xd8, 0xf2, 0xd1, 0xdb, 0x17, 0xaf, 0xb2, + 0xe9, 0x32, 0xe5, 0xc1, 0xef, 0x12, 0x45, 0xee, 0xd1, 0xdb, 0x17, 0x7f, 0x47, 0x5f, 0xbc, 0xc4, 0x2e, 0xbe, 0x01, + 0x85, 0x30, 0x78, 0x26, 0x00, 0x39, 0xea, 0xf9, 0x8d, 0x40, 0xec, 0x38, 0x40, 0x16, 0xc1, 0x77, 0x90, 0x34, 0x17, + 0x98, 0xe3, 0x0f, 0x82, 0xad, 0x76, 0x9a, 0xb9, 0xa5, 0x76, 0x82, 0xba, 0xb1, 0xb1, 0xa4, 0xcf, 0xef, 0xa9, 0x86, + 0x5b, 0x36, 0x75, 0x62, 0x2b, 0x2a, 0xe9, 0x7b, 0xc1, 0x56, 0x2a, 0x9b, 0x61, 0xa4, 0xd2, 0x5b, 0x14, 0xd7, 0x97, + 0x04, 0x42, 0x2f, 0x20, 0x25, 0x6d, 0x10, 0x89, 0xac, 0xa7, 0x1e, 0x23, 0x8a, 0x09, 0x23, 0x22, 0xcc, 0xbd, 0x01, + 0xff, 0x44, 0x25, 0xfd, 0x11, 0x7a, 0x30, 0xe9, 0xb4, 0xc0, 0xa0, 0xb9, 0x13, 0xfc, 0x20, 0x28, 0x3c, 0xc0, 0xdf, + 0xaa, 0xeb, 0xe0, 0xb9, 0x28, 0xeb, 0xfb, 0x8b, 0x1f, 0xed, 0xc9, 0xb5, 0x1f, 0xf1, 0xe8, 0x5a, 0xed, 0xf4, 0xde, + 0x7b, 0x41, 0xe4, 0x88, 0x77, 0xa3, 0x5e, 0xd4, 0x15, 0x63, 0xf6, 0x5e, 0x8c, 0x84, 0xe3, 0xe7, 0xff, 0xb6, 0xa6, + 0x12, 0x86, 0xbc, 0x6b, 0x1d, 0xc9, 0x7b, 0xff, 0x1c, 0xf5, 0xd0, 0x2e, 0xda, 0xdd, 0xdd, 0x23, 0x61, 0x84, 0x49, + 0x73, 0x22, 0x12, 0x44, 0x89, 0xb8, 0xe2, 0x79, 0x22, 0x9d, 0xad, 0xc7, 0xf7, 0x0d, 0xbb, 0xd4, 0xbd, 0x1c, 0x7e, + 0x11, 0x0b, 0xd4, 0x51, 0xb8, 0xb2, 0xf9, 0x24, 0x75, 0xa3, 0xaf, 0x8e, 0xcd, 0xf1, 0x92, 0x2e, 0x8b, 0x7e, 0xb9, + 0x3d, 0x38, 0x6e, 0xf7, 0x7a, 0xad, 0xa8, 0x5b, 0xc5, 0xb9, 0x75, 0xa3, 0x56, 0xaf, 0x77, 0x18, 0x11, 0x13, 0x3f, + 0xe0, 0x57, 0x5b, 0x3c, 0xb8, 0x4a, 0x5c, 0x78, 0xa7, 0xc2, 0x4b, 0x28, 0xe6, 0x7e, 0xd0, 0x66, 0x27, 0x7d, 0xa6, + 0xbf, 0x0b, 0xa9, 0x25, 0x94, 0xe5, 0xc9, 0x9c, 0xe6, 0xef, 0x46, 0x11, 0x9c, 0x53, 0x81, 0x7d, 0x33, 0xca, 0x1d, + 0x3a, 0x01, 0xd4, 0xc3, 0x64, 0xed, 0x04, 0x99, 0xfe, 0xfa, 0x5b, 0xe1, 0xc5, 0xaa, 0x01, 0x62, 0x3e, 0xc7, 0x22, + 0xf5, 0x4c, 0xf0, 0xe8, 0x64, 0xf8, 0x83, 0xd8, 0x9c, 0x8d, 0x09, 0x29, 0x40, 0x86, 0x39, 0xa9, 0xdd, 0x27, 0x10, + 0xa4, 0x51, 0xa5, 0x3c, 0x06, 0xaa, 0xfb, 0xad, 0x12, 0xbf, 0xbf, 0x81, 0x20, 0x01, 0xce, 0xf2, 0x9b, 0x96, 0x18, + 0xbe, 0xcc, 0x97, 0x85, 0xe4, 0x53, 0xb8, 0x71, 0xaf, 0x30, 0x89, 0xf0, 0xb3, 0x34, 0x99, 0xdc, 0x79, 0x91, 0x0e, + 0x15, 0x8d, 0xe8, 0xaa, 0xba, 0x95, 0x1d, 0x22, 0x4e, 0x78, 0x69, 0x78, 0xc7, 0x6f, 0xb8, 0x37, 0x77, 0xb6, 0xb8, + 0xdf, 0xb9, 0x73, 0xfc, 0x9b, 0x93, 0x76, 0x16, 0x3a, 0xa6, 0xbf, 0x85, 0xbf, 0xb9, 0x17, 0xbc, 0x83, 0x4f, 0xa6, + 0xfa, 0xf4, 0x27, 0x27, 0xfe, 0xe0, 0x23, 0xd3, 0x2a, 0xea, 0x33, 0x02, 0x49, 0x03, 0xaa, 0x1d, 0x00, 0xa2, 0x11, + 0xdc, 0x78, 0x4c, 0xed, 0xf3, 0x83, 0x96, 0x26, 0xa3, 0x21, 0x4a, 0x7c, 0x85, 0x52, 0x78, 0xdf, 0x65, 0x7a, 0xef, + 0x5f, 0xab, 0x91, 0xeb, 0x9b, 0x40, 0xef, 0x52, 0x3c, 0xdd, 0x2c, 0x9d, 0x9b, 0x79, 0xbf, 0xc3, 0x79, 0x57, 0x14, + 0x85, 0x49, 0xe0, 0xdd, 0xab, 0xb1, 0xab, 0x81, 0xfc, 0xc3, 0xc5, 0xc1, 0x47, 0xb5, 0x19, 0x2b, 0x55, 0xf4, 0x55, + 0x6f, 0xa0, 0xcf, 0xe8, 0x47, 0x5f, 0x66, 0xef, 0x21, 0xb5, 0xdd, 0x71, 0x5c, 0x70, 0xe7, 0x7a, 0x18, 0xd0, 0x86, + 0x4f, 0xdf, 0x1e, 0xbd, 0x06, 0x01, 0x88, 0xcf, 0x3f, 0x7c, 0x1b, 0xb9, 0xc1, 0x62, 0x3f, 0xd7, 0xd4, 0x29, 0xa5, + 0xb8, 0x63, 0x10, 0x1d, 0xdc, 0xa5, 0xe8, 0x2b, 0x7d, 0x3b, 0x29, 0x30, 0xb9, 0x17, 0x9c, 0x8a, 0xbe, 0xc5, 0x74, + 0xff, 0x64, 0x98, 0x6f, 0x4b, 0x1a, 0x81, 0xa6, 0xaa, 0x0a, 0xd5, 0x5b, 0xf3, 0x4a, 0x6c, 0xfd, 0xd0, 0x2c, 0x1d, + 0x73, 0x6f, 0x00, 0x9f, 0xbe, 0x82, 0x1c, 0xec, 0x99, 0xd9, 0x75, 0xc4, 0xae, 0x23, 0x27, 0x63, 0x3f, 0x09, 0xb8, + 0xc4, 0xa3, 0x1e, 0xd1, 0x97, 0xb1, 0xef, 0xcd, 0x2a, 0x43, 0x53, 0xb0, 0x28, 0xd1, 0xe8, 0xaf, 0xfc, 0x2f, 0xa4, + 0x54, 0x3e, 0x5b, 0x44, 0xf6, 0xb0, 0x08, 0x33, 0x83, 0x34, 0x8b, 0x9d, 0x4e, 0xa7, 0x70, 0xca, 0xec, 0xfb, 0xb0, + 0xa8, 0x2b, 0x7d, 0x5a, 0x19, 0xa4, 0x59, 0x3d, 0x61, 0x87, 0xd1, 0x11, 0x21, 0xdc, 0x57, 0x9b, 0x1f, 0x94, 0x3e, + 0x98, 0xd1, 0x02, 0xca, 0x5c, 0x15, 0x31, 0x73, 0x90, 0xff, 0x77, 0xcb, 0xa0, 0x6c, 0xc8, 0xbb, 0x1a, 0x3e, 0xc4, + 0x28, 0xeb, 0x9c, 0x83, 0x6a, 0x4f, 0x19, 0x70, 0x9a, 0xc6, 0x85, 0x54, 0x37, 0x00, 0x05, 0x42, 0x9d, 0xaa, 0xd7, + 0x95, 0x43, 0x01, 0xe6, 0x6d, 0xfb, 0xd6, 0x3d, 0x16, 0xb8, 0x0b, 0x1b, 0x0a, 0xb3, 0x34, 0x31, 0xeb, 0xa7, 0xd9, + 0x48, 0x52, 0x81, 0x3a, 0x83, 0x34, 0x2b, 0xbb, 0x7e, 0x87, 0x0b, 0x15, 0xa6, 0x1c, 0x68, 0x59, 0x97, 0xea, 0x65, + 0x5c, 0x45, 0x4d, 0xb4, 0x25, 0x38, 0x03, 0xdd, 0x38, 0x85, 0x5c, 0xdd, 0x54, 0xa2, 0xb7, 0xa8, 0xe6, 0xd8, 0x47, + 0xcb, 0x5c, 0x40, 0x3c, 0x42, 0x50, 0x22, 0x1a, 0xcd, 0xb3, 0x29, 0x64, 0x24, 0x51, 0x43, 0x8c, 0x68, 0x24, 0x32, + 0x93, 0x90, 0x2d, 0xa2, 0xc6, 0xe0, 0x66, 0x6d, 0x6d, 0x55, 0x06, 0x13, 0xcc, 0x5a, 0x02, 0x4e, 0xa5, 0x7a, 0xa6, + 0x3c, 0xb1, 0x3a, 0x2f, 0xae, 0xe2, 0x69, 0x76, 0x03, 0xf7, 0x4d, 0x0c, 0xcf, 0x13, 0x7d, 0x3f, 0x4d, 0x01, 0xd7, + 0xaf, 0x0c, 0x86, 0xe7, 0x78, 0x91, 0xc6, 0xf0, 0x7c, 0x72, 0xc5, 0x27, 0x1f, 0x30, 0x5e, 0x45, 0x15, 0xdb, 0x4c, + 0x6f, 0xf8, 0xab, 0x4a, 0x67, 0x07, 0x61, 0x15, 0xe7, 0xd7, 0x49, 0x91, 0xa8, 0xcb, 0x33, 0x86, 0xdb, 0x2e, 0x7b, + 0xaa, 0x65, 0xc8, 0x73, 0x3a, 0x57, 0x05, 0xb1, 0x94, 0xf1, 0xe4, 0xea, 0x14, 0x4b, 0xbd, 0x15, 0x8c, 0x35, 0x88, + 0xb2, 0x05, 0x17, 0x51, 0x69, 0x13, 0x88, 0xd5, 0x36, 0x21, 0x06, 0x0f, 0x64, 0xa8, 0x37, 0x37, 0x3a, 0x49, 0x1d, + 0x02, 0xce, 0xfe, 0x2e, 0x3c, 0xed, 0x4f, 0x8d, 0xa2, 0xb2, 0x7a, 0xf9, 0x1b, 0x8c, 0xe4, 0x18, 0xc6, 0xe4, 0x6d, + 0xbf, 0x30, 0x49, 0x55, 0x73, 0x46, 0xd9, 0x37, 0x59, 0xe5, 0xe2, 0x5c, 0xda, 0x44, 0x7d, 0x1f, 0x49, 0xa2, 0xe7, + 0x22, 0xc9, 0x7c, 0x9e, 0x2d, 0x9c, 0xaf, 0x9d, 0xf4, 0x5e, 0x1a, 0x85, 0x53, 0x3b, 0x30, 0x27, 0xd5, 0x57, 0x62, + 0xe3, 0xdb, 0x4b, 0xcb, 0x20, 0xf4, 0x0d, 0x3f, 0xb6, 0x4f, 0x6e, 0x1d, 0xb7, 0xd6, 0xc0, 0xa0, 0xf0, 0x62, 0xb7, + 0xfb, 0xf7, 0x63, 0xce, 0x26, 0x66, 0x53, 0x93, 0x8d, 0x91, 0xc3, 0xbe, 0x7a, 0x89, 0x8e, 0x10, 0xf5, 0xc8, 0x38, + 0xfd, 0x5d, 0x67, 0xca, 0x73, 0x26, 0x0d, 0xee, 0x95, 0x76, 0x8d, 0x0c, 0x0e, 0x31, 0x06, 0x5b, 0xba, 0x74, 0x5e, + 0xeb, 0x7b, 0x6d, 0x1b, 0x18, 0x0d, 0xb6, 0xe0, 0xa9, 0xc1, 0xad, 0xb6, 0x4c, 0x21, 0xde, 0xb1, 0x01, 0xcb, 0xa3, + 0x9e, 0x7a, 0xae, 0xce, 0x67, 0xd4, 0x0a, 0xc6, 0x10, 0x00, 0x60, 0xfd, 0x75, 0xa3, 0xc7, 0x4a, 0x05, 0xad, 0x69, + 0x8c, 0xd7, 0xc2, 0x19, 0xea, 0xa7, 0xc0, 0x5b, 0x90, 0x72, 0x59, 0x77, 0x56, 0x5d, 0x9e, 0xc7, 0xdd, 0xdd, 0x88, + 0xc7, 0x19, 0x36, 0xa0, 0xb6, 0x48, 0xc9, 0xec, 0xae, 0xba, 0x8c, 0xb7, 0xd8, 0x84, 0x08, 0x0c, 0x08, 0x08, 0x3e, + 0x62, 0xb9, 0x71, 0x49, 0xc8, 0xf6, 0x09, 0x53, 0x10, 0xa8, 0xfa, 0x10, 0xaf, 0x18, 0x6e, 0x6b, 0xdb, 0xb0, 0x07, + 0x99, 0x2f, 0x79, 0xa4, 0xf1, 0xda, 0xbc, 0x8b, 0xb2, 0x6a, 0xd1, 0xa1, 0xc1, 0xfc, 0x41, 0x18, 0xaa, 0xf9, 0x43, + 0x28, 0xec, 0x37, 0xf7, 0xc1, 0xe1, 0xf0, 0xa6, 0x07, 0x21, 0x71, 0xda, 0xcd, 0x39, 0x12, 0xc5, 0x91, 0x80, 0x4c, + 0xb6, 0x49, 0x73, 0x52, 0x35, 0x95, 0xaa, 0x13, 0x21, 0x9a, 0x8b, 0xd7, 0xee, 0x63, 0x73, 0xf9, 0x59, 0xad, 0x16, + 0xc8, 0x45, 0xbc, 0x90, 0xe9, 0xfa, 0x52, 0xcd, 0xb6, 0x44, 0xce, 0x8f, 0xa2, 0x05, 0x6f, 0x2b, 0x53, 0x7b, 0x03, + 0xb0, 0xf4, 0x78, 0x95, 0x69, 0x4b, 0xcf, 0xfe, 0xcf, 0x10, 0xf5, 0xc5, 0x35, 0xa9, 0x29, 0x5b, 0xd6, 0x56, 0xb8, + 0x1c, 0x63, 0xbd, 0x96, 0x30, 0x91, 0x79, 0xc2, 0xa8, 0x07, 0xa3, 0x22, 0x58, 0x67, 0x8d, 0x89, 0xc2, 0x8f, 0x74, + 0xa0, 0x47, 0x54, 0xd6, 0x68, 0xdb, 0xf0, 0x92, 0x8a, 0x01, 0xdb, 0x6b, 0x86, 0x6b, 0x4c, 0x79, 0x33, 0xca, 0xd0, + 0xa9, 0xe4, 0x61, 0x5c, 0x9a, 0x79, 0x46, 0x13, 0xe6, 0x46, 0x13, 0x46, 0x14, 0x6d, 0x69, 0x7b, 0x30, 0xdc, 0x18, + 0xa7, 0xe1, 0x19, 0xf7, 0x2d, 0x31, 0xa9, 0x82, 0xf1, 0x61, 0xb4, 0xc8, 0x7f, 0xcd, 0x38, 0xa0, 0x44, 0xf3, 0xae, + 0xea, 0xa0, 0x13, 0xca, 0xc3, 0x0a, 0x63, 0x70, 0xb4, 0x4d, 0x65, 0x8e, 0x54, 0x82, 0x64, 0xcb, 0xf5, 0x9c, 0xf5, + 0x6e, 0x51, 0x22, 0xc2, 0xd5, 0x60, 0x70, 0x15, 0x06, 0xde, 0x3f, 0xe4, 0x29, 0xb5, 0x15, 0x66, 0x1c, 0xce, 0x50, + 0xad, 0xd7, 0x90, 0x52, 0xab, 0xa9, 0x91, 0xc1, 0x56, 0xbd, 0xfd, 0x8f, 0x4d, 0x9e, 0x06, 0xc6, 0x0c, 0x55, 0xa6, + 0x20, 0x7a, 0x81, 0x6b, 0x1d, 0x07, 0x43, 0x73, 0xb8, 0x7a, 0xaa, 0x36, 0x8a, 0x4a, 0x95, 0x16, 0xea, 0xfc, 0x7c, + 0x3d, 0x86, 0xab, 0x4e, 0xb2, 0xb9, 0x33, 0xc8, 0x7b, 0xf1, 0x87, 0x69, 0xe4, 0x6a, 0xe1, 0x9b, 0xf5, 0x98, 0x20, + 0xa9, 0x62, 0x85, 0x44, 0x39, 0x4c, 0x90, 0x94, 0xf4, 0x25, 0x9d, 0x97, 0x19, 0x5a, 0x0a, 0x9e, 0xc5, 0x32, 0x86, + 0xcc, 0x6f, 0x2a, 0xc5, 0x03, 0x4b, 0x4a, 0xb8, 0xf0, 0xec, 0x9e, 0x6a, 0xd2, 0xdc, 0xd6, 0x69, 0xa5, 0xa5, 0x74, + 0xc5, 0xa7, 0xe6, 0xfc, 0x6e, 0x11, 0x29, 0xcf, 0x67, 0x59, 0x3e, 0xd1, 0xd7, 0x29, 0xd6, 0x68, 0xc9, 0xcc, 0x96, + 0x5e, 0x14, 0xdb, 0x10, 0x0b, 0x29, 0x70, 0x9b, 0x85, 0x9a, 0x15, 0x28, 0x05, 0xaf, 0x0a, 0x66, 0xdb, 0xc2, 0xe5, + 0x6b, 0xa0, 0xf3, 0x2d, 0x2b, 0xc3, 0xca, 0xd9, 0xda, 0xc4, 0x51, 0x43, 0x15, 0xf4, 0x5e, 0xd2, 0x21, 0x65, 0xfd, + 0x0b, 0x67, 0xdf, 0x0b, 0x61, 0x51, 0x88, 0x3e, 0xb3, 0x19, 0xa1, 0x09, 0xdb, 0x44, 0xd1, 0xf0, 0xe7, 0x2d, 0xa2, + 0xd1, 0x45, 0xad, 0xa3, 0x9d, 0xf6, 0x8d, 0x52, 0xaa, 0x95, 0xd4, 0x84, 0xd6, 0xe9, 0x32, 0x90, 0xd4, 0xd0, 0x6e, + 0x20, 0xa8, 0xcb, 0xbc, 0x82, 0xbc, 0x44, 0xa5, 0xc1, 0x15, 0x98, 0xce, 0x04, 0x18, 0x16, 0x0a, 0xd9, 0x1f, 0x1e, + 0x16, 0xbd, 0x8a, 0xfb, 0x6d, 0xa6, 0x22, 0x7e, 0x01, 0xb9, 0x35, 0x0b, 0x65, 0x54, 0xb2, 0x5d, 0xd4, 0x8c, 0xf8, + 0xd9, 0x9c, 0xeb, 0x24, 0x09, 0x45, 0x55, 0x59, 0x5c, 0x92, 0xa1, 0xb4, 0x97, 0x2a, 0x6b, 0x3a, 0xb0, 0xc9, 0x8e, + 0x8d, 0x3a, 0x68, 0x10, 0x52, 0xa3, 0x1f, 0x8c, 0x8b, 0xdc, 0x9e, 0xce, 0x58, 0xdd, 0xea, 0xa5, 0xd8, 0xaf, 0xbd, + 0x31, 0xde, 0xd4, 0x52, 0x7b, 0xeb, 0xc6, 0x97, 0x6e, 0xae, 0x62, 0xc3, 0xb7, 0x9b, 0xa3, 0xc4, 0x5d, 0x74, 0x59, + 0x57, 0x30, 0x56, 0x4d, 0xfc, 0x79, 0x0f, 0x34, 0xdc, 0x4c, 0x82, 0x8c, 0x87, 0xf2, 0xea, 0x23, 0x35, 0xda, 0x62, + 0xa5, 0x01, 0x1a, 0xb2, 0x6f, 0x8c, 0x1d, 0x56, 0x70, 0xed, 0x34, 0x12, 0x58, 0x1a, 0xe2, 0x2a, 0x2d, 0xa8, 0x4d, + 0x34, 0xd4, 0x48, 0x81, 0xed, 0x54, 0xa1, 0x1c, 0xaf, 0x43, 0x0b, 0xec, 0x3d, 0x82, 0x75, 0xe1, 0x5d, 0xa3, 0x76, + 0x4e, 0xf0, 0x62, 0xb7, 0xaa, 0x2e, 0x9c, 0xbe, 0x33, 0x82, 0x68, 0xab, 0x58, 0x36, 0xd7, 0xf9, 0xd6, 0x64, 0xba, + 0x3a, 0x52, 0x54, 0x05, 0x2c, 0x80, 0xcd, 0xbc, 0x6e, 0x2c, 0xc9, 0x48, 0x0c, 0xf1, 0x00, 0x0e, 0x98, 0xf0, 0x33, + 0x03, 0x2b, 0x96, 0x75, 0xbc, 0xd9, 0x9b, 0x2e, 0x4d, 0x2e, 0x6f, 0xd7, 0x08, 0xca, 0x73, 0x6b, 0x04, 0x95, 0xb9, + 0x63, 0x04, 0x15, 0xb9, 0x35, 0x82, 0xe6, 0x79, 0xc3, 0x08, 0x9a, 0xe4, 0x0d, 0x23, 0x68, 0x9c, 0x3b, 0x46, 0xd0, + 0x2c, 0x77, 0x8d, 0xa0, 0x45, 0x5e, 0x19, 0x41, 0x27, 0xb9, 0x63, 0x04, 0x4d, 0xab, 0x1f, 0xc1, 0x32, 0xdf, 0x6a, + 0xf2, 0x9c, 0xe6, 0xdb, 0x4d, 0x9e, 0xb3, 0xbc, 0x69, 0x33, 0x5d, 0xe4, 0xca, 0xde, 0x39, 0xcf, 0x4b, 0xb6, 0x2b, + 0x3c, 0xb2, 0x5e, 0x03, 0xaa, 0xe8, 0x77, 0x4e, 0xd6, 0xbd, 0x2a, 0x59, 0xb2, 0xde, 0x33, 0x9a, 0x3b, 0x1a, 0xd1, + 0x31, 0x59, 0x4f, 0x6d, 0x03, 0xfb, 0xb5, 0x1f, 0x13, 0x79, 0xe5, 0x45, 0x7b, 0x11, 0x09, 0x2b, 0x0d, 0x16, 0x72, + 0x45, 0x3b, 0xe6, 0x9d, 0xcb, 0xbc, 0x16, 0x34, 0x50, 0x45, 0xbb, 0xee, 0xb9, 0xce, 0xfc, 0x73, 0xb7, 0x16, 0x7e, + 0x12, 0xda, 0x24, 0x90, 0x7b, 0x11, 0x81, 0xf3, 0x36, 0xdc, 0xc9, 0x8a, 0x38, 0xea, 0xbb, 0xa7, 0x11, 0x73, 0x27, + 0x8c, 0xf2, 0x32, 0xf7, 0x20, 0x4e, 0x27, 0xf9, 0x6d, 0xc9, 0xcf, 0x93, 0x29, 0xb1, 0xc9, 0xe0, 0xc4, 0x24, 0x9b, + 0xf2, 0xf7, 0xef, 0x5e, 0x40, 0x3a, 0x85, 0x4c, 0x80, 0x51, 0x49, 0xa7, 0x64, 0xc0, 0x6c, 0x58, 0x53, 0x7e, 0x9d, + 0x4c, 0x78, 0x18, 0xed, 0xae, 0xb6, 0x56, 0x54, 0xaf, 0x49, 0xb9, 0x07, 0xf6, 0xc9, 0x2a, 0x85, 0x35, 0x2f, 0xf7, + 0x76, 0x57, 0xd2, 0x9f, 0x66, 0xf3, 0x38, 0x11, 0xf0, 0x9c, 0x94, 0xbb, 0xab, 0x1c, 0x1e, 0x44, 0x19, 0xd9, 0x2c, + 0x5d, 0x16, 0x18, 0x07, 0x7e, 0xeb, 0xd0, 0xac, 0xb2, 0x34, 0x3e, 0xd0, 0xac, 0x6d, 0xb2, 0x0a, 0xd3, 0xcb, 0x1d, + 0x53, 0xcf, 0x50, 0x0f, 0x9b, 0x10, 0xb0, 0xfa, 0x54, 0x48, 0xc3, 0x6c, 0x4a, 0xc0, 0x1d, 0x37, 0x87, 0x04, 0xd7, + 0x9a, 0xaa, 0x9e, 0xf7, 0x22, 0xe2, 0x86, 0x0f, 0x48, 0x07, 0x48, 0x88, 0x85, 0x83, 0x84, 0x94, 0x09, 0xe3, 0xdb, + 0xe0, 0x15, 0x2c, 0xd2, 0xa0, 0x6d, 0xe9, 0x20, 0x81, 0x1c, 0xde, 0xf5, 0x11, 0x89, 0x32, 0x9c, 0x72, 0x19, 0x27, + 0x29, 0x8b, 0xd3, 0x54, 0xb9, 0xb6, 0x2f, 0x72, 0xf6, 0xb8, 0x4f, 0x6f, 0x73, 0x76, 0x40, 0x4f, 0xe1, 0x9f, 0x9f, + 0x36, 0xf2, 0xe6, 0xab, 0x3d, 0xe9, 0xea, 0x3b, 0x64, 0xe6, 0xe5, 0x27, 0x64, 0xd1, 0xc7, 0xc4, 0xc4, 0x09, 0x2f, + 0x20, 0xb8, 0xc0, 0x88, 0x1d, 0x60, 0x7c, 0x32, 0xcf, 0xd2, 0xa2, 0xda, 0xf9, 0x5e, 0x65, 0x37, 0xe7, 0x71, 0x9a, + 0x56, 0x22, 0x3a, 0x46, 0xc4, 0x2a, 0x5e, 0xa8, 0xc5, 0xcf, 0x71, 0xae, 0xdf, 0x5d, 0xc4, 0x05, 0x7f, 0x1b, 0xcb, + 0x2b, 0x06, 0xeb, 0x43, 0x8b, 0xed, 0x3c, 0x5b, 0x2e, 0x0a, 0xf6, 0x9d, 0x7f, 0xae, 0xf7, 0x81, 0xdf, 0x62, 0x81, + 0xe5, 0xc7, 0x4b, 0xf1, 0x41, 0x64, 0x37, 0xe2, 0xdc, 0x82, 0xb3, 0x32, 0x37, 0x45, 0xeb, 0xa0, 0xff, 0x73, 0x85, + 0x8b, 0x73, 0x8c, 0x2c, 0xe1, 0x85, 0x09, 0xfe, 0xd7, 0x95, 0xd4, 0x55, 0xe5, 0x78, 0x6f, 0x10, 0xab, 0x04, 0x9e, + 0xbb, 0x0f, 0x44, 0x25, 0xa0, 0xca, 0x38, 0x75, 0x9e, 0x80, 0x0a, 0xe7, 0x27, 0xd3, 0x5a, 0xc4, 0xc8, 0xd0, 0xd1, + 0xfa, 0x0c, 0x24, 0x68, 0x80, 0xc4, 0xc3, 0x82, 0x4a, 0x72, 0x5a, 0xf2, 0x04, 0xce, 0xab, 0x6c, 0x3d, 0x68, 0x25, + 0x77, 0x83, 0x17, 0xa4, 0xd2, 0x9a, 0x9d, 0x00, 0x64, 0x77, 0xab, 0x61, 0x5a, 0x1e, 0xe5, 0x63, 0x55, 0xef, 0x1c, + 0x6f, 0x2c, 0x4d, 0x26, 0xe7, 0x57, 0x49, 0x21, 0xb3, 0xfc, 0x6e, 0xc8, 0xf5, 0x41, 0x76, 0xad, 0x7c, 0xdb, 0xf4, + 0xc1, 0x87, 0x17, 0x39, 0xee, 0x7d, 0x75, 0x68, 0xef, 0xa7, 0xb5, 0x66, 0xa9, 0x91, 0x94, 0xfa, 0xdc, 0x11, 0x8c, + 0x9b, 0xda, 0x67, 0x8d, 0x8e, 0xaa, 0x40, 0x2d, 0xa4, 0xea, 0xb7, 0x1d, 0x31, 0xd5, 0xe2, 0x2c, 0x2e, 0x20, 0x25, + 0x82, 0xd7, 0xec, 0xde, 0x1a, 0x68, 0xea, 0xd7, 0xdc, 0xba, 0xdb, 0x04, 0xa9, 0x13, 0xa8, 0x98, 0x4e, 0xb4, 0xec, + 0x8e, 0xa7, 0xd3, 0x13, 0x4c, 0x90, 0xed, 0x6c, 0x2a, 0x52, 0x7b, 0x9b, 0xee, 0x26, 0x75, 0x8c, 0xc4, 0x78, 0x98, + 0xac, 0xd7, 0xf7, 0xbf, 0x65, 0x2b, 0x9d, 0x61, 0x1c, 0x6f, 0x51, 0xe0, 0xf3, 0x05, 0x3c, 0x96, 0x34, 0xf1, 0x55, + 0x71, 0xb7, 0x4b, 0xdb, 0x9e, 0xf9, 0xf1, 0xe4, 0x36, 0x27, 0xc6, 0x7c, 0x8b, 0x35, 0x0f, 0xd9, 0x69, 0xae, 0xf5, + 0xfb, 0x7b, 0xa8, 0x4f, 0x67, 0x24, 0x5b, 0xaf, 0x9d, 0xaf, 0xba, 0xdd, 0x07, 0x09, 0x56, 0xe5, 0x0f, 0x23, 0x14, + 0x7f, 0x7a, 0x77, 0xb9, 0x57, 0x5f, 0x2a, 0xa0, 0x99, 0xae, 0xe6, 0x5c, 0x5e, 0x65, 0xd3, 0x20, 0xfa, 0xf6, 0xe4, + 0x2c, 0x6a, 0x04, 0x45, 0xb4, 0xb9, 0x9f, 0x7d, 0xa8, 0x5f, 0xa9, 0xf8, 0xfc, 0xec, 0xec, 0x6d, 0x0b, 0x9d, 0x91, + 0xed, 0xd6, 0xa9, 0x3a, 0x57, 0xdc, 0xda, 0xb5, 0xa7, 0xd4, 0x4b, 0xcb, 0x21, 0x5b, 0xdb, 0xe2, 0x2c, 0xcc, 0xe4, + 0xde, 0x87, 0x40, 0xda, 0x98, 0x17, 0xe7, 0x5c, 0x1e, 0x7c, 0x5e, 0xf7, 0x85, 0x46, 0xe8, 0xd1, 0x53, 0xb0, 0x04, + 0x2a, 0xa4, 0x42, 0x5d, 0x02, 0x9e, 0xde, 0xb9, 0x7b, 0xd9, 0x7b, 0x10, 0xa3, 0xcf, 0x2b, 0x42, 0x6c, 0x10, 0x1c, + 0xa3, 0xae, 0x2d, 0xe8, 0x2c, 0x07, 0xf5, 0x14, 0x79, 0xc5, 0x83, 0xeb, 0x7a, 0xe8, 0x30, 0x19, 0x47, 0xcb, 0xd5, + 0x69, 0x7b, 0xb4, 0xe4, 0x32, 0x3b, 0x6f, 0x5d, 0x4d, 0x25, 0x9d, 0xc2, 0x58, 0xe9, 0x1a, 0x93, 0x6a, 0x24, 0x32, + 0x2a, 0x14, 0x0c, 0xe7, 0xea, 0x62, 0x99, 0x9e, 0x6c, 0x14, 0x6c, 0x27, 0x79, 0x52, 0x6a, 0xeb, 0xa0, 0x1a, 0xfa, + 0xc9, 0xeb, 0xb3, 0x17, 0x67, 0x3f, 0x9d, 0xbf, 0x7f, 0xfd, 0xec, 0xe4, 0x9b, 0x17, 0xaf, 0x4f, 0x9e, 0xb1, 0x08, + 0x59, 0x55, 0x11, 0x6d, 0xab, 0x75, 0x7c, 0x74, 0x76, 0xf2, 0xed, 0x9b, 0x77, 0x2f, 0x4e, 0x4e, 0xd9, 0x28, 0x3a, + 0xc5, 0xdb, 0x8e, 0x5a, 0xb1, 0x98, 0xb6, 0x8e, 0x15, 0x53, 0x8e, 0x68, 0x74, 0x6c, 0xee, 0x3c, 0xc6, 0x88, 0x3a, + 0x1a, 0x3d, 0x4b, 0xe2, 0x4b, 0x91, 0x15, 0x32, 0x99, 0x44, 0x63, 0x63, 0x95, 0x6c, 0xf2, 0x59, 0xcd, 0x80, 0xbe, + 0xdb, 0xec, 0x45, 0xdd, 0x4e, 0xa1, 0x86, 0xeb, 0xa9, 0x1b, 0xae, 0x39, 0xad, 0x0f, 0x12, 0x6e, 0xc8, 0x75, 0xc8, + 0x49, 0x61, 0x0e, 0x6b, 0x7e, 0xb7, 0x31, 0xb6, 0xe6, 0xa7, 0x3d, 0x48, 0xcf, 0xd5, 0xcc, 0x0e, 0xf5, 0x51, 0xa4, + 0xf2, 0x3f, 0x78, 0xa3, 0x8b, 0x56, 0xbf, 0x94, 0x77, 0x3f, 0x44, 0xc2, 0x85, 0xc5, 0x0d, 0x17, 0x91, 0x70, 0xc1, + 0x73, 0x70, 0x53, 0xa0, 0x1d, 0x7d, 0x43, 0x5c, 0x7c, 0xca, 0xa7, 0x1a, 0x36, 0x24, 0x8f, 0xe8, 0x5e, 0x02, 0xbd, + 0xd7, 0x9c, 0xdc, 0xe8, 0x40, 0x29, 0xe9, 0x7f, 0x16, 0xbc, 0xed, 0x5f, 0x7f, 0x22, 0x84, 0x0f, 0xdf, 0xf5, 0xe2, + 0xae, 0x76, 0xbb, 0x65, 0xb4, 0xc2, 0x92, 0x6b, 0x61, 0xf9, 0xc9, 0xc2, 0x51, 0xaa, 0x30, 0x5d, 0x08, 0xef, 0xb0, + 0x91, 0xbc, 0x8a, 0xeb, 0xaf, 0xd7, 0xe7, 0xa0, 0x7e, 0xe9, 0x03, 0x0b, 0x9c, 0xaa, 0xd2, 0x40, 0x50, 0xfb, 0x39, + 0xa4, 0x00, 0x71, 0xc7, 0x14, 0x54, 0x24, 0x83, 0xbf, 0xc3, 0xd0, 0xdb, 0x42, 0xc9, 0x23, 0x7b, 0xb3, 0x89, 0xba, + 0x6e, 0xe1, 0x7c, 0x12, 0x4b, 0x7e, 0x99, 0xe5, 0x77, 0x64, 0xbc, 0x5e, 0x6f, 0x52, 0xaa, 0x3e, 0x7e, 0xd6, 0x94, + 0x97, 0x81, 0x8d, 0x96, 0x69, 0x08, 0xf1, 0x70, 0xa4, 0x8b, 0xc6, 0x10, 0xe5, 0x38, 0xcc, 0x51, 0x55, 0x52, 0x7a, + 0x50, 0x65, 0x9f, 0x57, 0x3b, 0xb3, 0x1c, 0xc2, 0x1c, 0xab, 0xd7, 0x66, 0x4b, 0x5a, 0xd7, 0xad, 0xfa, 0x0d, 0x09, + 0x6e, 0x32, 0xbf, 0x34, 0x4a, 0xdd, 0x95, 0x63, 0x11, 0x59, 0x5f, 0x2f, 0x61, 0xb8, 0xff, 0xf9, 0xe7, 0x8f, 0x0f, + 0x7a, 0x03, 0xf4, 0x5c, 0xde, 0xf3, 0x6e, 0xa8, 0xef, 0x38, 0xb0, 0xae, 0x29, 0xd1, 0xcb, 0xed, 0xf9, 0x62, 0xa1, + 0xdc, 0xa8, 0x2f, 0xb3, 0x1b, 0xe3, 0x46, 0xa5, 0xb1, 0xe6, 0x9b, 0xf5, 0x62, 0x7b, 0x6d, 0xc1, 0x93, 0x38, 0xec, + 0x0d, 0x82, 0xae, 0x97, 0x1c, 0xc6, 0xd6, 0x0a, 0xd0, 0xe0, 0x82, 0x65, 0x59, 0x61, 0xa4, 0x8a, 0x24, 0x56, 0x26, + 0x91, 0x73, 0x10, 0x55, 0x5a, 0x65, 0x8f, 0x12, 0x73, 0xa9, 0x76, 0x5d, 0xab, 0x2c, 0x35, 0xae, 0xdc, 0x24, 0xa5, + 0x5b, 0xaa, 0xe9, 0xd9, 0xb6, 0x57, 0x6e, 0x37, 0xde, 0xaa, 0x9f, 0x5c, 0xa9, 0x75, 0xdb, 0xab, 0x58, 0x85, 0xb5, + 0x21, 0x94, 0xb7, 0xf7, 0x76, 0xcb, 0x27, 0xde, 0xb6, 0x51, 0x28, 0xd3, 0xb7, 0x19, 0x2f, 0x66, 0x6c, 0x46, 0x61, + 0x7f, 0xbd, 0x21, 0xec, 0xd1, 0xd1, 0x65, 0xc5, 0xfd, 0xdb, 0x37, 0xa7, 0x67, 0x10, 0x0d, 0x11, 0x63, 0x0c, 0xcc, + 0x6a, 0x47, 0xc7, 0xcf, 0xf5, 0x20, 0xd4, 0x60, 0x27, 0x88, 0xe0, 0x06, 0xa6, 0x44, 0xed, 0x2a, 0xf7, 0x6e, 0x7b, + 0x37, 0x37, 0x37, 0x3d, 0x38, 0x8c, 0xd0, 0x5b, 0xe6, 0xa9, 0xda, 0x47, 0x4c, 0xa3, 0xf2, 0x21, 0xd9, 0x7c, 0xa4, + 0xd3, 0x53, 0x38, 0xc2, 0x59, 0x5f, 0xf4, 0x73, 0x7a, 0x95, 0xdd, 0x1c, 0xa5, 0xa9, 0x35, 0x39, 0xb4, 0x6b, 0xaa, + 0xbe, 0xb6, 0x79, 0xd4, 0x56, 0xba, 0xb1, 0x1d, 0x9d, 0x4f, 0x93, 0x22, 0xbe, 0x48, 0xf9, 0xf4, 0xfc, 0xe2, 0xce, + 0x08, 0x1a, 0x12, 0x3e, 0x8b, 0xdc, 0xdb, 0x72, 0x9a, 0x77, 0xf1, 0xed, 0x1c, 0x3e, 0x51, 0x3f, 0xec, 0x75, 0x3a, + 0xea, 0xe7, 0x4e, 0xeb, 0x6f, 0x93, 0x34, 0x99, 0x7c, 0x80, 0x3b, 0x7b, 0xb8, 0xbe, 0x39, 0xab, 0xda, 0x6e, 0xf4, + 0xcb, 0x9d, 0x43, 0x80, 0xb3, 0x75, 0x94, 0xa6, 0x4f, 0xf6, 0xd4, 0x17, 0xe6, 0x7e, 0x9d, 0xe0, 0x43, 0xa9, 0xb8, + 0xc1, 0x89, 0x86, 0xb1, 0xe2, 0x5b, 0xcd, 0x4b, 0xaf, 0x85, 0xba, 0x03, 0xda, 0x5e, 0xf0, 0x5d, 0x63, 0x26, 0xdb, + 0x78, 0x03, 0x75, 0xdc, 0xb9, 0x79, 0x98, 0x9b, 0xf0, 0xe5, 0x40, 0xaa, 0x0b, 0xb3, 0x29, 0x24, 0xd7, 0xd6, 0x47, + 0x4a, 0x9b, 0x7d, 0x71, 0xe8, 0xcb, 0xd1, 0x27, 0xcc, 0x96, 0x5a, 0xb7, 0xa7, 0x74, 0x91, 0xa1, 0x0e, 0x9f, 0xb0, + 0x25, 0x14, 0x63, 0x28, 0xb4, 0x2e, 0xa4, 0x2b, 0x91, 0x52, 0xb7, 0x39, 0xe2, 0x34, 0x1f, 0x43, 0xab, 0x44, 0x7f, + 0x82, 0x71, 0x08, 0x7a, 0x15, 0x6f, 0xbd, 0xb6, 0xc9, 0x60, 0x30, 0xac, 0x4d, 0x62, 0xd0, 0x9c, 0x52, 0x93, 0xcc, + 0xa5, 0x7d, 0xef, 0xac, 0x3a, 0x57, 0x33, 0x01, 0xd2, 0x77, 0x57, 0xdf, 0x71, 0x4d, 0xcd, 0x4d, 0xd4, 0x53, 0xc8, + 0xb3, 0x09, 0xd2, 0x1d, 0x1e, 0xa8, 0x84, 0xc7, 0x3a, 0x45, 0x54, 0x97, 0x0b, 0xee, 0xb4, 0xfe, 0x36, 0xbd, 0x48, + 0xed, 0xb4, 0xbb, 0xf2, 0xea, 0x2c, 0xbe, 0x78, 0x8e, 0x75, 0x9e, 0x5d, 0xa4, 0xc7, 0x50, 0xa1, 0xdc, 0x39, 0x84, + 0x0d, 0xb1, 0x9a, 0xf3, 0x66, 0x73, 0xf6, 0x26, 0xbf, 0x1d, 0x0d, 0x19, 0xad, 0x8b, 0x21, 0xf8, 0x59, 0x07, 0xa2, + 0xba, 0x7c, 0x72, 0xa7, 0xa5, 0x57, 0x2e, 0x52, 0x9e, 0x59, 0xc5, 0x2e, 0x39, 0xba, 0x70, 0x29, 0xc9, 0xf8, 0x2e, + 0xbb, 0x31, 0x40, 0x69, 0x74, 0x28, 0xc7, 0x02, 0xd0, 0xbe, 0x1b, 0x6a, 0x80, 0x0e, 0x46, 0xd5, 0x2e, 0x3c, 0x95, + 0x3b, 0x2d, 0x7d, 0xcc, 0x68, 0x07, 0x2e, 0x6a, 0x82, 0x7b, 0xa6, 0xdc, 0xda, 0x48, 0xca, 0xd5, 0x00, 0xb1, 0x55, + 0x63, 0x61, 0x19, 0x55, 0x3f, 0xca, 0x71, 0x0b, 0xec, 0x29, 0x25, 0x94, 0x00, 0x7d, 0xd4, 0x3f, 0xd9, 0x10, 0x30, + 0x3a, 0xe0, 0x57, 0xb3, 0x2f, 0x45, 0x08, 0x15, 0x43, 0x0d, 0xec, 0x84, 0xaa, 0x1d, 0x83, 0x69, 0x2d, 0xd2, 0x7f, + 0x2b, 0x94, 0xa0, 0xcf, 0x0d, 0xd5, 0xd0, 0x08, 0x86, 0xd9, 0xbc, 0xcd, 0xa8, 0xe5, 0x5c, 0xc4, 0x87, 0x03, 0xde, + 0x2a, 0x54, 0x01, 0x61, 0x7b, 0xcd, 0x4f, 0x9d, 0x71, 0x47, 0xa4, 0x7a, 0x68, 0xe9, 0xc1, 0x34, 0xb8, 0x54, 0xf9, + 0xf1, 0x6b, 0xb5, 0x46, 0xbf, 0xd3, 0x7f, 0x70, 0xfa, 0x33, 0xa7, 0x7f, 0xe7, 0x74, 0x97, 0x8f, 0xcb, 0xad, 0x73, + 0xa7, 0x7c, 0x9d, 0xbe, 0x0e, 0x25, 0x3c, 0x8b, 0xf3, 0x4b, 0x2e, 0xc3, 0xcd, 0xb1, 0x82, 0x23, 0x38, 0xf4, 0x27, + 0x32, 0x4f, 0xbf, 0xe7, 0x77, 0xa0, 0xfe, 0x80, 0xd1, 0x19, 0x4c, 0xb8, 0xf1, 0xa5, 0x76, 0x6b, 0xd2, 0xcd, 0x56, + 0xaa, 0xdb, 0xef, 0x64, 0x76, 0x79, 0x99, 0x72, 0xe7, 0xee, 0x3b, 0xca, 0x4d, 0x63, 0x61, 0xbb, 0x6f, 0xd2, 0x58, + 0x93, 0xf2, 0x3e, 0xb2, 0xaf, 0xf3, 0x32, 0x65, 0xae, 0x44, 0xad, 0xcf, 0x8b, 0x34, 0x0a, 0xab, 0xe5, 0xd4, 0x9b, + 0x66, 0xcb, 0x8b, 0x94, 0xf7, 0x90, 0x70, 0xa1, 0xab, 0xd5, 0xc5, 0xf2, 0xe2, 0x22, 0x55, 0xb7, 0x08, 0x42, 0xee, + 0xac, 0xac, 0x40, 0xcf, 0x05, 0xa4, 0xd1, 0xf5, 0xa5, 0x19, 0x70, 0x52, 0x2c, 0x40, 0x66, 0xa8, 0x46, 0x31, 0xcb, + 0xd4, 0x53, 0x6f, 0xf4, 0xc2, 0x23, 0x63, 0xfa, 0x93, 0x7b, 0xb3, 0x95, 0xe1, 0x16, 0xd5, 0xc5, 0x56, 0x5b, 0xab, + 0xb9, 0x94, 0xf7, 0x91, 0xaa, 0x86, 0x37, 0x55, 0xd5, 0x7e, 0x62, 0xdf, 0x6d, 0xde, 0x95, 0x25, 0x81, 0x17, 0xc1, + 0x5d, 0x59, 0x3f, 0xa9, 0xab, 0xb2, 0x8e, 0x73, 0x65, 0xed, 0x5a, 0xd5, 0xa3, 0x52, 0x90, 0x54, 0xac, 0x00, 0x8f, + 0xa2, 0x12, 0xe5, 0x73, 0xed, 0x2c, 0x09, 0x54, 0x01, 0x0b, 0xf6, 0x96, 0x63, 0x48, 0xfa, 0x15, 0xde, 0x74, 0x88, + 0x6f, 0x9e, 0xa2, 0x88, 0xb1, 0xb7, 0xec, 0xb4, 0x95, 0x5d, 0xa7, 0xdd, 0xf0, 0xe8, 0x09, 0x30, 0x1e, 0x6d, 0xd5, + 0x8b, 0x9e, 0x45, 0x0d, 0x31, 0xb7, 0xbb, 0xca, 0xe1, 0x44, 0x84, 0x7b, 0xb5, 0x75, 0x14, 0x98, 0x82, 0xa8, 0xdc, + 0x69, 0x85, 0x86, 0xed, 0x32, 0x30, 0x0f, 0x1a, 0xf6, 0xb3, 0xbb, 0xb2, 0xf7, 0x48, 0x1a, 0x05, 0x06, 0x94, 0x7f, + 0x47, 0xbf, 0x48, 0x48, 0xa9, 0x2f, 0x9d, 0xd3, 0x62, 0x31, 0x2a, 0xcf, 0x41, 0xef, 0x82, 0x2c, 0x64, 0x06, 0x7e, + 0x9a, 0x58, 0xcd, 0x09, 0x38, 0x14, 0xdc, 0x14, 0x8b, 0x79, 0xde, 0x91, 0xbb, 0x95, 0x3b, 0x2d, 0xdc, 0x20, 0xe3, + 0xaa, 0xb5, 0x2c, 0xb3, 0xdc, 0x69, 0x25, 0xd3, 0xcd, 0x32, 0xad, 0x0c, 0xef, 0x80, 0xd1, 0x16, 0x78, 0x24, 0xba, + 0x4f, 0xb1, 0x99, 0x2a, 0xe5, 0xaa, 0xa5, 0x2d, 0xac, 0x3b, 0x7c, 0x08, 0xf8, 0x08, 0xed, 0x9b, 0x30, 0x60, 0xb6, + 0xbb, 0x4a, 0xec, 0xc1, 0xb5, 0xe8, 0x2c, 0x52, 0xa7, 0xd6, 0x22, 0x52, 0x96, 0x3b, 0x30, 0xa2, 0x2a, 0x2c, 0xa6, + 0x1a, 0x07, 0x10, 0x89, 0x2a, 0x6f, 0x61, 0xc4, 0x2f, 0xdb, 0xd9, 0x76, 0x6d, 0x9d, 0x1b, 0x2b, 0x4c, 0x76, 0x5a, + 0x8a, 0xcb, 0xb1, 0x8a, 0xdf, 0xb5, 0xfe, 0xa6, 0x4a, 0x9c, 0x31, 0x08, 0x16, 0x41, 0x1f, 0xe7, 0x70, 0xce, 0x53, + 0x59, 0x29, 0x54, 0xdd, 0x07, 0x87, 0x22, 0xea, 0x84, 0x80, 0x80, 0x2b, 0x5e, 0xa7, 0x60, 0xc4, 0x51, 0xe0, 0x95, + 0xb9, 0xdb, 0x67, 0x45, 0xbd, 0x73, 0x51, 0x9a, 0x5b, 0x94, 0xe6, 0x7f, 0x0c, 0xa5, 0x12, 0x50, 0x2a, 0x00, 0xa5, + 0xf7, 0x98, 0x98, 0x11, 0xb8, 0xdd, 0x55, 0x6e, 0x4c, 0xdd, 0xcf, 0xa2, 0x27, 0xd9, 0x42, 0x39, 0x05, 0xcc, 0xf4, + 0x72, 0x20, 0x49, 0x05, 0x13, 0x57, 0x74, 0xc0, 0x58, 0x62, 0x85, 0xb0, 0xaa, 0xad, 0xd8, 0xb5, 0xaa, 0x04, 0xc3, + 0xc3, 0x7b, 0xc5, 0xab, 0xd1, 0x41, 0x42, 0x1a, 0x36, 0x70, 0x9c, 0x18, 0x73, 0x0c, 0xdd, 0x18, 0x34, 0x34, 0x44, + 0xfc, 0x6a, 0xe7, 0xf0, 0x09, 0x5e, 0x11, 0x79, 0xb8, 0xbb, 0x4a, 0xc2, 0xb0, 0x5f, 0x3e, 0xd9, 0x53, 0x3f, 0x5b, + 0x35, 0x6a, 0x55, 0x3b, 0xb0, 0x3f, 0x42, 0xaf, 0x85, 0xe4, 0x0b, 0x28, 0xcd, 0xca, 0x9d, 0xd6, 0x5c, 0xc9, 0xf8, + 0x24, 0xac, 0x2e, 0xab, 0xec, 0x53, 0xbd, 0x57, 0xcc, 0x09, 0x5c, 0x0d, 0x39, 0x8f, 0x6f, 0xa1, 0x46, 0x1c, 0x56, + 0x17, 0x54, 0x0e, 0x1a, 0x55, 0xaa, 0x05, 0x90, 0xd7, 0x17, 0xc0, 0xbf, 0x61, 0xb6, 0x12, 0x3d, 0x33, 0x2d, 0x8b, + 0x8b, 0x38, 0x84, 0x0b, 0x45, 0x2d, 0x36, 0x8c, 0xc6, 0xab, 0x89, 0x1f, 0x31, 0xd7, 0x2b, 0x52, 0x70, 0x53, 0xdd, + 0x83, 0x93, 0x2d, 0xe3, 0xff, 0x89, 0x03, 0x0d, 0xd8, 0xc1, 0xfe, 0x04, 0x89, 0x4d, 0x37, 0x07, 0x66, 0x17, 0x45, + 0x6e, 0x0c, 0x77, 0x9f, 0x32, 0x82, 0xbc, 0xb6, 0x5e, 0xf4, 0x70, 0xd4, 0x2a, 0x70, 0x81, 0x05, 0x62, 0x81, 0x23, + 0x42, 0x38, 0xb7, 0x75, 0x82, 0xb9, 0x9f, 0x51, 0x55, 0xf4, 0x13, 0x2d, 0xe2, 0xa2, 0xb8, 0xc9, 0x72, 0x88, 0xb7, + 0x81, 0x66, 0xa2, 0x3f, 0xc4, 0xc2, 0xe6, 0x89, 0xd0, 0xa9, 0x83, 0x77, 0x34, 0xb1, 0x21, 0x2e, 0xaa, 0xb2, 0x38, + 0x0c, 0xf7, 0x1f, 0x3f, 0x2e, 0x77, 0x5a, 0x0b, 0x30, 0xea, 0xe6, 0x88, 0xb4, 0x0c, 0x8e, 0x6f, 0xfd, 0x77, 0x9e, + 0xfe, 0x87, 0x16, 0x6b, 0x54, 0x9e, 0x23, 0x3b, 0x5b, 0x80, 0x68, 0xb7, 0x8e, 0xbb, 0xfa, 0x55, 0x88, 0x0a, 0x71, + 0x9e, 0xb1, 0x7e, 0x10, 0xb8, 0x88, 0xaa, 0x3a, 0x45, 0x38, 0xf8, 0x82, 0xf8, 0x8b, 0x78, 0x7a, 0x0a, 0x81, 0x07, + 0xde, 0x3e, 0x85, 0xa3, 0x55, 0xb5, 0x24, 0x8d, 0x95, 0xad, 0x47, 0x1f, 0x32, 0x80, 0xd4, 0x2b, 0x71, 0x6f, 0x36, + 0x5e, 0xed, 0x97, 0x7b, 0x97, 0x09, 0x09, 0x0d, 0xb3, 0xa8, 0xae, 0x51, 0xa4, 0x83, 0x2f, 0x20, 0xf1, 0xe2, 0xa8, + 0x4f, 0xfb, 0xb4, 0x6f, 0x9c, 0xc2, 0x51, 0xce, 0x76, 0x57, 0x12, 0x3c, 0x8d, 0x9d, 0x4b, 0x7c, 0x1a, 0x8c, 0xcb, + 0xce, 0x05, 0x3e, 0xed, 0x8f, 0xad, 0x77, 0xab, 0x55, 0xe7, 0x01, 0xce, 0xd8, 0x76, 0x0e, 0x6b, 0xf3, 0xae, 0xce, + 0x72, 0xfc, 0x81, 0xe9, 0xd5, 0x13, 0xf4, 0x97, 0xdd, 0x55, 0xee, 0x89, 0xd0, 0xcf, 0x49, 0xa9, 0x9f, 0x2e, 0xed, + 0xd3, 0x05, 0xa9, 0xcf, 0x9d, 0xb0, 0x81, 0x3e, 0xe2, 0x4f, 0xcc, 0x5d, 0x02, 0xc9, 0x47, 0x0d, 0xa5, 0x2b, 0xd5, + 0xf4, 0x5c, 0xb5, 0x72, 0xc6, 0xe7, 0x0b, 0x9e, 0xc7, 0x72, 0x99, 0xf3, 0x9a, 0x33, 0x57, 0xbd, 0x3d, 0x97, 0xd5, + 0xeb, 0xf3, 0x34, 0xbb, 0x69, 0x57, 0xd1, 0xff, 0x5b, 0xab, 0x5c, 0x25, 0x97, 0x57, 0xb6, 0x4e, 0x83, 0x87, 0x3a, + 0xf7, 0xc5, 0x5b, 0x4e, 0xaa, 0x94, 0xd1, 0xd6, 0xcb, 0xec, 0x26, 0xf8, 0x8f, 0xff, 0x6a, 0xf9, 0xa9, 0xd9, 0xce, + 0x18, 0x5e, 0x1d, 0x41, 0xce, 0x11, 0x1a, 0x6d, 0x07, 0x09, 0xb4, 0xd5, 0xed, 0x6f, 0x28, 0x24, 0x12, 0x14, 0x58, + 0x4a, 0x31, 0x03, 0xb9, 0x79, 0x04, 0x86, 0x43, 0xb6, 0x6c, 0xd3, 0x1e, 0x80, 0xf0, 0x79, 0x72, 0x79, 0xf5, 0xe7, + 0x40, 0x04, 0x94, 0xdc, 0x03, 0x23, 0xbc, 0xfa, 0x24, 0x20, 0x21, 0x9e, 0x6f, 0xf3, 0xfb, 0xea, 0xa6, 0xe4, 0x0f, + 0xc1, 0xa7, 0xa2, 0xfa, 0x4f, 0x8d, 0x61, 0x3b, 0xf8, 0x9f, 0x06, 0x79, 0x79, 0x6e, 0xf6, 0x1d, 0xf7, 0x10, 0x9a, + 0x7e, 0xfd, 0xc7, 0x07, 0xa6, 0x76, 0x54, 0x6c, 0x67, 0x11, 0x4f, 0xc1, 0x57, 0xd3, 0xbb, 0xc8, 0xa4, 0xcc, 0xe6, + 0x78, 0x89, 0xae, 0x1d, 0xb4, 0x0e, 0xb4, 0x0c, 0xfe, 0xe3, 0xbf, 0xc2, 0x12, 0xdc, 0xd2, 0x55, 0xd9, 0xfa, 0x8f, + 0xff, 0xfb, 0xb8, 0x21, 0xba, 0xca, 0x73, 0x60, 0xe2, 0xa7, 0x56, 0x0f, 0x6a, 0x68, 0x07, 0x45, 0x68, 0x72, 0x0b, + 0x7f, 0x1c, 0xe9, 0x18, 0x4b, 0xb5, 0x05, 0xe5, 0x56, 0xc9, 0xd2, 0x38, 0x57, 0x91, 0xf6, 0xba, 0x7d, 0x08, 0x7a, + 0x71, 0xec, 0x46, 0x28, 0xa6, 0x94, 0xae, 0x5f, 0xd4, 0x93, 0x4d, 0xc4, 0x45, 0xb1, 0x9c, 0xf3, 0xa9, 0x0e, 0xfc, + 0x62, 0x4e, 0x2e, 0xbf, 0x67, 0xb0, 0xf0, 0x95, 0xb7, 0x64, 0x24, 0x41, 0x6c, 0x8d, 0xab, 0x9b, 0xde, 0x9b, 0x7b, + 0x87, 0x9c, 0xb6, 0x05, 0xba, 0x6a, 0x75, 0x2b, 0x90, 0x82, 0x2e, 0xd2, 0x96, 0x9a, 0xf3, 0x8b, 0x44, 0xc4, 0xf9, + 0xdd, 0xb9, 0xda, 0x68, 0xba, 0x31, 0x60, 0x6a, 0xe7, 0xe3, 0x6e, 0x35, 0x5c, 0x97, 0xf1, 0x9d, 0x69, 0x2d, 0x7a, + 0xf3, 0x3a, 0x72, 0xf6, 0x1b, 0x35, 0xc3, 0x83, 0xc6, 0x5b, 0xad, 0x8b, 0x73, 0x8d, 0x21, 0xb7, 0x95, 0xb0, 0xae, + 0xb5, 0x02, 0x4f, 0x45, 0x93, 0xc5, 0x7c, 0x9a, 0x04, 0x18, 0x93, 0x77, 0x91, 0xdd, 0xf6, 0x76, 0x57, 0x3c, 0x8c, + 0xe6, 0x71, 0xfe, 0x81, 0x4f, 0x7b, 0x93, 0x24, 0x9f, 0xa4, 0xb0, 0x75, 0xb9, 0x48, 0x63, 0xf1, 0x41, 0xff, 0xec, + 0x65, 0x4b, 0x89, 0x21, 0xc8, 0x1f, 0xb5, 0x70, 0x98, 0xb1, 0x2b, 0xcb, 0xf0, 0xaa, 0xe6, 0x48, 0x30, 0x23, 0x56, + 0x18, 0x46, 0x84, 0xda, 0x8d, 0x8c, 0x53, 0x8b, 0xc2, 0x79, 0x69, 0x88, 0x89, 0x56, 0xd3, 0x8b, 0x8c, 0x3a, 0xa2, + 0xee, 0xc8, 0x94, 0xbb, 0xbc, 0x42, 0x34, 0xb6, 0xf0, 0x67, 0x3b, 0x83, 0x92, 0x3f, 0xd2, 0x99, 0x6d, 0xe5, 0x5f, + 0x19, 0x1d, 0x94, 0xf6, 0xf0, 0x22, 0x93, 0x3f, 0xd2, 0xb5, 0xde, 0x24, 0xdd, 0xd7, 0xb1, 0xfb, 0x69, 0x8d, 0xbc, + 0xc3, 0x0a, 0xa4, 0x1a, 0x05, 0xd7, 0xc0, 0xfa, 0x6f, 0xff, 0xe7, 0xff, 0x04, 0x0c, 0x0c, 0xf6, 0x45, 0xd9, 0x6c, + 0xe6, 0xd8, 0x67, 0x1e, 0xfa, 0xe6, 0xff, 0xf8, 0x2f, 0xff, 0xef, 0xff, 0xf3, 0x3f, 0xdb, 0xcf, 0x04, 0xec, 0xe8, + 0x4c, 0xac, 0xaa, 0xce, 0xa6, 0xe0, 0x80, 0x69, 0x86, 0x31, 0x8b, 0xc5, 0x7d, 0x63, 0x18, 0xd5, 0x08, 0x78, 0xc1, + 0xf9, 0x14, 0xf6, 0x89, 0x74, 0xa3, 0xf4, 0x3c, 0xe5, 0xd7, 0xdc, 0x04, 0xf4, 0x6d, 0xe9, 0x6a, 0xcb, 0x17, 0x93, + 0x6c, 0x29, 0x64, 0xe8, 0x72, 0xed, 0x3a, 0x19, 0xc0, 0x08, 0xb6, 0x2c, 0xa0, 0xc6, 0xfa, 0x81, 0xe9, 0xaa, 0x00, + 0xb8, 0x17, 0xb2, 0xf0, 0x9e, 0xf2, 0x00, 0x54, 0xa9, 0x7b, 0x60, 0xa3, 0x03, 0x12, 0xc0, 0x7d, 0x28, 0x1a, 0x4b, + 0x29, 0x2c, 0xb3, 0x7b, 0xf1, 0xb4, 0xcd, 0xda, 0x69, 0xb9, 0x7a, 0x75, 0x39, 0xfc, 0xce, 0xa1, 0xe5, 0x9a, 0x5b, + 0xe6, 0xa3, 0x55, 0x1f, 0xef, 0x05, 0xde, 0x85, 0x2e, 0x78, 0x51, 0x1d, 0x9b, 0x86, 0xe4, 0x3b, 0x0f, 0xa3, 0x0c, + 0x3d, 0xd3, 0xd5, 0x97, 0x75, 0x8c, 0x54, 0xe5, 0xb4, 0x4f, 0xf7, 0x1f, 0x3f, 0xa6, 0x83, 0x8d, 0x4e, 0x51, 0xff, + 0x43, 0xa9, 0xf2, 0x47, 0x3b, 0xad, 0xbe, 0xac, 0x77, 0x5a, 0x95, 0xd3, 0xc1, 0xe3, 0x47, 0xf4, 0xe0, 0xcb, 0xfe, + 0xbd, 0xdd, 0xce, 0xf5, 0x59, 0x83, 0xfc, 0xf2, 0x22, 0xd2, 0xa1, 0x20, 0xf7, 0xbd, 0xbf, 0x89, 0x34, 0xed, 0xb8, + 0x6a, 0xfa, 0x76, 0xc8, 0x9c, 0xd2, 0x50, 0x35, 0x04, 0x13, 0xdb, 0x84, 0x80, 0xcf, 0x66, 0x7c, 0x22, 0x8b, 0xb0, + 0x7e, 0x1b, 0x40, 0xf4, 0x1a, 0xd2, 0xc0, 0x99, 0x5c, 0xcc, 0x61, 0x4d, 0xe2, 0xdd, 0x83, 0x07, 0xd5, 0x50, 0x1d, + 0x07, 0xba, 0xf1, 0xf5, 0xda, 0x84, 0x7b, 0xd5, 0xca, 0x11, 0x1c, 0x2d, 0x25, 0x2b, 0x7a, 0xcb, 0xcc, 0xa9, 0x83, + 0xfb, 0x58, 0x4b, 0x5d, 0x9a, 0xba, 0xd0, 0x8c, 0x46, 0xd1, 0xff, 0xf7, 0x7f, 0xfd, 0x97, 0xff, 0x25, 0xa2, 0x11, + 0xb4, 0x12, 0xd1, 0xe8, 0xe5, 0x9b, 0xe3, 0xef, 0x4f, 0x9e, 0x45, 0x63, 0x8a, 0x2f, 0xfe, 0xb7, 0x88, 0x46, 0x4b, + 0xa1, 0x5f, 0xbd, 0x7f, 0xed, 0xbc, 0xfc, 0x6f, 0xff, 0xe3, 0xff, 0x1a, 0x51, 0x75, 0x72, 0x6c, 0x3c, 0xb6, 0x0c, + 0x62, 0x92, 0xd9, 0xa0, 0xe9, 0x3f, 0x05, 0x8b, 0xd3, 0x2a, 0x8d, 0xde, 0xbc, 0x3d, 0x79, 0xad, 0xfa, 0xfa, 0xdf, + 0x01, 0x40, 0x30, 0xef, 0xea, 0xae, 0x01, 0xac, 0x49, 0x9a, 0x15, 0xc0, 0xfe, 0x8f, 0x5f, 0xbe, 0x39, 0x05, 0x98, + 0x2a, 0x20, 0x94, 0xb5, 0xed, 0x13, 0xb8, 0xfc, 0xfd, 0xec, 0xf1, 0xed, 0xbb, 0x93, 0xd3, 0xd3, 0x88, 0xe2, 0x75, + 0xe2, 0x45, 0xe4, 0x32, 0x72, 0x35, 0xa1, 0x1f, 0x19, 0xe1, 0x96, 0x59, 0x57, 0xa2, 0x42, 0x59, 0x67, 0xea, 0x33, + 0xae, 0xca, 0x36, 0x26, 0x5c, 0x8b, 0x10, 0xdd, 0xaf, 0xb2, 0xaf, 0x7c, 0xc2, 0x98, 0xb6, 0x2c, 0xbc, 0x87, 0xa5, + 0x54, 0xad, 0x04, 0x54, 0xdb, 0x2d, 0xa5, 0xf1, 0xed, 0x96, 0x52, 0xa5, 0xf0, 0x36, 0xd6, 0xc6, 0x32, 0x9b, 0x3b, + 0xd2, 0x9d, 0xdf, 0x7e, 0x0c, 0x55, 0x95, 0xad, 0xe1, 0x5f, 0x01, 0x59, 0xdf, 0x32, 0xd2, 0x84, 0x79, 0x4b, 0xb1, + 0x36, 0x1c, 0x54, 0x04, 0xab, 0xd4, 0xd7, 0x07, 0x10, 0xbb, 0x4d, 0xd9, 0xbd, 0xc9, 0xe3, 0x45, 0xc5, 0xa0, 0xb7, + 0xa8, 0xfa, 0x5b, 0x99, 0xf5, 0x96, 0xbd, 0xe7, 0xf6, 0x7a, 0x8e, 0x22, 0xee, 0x62, 0xa5, 0x36, 0xbc, 0x6c, 0xca, + 0xc3, 0x30, 0xaa, 0xbc, 0x32, 0x66, 0x40, 0xd7, 0x71, 0x7a, 0x7d, 0xff, 0x70, 0x3e, 0xbe, 0x02, 0x71, 0xd1, 0x7d, + 0x74, 0x09, 0xe2, 0xa2, 0x7b, 0x70, 0x11, 0xde, 0xc4, 0x92, 0xe7, 0xe7, 0x57, 0x70, 0xe8, 0xfd, 0x8f, 0x68, 0xd0, + 0x14, 0xcc, 0x1c, 0xf1, 0x4d, 0x7c, 0xf7, 0xc7, 0xb6, 0x79, 0x47, 0x37, 0xf1, 0xdd, 0xb6, 0x1d, 0x47, 0x43, 0xed, + 0x57, 0x4d, 0x87, 0xa0, 0x9e, 0x07, 0xd1, 0x9b, 0x6f, 0xbe, 0x51, 0x2a, 0x5c, 0x88, 0xfd, 0xed, 0xae, 0xda, 0xea, + 0x75, 0x59, 0x21, 0x15, 0xcf, 0xe7, 0x27, 0xc5, 0x79, 0x26, 0xfe, 0x18, 0x38, 0x6f, 0x41, 0xef, 0xf8, 0x24, 0x78, + 0xb0, 0xf1, 0x0d, 0x80, 0x54, 0x97, 0x08, 0x11, 0x3e, 0x3a, 0x20, 0x0d, 0xff, 0x35, 0xc2, 0xe4, 0x0f, 0x92, 0x23, + 0xdf, 0x4e, 0x84, 0x9c, 0xea, 0x7d, 0x12, 0x5e, 0x7f, 0x8a, 0x55, 0xe0, 0x1f, 0xd1, 0xa4, 0xbd, 0x44, 0xcc, 0xf2, + 0x38, 0xe7, 0xd3, 0xfb, 0xe7, 0xbb, 0x4e, 0x95, 0x7e, 0xb1, 0x5c, 0x2c, 0xb2, 0x5c, 0x16, 0xe7, 0x98, 0x0f, 0x64, + 0x9e, 0xc0, 0xda, 0x84, 0x2b, 0xcb, 0x6c, 0x26, 0xdc, 0x0f, 0x5b, 0x29, 0xa4, 0xe6, 0x51, 0xa2, 0x82, 0xd5, 0x4e, + 0xd0, 0xa8, 0x68, 0x6f, 0x5a, 0x45, 0x8b, 0x57, 0x56, 0x31, 0x93, 0x8b, 0x76, 0xd0, 0x87, 0x2b, 0x7d, 0x2b, 0xdf, + 0xba, 0xc9, 0xe6, 0x0b, 0xd1, 0xc7, 0xe0, 0xcc, 0xc3, 0x54, 0x07, 0x4f, 0x97, 0xb3, 0x19, 0x28, 0x0a, 0x5a, 0xa0, + 0x43, 0x56, 0x50, 0x15, 0x45, 0x0d, 0xc7, 0xa3, 0x7e, 0x48, 0xf8, 0x0d, 0x64, 0xa0, 0xae, 0x6e, 0x77, 0xd0, 0xf1, + 0x3f, 0xb9, 0x8f, 0x37, 0x9a, 0xc8, 0x83, 0x7d, 0x4f, 0x7e, 0xfe, 0x88, 0x62, 0x36, 0x71, 0x93, 0x90, 0x0e, 0xb3, + 0x8c, 0x25, 0x42, 0x7e, 0x85, 0xed, 0x43, 0xac, 0x69, 0xec, 0xe4, 0x7b, 0xa8, 0x9d, 0x54, 0x89, 0xbb, 0x4c, 0x19, + 0x07, 0x31, 0xe1, 0xc2, 0xf1, 0x55, 0x9c, 0x1f, 0x67, 0x53, 0x8e, 0x20, 0x5e, 0xc8, 0x2c, 0x86, 0x0b, 0xaf, 0xaa, + 0x54, 0x82, 0x98, 0x49, 0xb0, 0x57, 0xcb, 0x2e, 0xb8, 0x07, 0x45, 0xe7, 0x6e, 0x11, 0xeb, 0xee, 0xee, 0x51, 0x98, + 0xbd, 0xed, 0x04, 0x64, 0xa6, 0x4e, 0x53, 0xd0, 0xd6, 0x57, 0x2e, 0x85, 0x1f, 0xc7, 0x79, 0x9e, 0xf0, 0xbc, 0xe5, + 0x3d, 0xff, 0x9d, 0xb8, 0x84, 0xbe, 0xd5, 0x29, 0x80, 0x59, 0xb4, 0x66, 0x09, 0x4f, 0xa7, 0x6c, 0x67, 0xa2, 0x3e, + 0xb4, 0xd6, 0xc0, 0x83, 0xaf, 0xfa, 0xfd, 0xbe, 0xb6, 0x80, 0x0f, 0xd4, 0x23, 0x58, 0xbf, 0xe1, 0x11, 0x7e, 0xd4, + 0xf4, 0xe2, 0xaf, 0x94, 0x91, 0x63, 0xc3, 0x82, 0xb5, 0x15, 0xc2, 0x77, 0x2a, 0x7b, 0xcc, 0x1f, 0x81, 0x4d, 0x65, + 0x99, 0xb1, 0xa0, 0x0d, 0x0c, 0x58, 0x15, 0x4c, 0x0d, 0x80, 0x1e, 0xff, 0x11, 0x80, 0xce, 0x92, 0x79, 0x22, 0x2e, + 0x8b, 0x7b, 0x21, 0x02, 0x51, 0x58, 0x87, 0x47, 0xaa, 0x2f, 0x76, 0x5a, 0x38, 0x87, 0x57, 0x59, 0x0a, 0x57, 0x57, + 0xee, 0x70, 0xff, 0xd2, 0x6f, 0x7d, 0xdd, 0xef, 0xf7, 0x69, 0xef, 0x11, 0x5c, 0x2c, 0xf8, 0xf8, 0x8b, 0x3e, 0xed, + 0xc1, 0x3f, 0xbe, 0xef, 0x6f, 0xd9, 0x48, 0x0c, 0xe7, 0x89, 0xe8, 0xa9, 0x9f, 0xfb, 0xfd, 0x4f, 0x83, 0xf7, 0xe1, + 0x30, 0xa0, 0xba, 0x45, 0xbd, 0xe6, 0x5f, 0xd7, 0x97, 0xb0, 0xeb, 0x9c, 0x0c, 0x61, 0xfd, 0x27, 0x06, 0xf2, 0x27, + 0xcd, 0xfb, 0x48, 0xa2, 0x17, 0xba, 0xef, 0xa0, 0x75, 0x9c, 0x2d, 0xd3, 0x69, 0x4b, 0x64, 0xb2, 0x05, 0xa1, 0x4c, + 0x2d, 0x1b, 0x3a, 0x12, 0xd5, 0x42, 0xce, 0x63, 0x96, 0xa8, 0x4b, 0x67, 0x14, 0x73, 0x82, 0x26, 0x10, 0x8b, 0xa3, + 0x6d, 0x54, 0x36, 0x8e, 0x20, 0x29, 0xe2, 0x27, 0x7c, 0xa0, 0xa7, 0x1e, 0xea, 0x17, 0x9f, 0x52, 0xdf, 0x4c, 0xcd, + 0x58, 0x1d, 0xc7, 0x6d, 0xc7, 0xeb, 0x75, 0x3b, 0x5b, 0xaf, 0xe1, 0xbe, 0x8b, 0x4f, 0x1d, 0x9f, 0x9a, 0x7b, 0xae, + 0xb3, 0x5a, 0x40, 0x6e, 0x1a, 0x05, 0xf4, 0x0b, 0x28, 0x0f, 0x62, 0x9d, 0xfe, 0x48, 0xfd, 0xca, 0xa8, 0xee, 0x50, + 0xfd, 0x2c, 0x6a, 0x17, 0x79, 0xb4, 0x26, 0x2c, 0x56, 0x8a, 0xd1, 0x7a, 0x1d, 0xe1, 0x7a, 0x82, 0x2b, 0xed, 0x32, + 0x5b, 0x34, 0x88, 0xe8, 0x92, 0x15, 0xf6, 0x67, 0x84, 0x00, 0x2f, 0x35, 0x33, 0xac, 0xe0, 0xbd, 0x89, 0x73, 0xe1, + 0x82, 0xfb, 0x3a, 0x6b, 0xe9, 0x4e, 0x5b, 0x3a, 0xd5, 0xe2, 0xb4, 0x3e, 0x13, 0x53, 0x26, 0xbc, 0x25, 0xdc, 0xa4, + 0x06, 0xf1, 0x73, 0x94, 0xd3, 0xc8, 0x70, 0xf1, 0x88, 0xd0, 0xc5, 0xb6, 0x9c, 0x8a, 0xc3, 0x85, 0xce, 0x36, 0xe2, + 0x45, 0x7a, 0xac, 0xe7, 0x33, 0x8c, 0x48, 0x14, 0x93, 0xbb, 0x88, 0x4e, 0x08, 0xad, 0xde, 0xab, 0xc1, 0xab, 0xed, + 0x75, 0x44, 0x53, 0xf7, 0x15, 0x4c, 0x03, 0x24, 0xb9, 0xd5, 0x91, 0xfa, 0xb3, 0x7f, 0x67, 0x9c, 0x9e, 0x4a, 0x75, + 0xbb, 0x70, 0x32, 0x3c, 0x3e, 0x14, 0xb9, 0x57, 0xe1, 0xea, 0x4c, 0x8f, 0x5c, 0x45, 0xf1, 0xe9, 0x20, 0xbe, 0xf2, + 0xf0, 0xec, 0x1f, 0x8d, 0x90, 0x38, 0x23, 0x30, 0x4b, 0x7a, 0x93, 0xb3, 0xd5, 0xce, 0x2f, 0xb7, 0x83, 0xa7, 0xa3, + 0xc1, 0xf0, 0x60, 0x30, 0xdf, 0x09, 0x22, 0x1e, 0x51, 0x55, 0xd0, 0x1f, 0x1e, 0x1c, 0x40, 0xc1, 0x8d, 0x53, 0xb0, + 0x0f, 0x05, 0x89, 0x53, 0xf0, 0x18, 0x0a, 0x26, 0x4e, 0xc1, 0x17, 0x50, 0x30, 0x75, 0x0a, 0xbe, 0x84, 0x82, 0xeb, + 0xa8, 0xa4, 0xff, 0xd8, 0x38, 0x84, 0xf4, 0x09, 0xc7, 0x8e, 0xf2, 0xec, 0xa6, 0x60, 0x03, 0x93, 0x96, 0x63, 0x72, + 0xc5, 0xe7, 0x1c, 0x12, 0xcd, 0xe3, 0xcf, 0x34, 0xbb, 0xac, 0x8e, 0x23, 0xe9, 0xf8, 0x98, 0x97, 0xd9, 0x65, 0x4d, + 0x0e, 0x63, 0x9a, 0x1e, 0xc1, 0x6e, 0xf2, 0x51, 0x75, 0xcb, 0xe3, 0x97, 0x64, 0xbc, 0xf5, 0x34, 0x8f, 0xae, 0xf0, + 0xa5, 0x4d, 0xe2, 0xda, 0x7b, 0x44, 0x8c, 0x20, 0xff, 0x4f, 0x98, 0xfc, 0x2a, 0x87, 0x63, 0x5b, 0xb0, 0xf2, 0x55, + 0xcd, 0x03, 0xfb, 0x3a, 0xb0, 0x47, 0xcf, 0xfa, 0x74, 0xdf, 0x1c, 0xe6, 0x0a, 0xf4, 0xaa, 0x57, 0x2f, 0x1e, 0x77, + 0xed, 0xad, 0x35, 0xb8, 0xb6, 0x4d, 0xf5, 0x03, 0xb8, 0x2b, 0x4e, 0x0b, 0x74, 0xb8, 0x2b, 0x4d, 0x66, 0x70, 0xbc, + 0xdf, 0xcc, 0xbb, 0xe9, 0xa0, 0x85, 0x67, 0xf3, 0x68, 0x8a, 0x97, 0x48, 0x35, 0xa5, 0xbd, 0xf6, 0x4d, 0xa9, 0xa4, + 0xab, 0x82, 0x2a, 0x43, 0x51, 0x41, 0x65, 0x7c, 0x19, 0xc4, 0x54, 0xf9, 0x5b, 0x03, 0x38, 0x00, 0xda, 0x0f, 0xb3, + 0x80, 0xd3, 0x9b, 0x2b, 0x2e, 0x82, 0x89, 0xbd, 0x9c, 0x37, 0xb7, 0x51, 0xb9, 0x0a, 0x9f, 0x70, 0xd0, 0xc1, 0xfc, + 0x02, 0x5e, 0x9e, 0x8e, 0x35, 0xa8, 0x3d, 0x3b, 0x21, 0xa4, 0xfc, 0x77, 0x47, 0xdd, 0xa7, 0xd9, 0x65, 0xd4, 0x9c, + 0xc7, 0x7b, 0xe3, 0xe4, 0x1f, 0x0a, 0x4e, 0xff, 0xa4, 0x30, 0xf8, 0xed, 0xbd, 0xd9, 0xf0, 0xc8, 0xad, 0x9a, 0xc9, + 0x9f, 0x0e, 0x4a, 0x7c, 0xc6, 0x2f, 0x96, 0x97, 0xad, 0x97, 0xd9, 0xe5, 0x47, 0x23, 0x13, 0xdd, 0x57, 0x80, 0xfd, + 0x1d, 0x15, 0xb5, 0xd2, 0xd3, 0x64, 0x6f, 0xfa, 0x52, 0x3f, 0xcb, 0x7a, 0x7d, 0x09, 0xb0, 0xb5, 0xa4, 0x12, 0x9c, + 0xd0, 0x0f, 0x10, 0x91, 0x13, 0xf7, 0xf7, 0x12, 0x68, 0xc2, 0xf9, 0x7d, 0x16, 0x3b, 0xf0, 0x1c, 0xbe, 0xe2, 0x45, + 0x11, 0x5f, 0x72, 0x97, 0x39, 0xd4, 0x1a, 0x07, 0x76, 0x64, 0xf5, 0x79, 0x00, 0xcd, 0x89, 0x0b, 0x71, 0xeb, 0xc1, + 0xa9, 0x23, 0xf0, 0xf5, 0x00, 0x21, 0xba, 0xa1, 0x8f, 0x40, 0x72, 0xcd, 0xc0, 0x45, 0xa4, 0xd2, 0x66, 0xa1, 0x8c, + 0x2f, 0x37, 0x03, 0x1c, 0x81, 0x7e, 0xcb, 0x1a, 0xe3, 0x22, 0xb5, 0x9f, 0xd6, 0x73, 0xf4, 0xc7, 0x43, 0xe4, 0xd2, + 0xec, 0xf2, 0xdf, 0x1e, 0x1f, 0xf7, 0x40, 0xd8, 0xe1, 0x2e, 0xa7, 0x59, 0xe4, 0xe3, 0x5c, 0x51, 0x1f, 0xb1, 0xda, + 0xf2, 0x01, 0x69, 0x81, 0x90, 0x57, 0x3d, 0x4c, 0x66, 0xe6, 0xed, 0x0b, 0xb2, 0x6a, 0x66, 0x2a, 0x0c, 0xfe, 0xf2, + 0xe5, 0x0c, 0xfe, 0xeb, 0x4f, 0x4b, 0xac, 0xde, 0x9a, 0x26, 0xd7, 0x2b, 0x47, 0xb5, 0x9a, 0x65, 0x42, 0xf6, 0x66, + 0xf1, 0x3c, 0x49, 0xef, 0x82, 0x79, 0x26, 0xb2, 0x62, 0x11, 0x4f, 0xf8, 0x10, 0xb3, 0xa8, 0xea, 0x84, 0x6c, 0x03, + 0x7f, 0x3f, 0xe7, 0x73, 0xf5, 0xb5, 0x4d, 0x92, 0x3a, 0x4b, 0xf9, 0x6d, 0xa9, 0xa0, 0x59, 0xd5, 0x2a, 0xab, 0xaa, + 0x48, 0x51, 0xea, 0x0b, 0xd0, 0x09, 0x75, 0x06, 0x56, 0xc8, 0xe4, 0x3e, 0xd4, 0x5e, 0xbf, 0xc0, 0xdf, 0x7f, 0x9c, + 0xf3, 0x79, 0xcb, 0x7f, 0x6c, 0x1b, 0x3f, 0x04, 0xd0, 0xa0, 0xe1, 0x60, 0xbf, 0xd5, 0x1f, 0xe2, 0x27, 0xbd, 0x82, + 0xa7, 0x33, 0xec, 0xac, 0x87, 0x49, 0x0d, 0x1c, 0x4d, 0xf0, 0xcb, 0xfe, 0xe2, 0xd6, 0x34, 0xd6, 0x43, 0x53, 0x2f, + 0x34, 0xe9, 0xb6, 0xe5, 0x62, 0x86, 0x28, 0x38, 0xc0, 0xb6, 0x37, 0x4b, 0xb3, 0x9b, 0x80, 0xa7, 0x69, 0xb2, 0x28, + 0x92, 0x62, 0x88, 0xfd, 0x0d, 0x5a, 0xfd, 0xe1, 0x3c, 0xbe, 0xd5, 0x2d, 0x3f, 0x82, 0x96, 0x6d, 0xcd, 0xab, 0x64, + 0x3a, 0xe5, 0x62, 0x6b, 0xab, 0x07, 0x0f, 0xb7, 0x7a, 0xd0, 0xea, 0x3f, 0xd0, 0x0c, 0xe4, 0x95, 0x51, 0xed, 0x3c, + 0x0c, 0xda, 0xe3, 0x56, 0xbf, 0x31, 0xcc, 0xcd, 0x56, 0x17, 0x39, 0x5f, 0xe9, 0x84, 0xb5, 0xfd, 0xd2, 0xbf, 0x5e, + 0xe9, 0x99, 0xff, 0xea, 0xab, 0xaf, 0x4a, 0x7f, 0x6a, 0x7e, 0xf5, 0xa7, 0xd3, 0xd2, 0x9f, 0x98, 0x5f, 0xb3, 0xfe, + 0xac, 0xf4, 0x13, 0xf3, 0xeb, 0x60, 0x7f, 0x32, 0x3d, 0xd8, 0x2f, 0xfd, 0x1b, 0xfb, 0x7a, 0xd6, 0x2f, 0x7d, 0xae, + 0x7f, 0xe5, 0x7c, 0xaa, 0xe8, 0x44, 0x1f, 0xb7, 0xfa, 0xb2, 0xdf, 0x2f, 0x71, 0x29, 0x8f, 0x6a, 0x4c, 0x06, 0x9d, + 0x06, 0xe3, 0xd5, 0x27, 0xd7, 0x6c, 0x55, 0xdd, 0x4d, 0x26, 0x5b, 0xeb, 0x4d, 0xe3, 0xfc, 0xc3, 0xb8, 0xe5, 0x0c, + 0x21, 0x8e, 0x55, 0xb5, 0xd5, 0x45, 0x96, 0xc3, 0xf1, 0xf9, 0xc1, 0xe2, 0xb6, 0x55, 0x64, 0x90, 0x1f, 0x57, 0x93, + 0xf9, 0x60, 0x36, 0x54, 0xaf, 0x7a, 0x79, 0x3c, 0x4d, 0x96, 0x45, 0x30, 0xd8, 0xaf, 0xc8, 0x24, 0x18, 0x7c, 0xb1, + 0xb8, 0x55, 0x23, 0xc1, 0x2c, 0x9c, 0x83, 0x47, 0x8b, 0xdb, 0x21, 0x6a, 0x7c, 0x09, 0xa6, 0x07, 0x88, 0xd3, 0xb4, + 0xe5, 0x1f, 0x14, 0x2d, 0x1e, 0x17, 0xe8, 0x75, 0xb4, 0x78, 0xee, 0xdd, 0xaa, 0x44, 0xc0, 0x7f, 0x9b, 0xf3, 0x69, + 0x12, 0xb7, 0x3c, 0xa4, 0x93, 0x27, 0x6c, 0xd0, 0x07, 0x3f, 0x24, 0x59, 0xdd, 0x43, 0x71, 0x66, 0xad, 0xc0, 0xe5, + 0x2a, 0xed, 0x64, 0x0e, 0x66, 0x82, 0x58, 0xc8, 0xb2, 0x8c, 0xc6, 0x2a, 0x0e, 0xf6, 0x1b, 0x4f, 0x49, 0x5d, 0x15, + 0x53, 0x53, 0x92, 0x31, 0xfd, 0x87, 0x1b, 0xc2, 0x0a, 0xd2, 0xb2, 0x16, 0xe5, 0x6a, 0xea, 0x2b, 0xf9, 0xbe, 0x51, + 0x5f, 0xe1, 0x6c, 0x33, 0x2e, 0xb6, 0x56, 0x09, 0x90, 0x57, 0x55, 0xf9, 0x87, 0x13, 0x11, 0x0b, 0x82, 0x0d, 0x6a, + 0xab, 0x40, 0xd8, 0xb3, 0x9c, 0x45, 0xd6, 0x45, 0x0b, 0xec, 0x36, 0x8f, 0xe8, 0xcf, 0x7f, 0x46, 0x09, 0x33, 0x8d, + 0x38, 0x49, 0x30, 0xd0, 0x0e, 0xf3, 0x46, 0xa0, 0x8b, 0xd9, 0x2d, 0x99, 0xcd, 0x98, 0x32, 0x20, 0x55, 0x65, 0x6e, + 0x81, 0x0a, 0xc3, 0xac, 0xa7, 0x67, 0x55, 0x6f, 0x6c, 0x70, 0x6b, 0x7b, 0x50, 0x62, 0x12, 0x48, 0x75, 0x38, 0x68, + 0x6a, 0x33, 0xc0, 0x58, 0x20, 0x54, 0xcb, 0x36, 0xff, 0x4a, 0x08, 0xc7, 0x25, 0xf4, 0xde, 0xee, 0xe9, 0xdd, 0x8b, + 0xa9, 0x77, 0x96, 0x93, 0x32, 0x29, 0xde, 0x34, 0x53, 0x64, 0x18, 0x0f, 0xbb, 0x0b, 0x7e, 0xa9, 0xa3, 0xaf, 0x79, + 0x2d, 0xb3, 0x94, 0xfa, 0x38, 0xac, 0x8d, 0x2a, 0x70, 0x3f, 0xd3, 0xf6, 0x99, 0x9a, 0x24, 0xd1, 0x07, 0xf3, 0x56, + 0x5a, 0xdd, 0xc2, 0x03, 0xf6, 0x98, 0x99, 0x70, 0xaa, 0x3e, 0x4d, 0xa6, 0x65, 0xa9, 0x8f, 0x9f, 0xd6, 0x25, 0x86, + 0xf8, 0x98, 0xe6, 0x51, 0x54, 0x7b, 0x77, 0xbd, 0x51, 0x57, 0x51, 0x4d, 0x67, 0x10, 0x60, 0xa6, 0x63, 0xa0, 0x34, + 0x6e, 0x76, 0x5a, 0x0a, 0x4d, 0x2a, 0x20, 0xd3, 0x19, 0x0c, 0x04, 0xa6, 0x59, 0x0c, 0x9b, 0x57, 0xa6, 0x60, 0xf3, + 0x2c, 0x83, 0x42, 0x0b, 0x06, 0x1a, 0x42, 0x86, 0x50, 0xb3, 0x9b, 0x57, 0x2b, 0x58, 0xd7, 0xc1, 0x1f, 0xe5, 0x8e, + 0x55, 0x58, 0x80, 0xbe, 0x60, 0x53, 0x0f, 0x1f, 0x1c, 0x36, 0x83, 0x3a, 0x1e, 0x0c, 0xc5, 0xcf, 0x22, 0xbf, 0xb8, + 0xa1, 0x7e, 0x71, 0xd3, 0xfa, 0x7c, 0x65, 0x52, 0xe8, 0xca, 0x78, 0xd1, 0x83, 0x08, 0x1d, 0xe4, 0x32, 0x5a, 0x0a, + 0x3a, 0xd9, 0x7a, 0x87, 0xcb, 0x82, 0xe7, 0x3d, 0xe5, 0xe0, 0xc0, 0xb5, 0x39, 0x9c, 0x2c, 0xf3, 0x22, 0xcb, 0x83, + 0x45, 0x96, 0x40, 0xbe, 0x9a, 0x52, 0x6d, 0x95, 0x11, 0x3b, 0x06, 0x39, 0xe3, 0x55, 0xb6, 0x88, 0x27, 0x89, 0xbc, + 0x0b, 0xfa, 0x43, 0x25, 0x24, 0xfa, 0x43, 0x2d, 0xf1, 0xfa, 0x5b, 0xeb, 0x07, 0x1a, 0x97, 0x5d, 0xd4, 0x55, 0xf2, + 0x4d, 0xb1, 0xec, 0x92, 0xf1, 0xd0, 0x79, 0xab, 0x92, 0x08, 0x83, 0x48, 0x8d, 0xf3, 0xde, 0x25, 0x30, 0x31, 0x98, + 0xe8, 0xbf, 0xcc, 0xf0, 0x7f, 0x5f, 0xf5, 0x5b, 0x3a, 0x6d, 0x30, 0xf9, 0x94, 0x5e, 0x83, 0x0b, 0x3e, 0xcb, 0x72, + 0xc8, 0x22, 0xf4, 0xf1, 0xaa, 0x31, 0x5c, 0xea, 0xad, 0x2e, 0x73, 0x1a, 0x7c, 0xb5, 0xb8, 0xfd, 0xa4, 0xe6, 0xd5, + 0x37, 0x0f, 0x0e, 0x6d, 0x7b, 0x3b, 0x22, 0x93, 0x9e, 0x69, 0x8c, 0x7c, 0xa4, 0x35, 0xcd, 0xd8, 0xbf, 0x02, 0x01, + 0x81, 0xa8, 0x34, 0xb7, 0x6a, 0xed, 0xec, 0x7c, 0x02, 0xde, 0xcc, 0xc7, 0x16, 0x6f, 0xc3, 0x8d, 0x0e, 0x4c, 0xbe, + 0xd9, 0x46, 0xba, 0xf8, 0x79, 0x32, 0x9d, 0xa6, 0xbc, 0x29, 0x4d, 0x1e, 0x2f, 0x6e, 0x35, 0x01, 0x1c, 0x80, 0x2c, + 0x31, 0x5a, 0x4f, 0x43, 0x90, 0x54, 0x7d, 0x80, 0x3c, 0x19, 0x6e, 0xcd, 0x4e, 0xbf, 0xc8, 0x74, 0xe5, 0x9c, 0xa7, + 0xb1, 0x4c, 0xae, 0x79, 0x59, 0x9f, 0xb4, 0x1a, 0x56, 0xdc, 0x31, 0xd7, 0x00, 0x7a, 0xdc, 0xff, 0x6c, 0x68, 0x2c, + 0x63, 0x15, 0x3c, 0xf8, 0xec, 0xc0, 0x03, 0xd3, 0x0a, 0x90, 0xd0, 0x3a, 0x60, 0x14, 0x98, 0xbb, 0xe2, 0x86, 0x2d, + 0x7f, 0x50, 0x50, 0x7b, 0x0b, 0x11, 0xfc, 0xfa, 0x08, 0xd4, 0xf1, 0x45, 0x91, 0xa5, 0x4b, 0x08, 0x5b, 0xcf, 0x16, + 0x41, 0xef, 0x60, 0x71, 0x3b, 0x44, 0xda, 0xe9, 0xd7, 0x47, 0xf1, 0x6f, 0xa2, 0x7b, 0xfe, 0x45, 0x45, 0xf7, 0x1f, + 0xa1, 0x96, 0xd9, 0x00, 0xfe, 0x1b, 0x56, 0x23, 0x0b, 0xfa, 0xad, 0x83, 0xc5, 0x6d, 0x0b, 0x34, 0x85, 0xde, 0xfe, + 0xe2, 0xb6, 0xf5, 0x97, 0x7e, 0xbf, 0x7f, 0x40, 0xfb, 0x2d, 0x78, 0x36, 0xbf, 0xfb, 0xfd, 0xfe, 0xfe, 0x23, 0xda, + 0xc7, 0x4a, 0x8f, 0xab, 0xb2, 0xc1, 0xec, 0xc1, 0x65, 0xa0, 0xc8, 0xd8, 0x70, 0x42, 0xf2, 0x9f, 0x0d, 0x64, 0x13, + 0x98, 0xcd, 0x4f, 0x59, 0x7b, 0x8d, 0x06, 0x7c, 0x19, 0x5f, 0x5c, 0xf0, 0x69, 0x30, 0xcb, 0x26, 0xcb, 0xe2, 0x3f, + 0x7f, 0x04, 0x8f, 0x2e, 0x66, 0xfe, 0x0c, 0x1e, 0x87, 0x76, 0xb2, 0x03, 0x75, 0xe1, 0xd8, 0xbe, 0xff, 0xe8, 0x1e, + 0xa6, 0xf2, 0xa7, 0x87, 0xf9, 0xaf, 0x0c, 0x4f, 0xcf, 0xc0, 0xa3, 0x4f, 0x87, 0x73, 0x64, 0x7a, 0x1a, 0x1b, 0xa6, + 0xab, 0xf9, 0xba, 0x3e, 0x66, 0xb8, 0xb9, 0xf2, 0x1f, 0x9e, 0xe6, 0x8d, 0xf6, 0x14, 0xcd, 0x6d, 0x1d, 0x6a, 0x55, + 0xf7, 0x13, 0x79, 0xe4, 0x5f, 0xbe, 0x7e, 0x04, 0xff, 0x6d, 0xe8, 0x82, 0x95, 0x6e, 0xf7, 0x73, 0x4d, 0xb7, 0x53, + 0xca, 0xc3, 0x47, 0xd4, 0xc1, 0x2d, 0x9f, 0xcc, 0x66, 0x7f, 0xf8, 0x9b, 0x3f, 0xf2, 0xc1, 0x44, 0x69, 0x61, 0x5b, + 0x3e, 0x78, 0x9a, 0x65, 0x70, 0xd5, 0xfd, 0xc6, 0x17, 0x06, 0x51, 0xd5, 0x47, 0x3f, 0x3b, 0x4a, 0xa8, 0x0a, 0x14, + 0x02, 0x3d, 0xf4, 0x67, 0xa5, 0x87, 0x9e, 0xe4, 0x2c, 0xc2, 0x78, 0x80, 0x88, 0x3e, 0x33, 0x8f, 0x3f, 0x28, 0x9f, + 0xfa, 0x1b, 0x48, 0x54, 0xd4, 0xa7, 0x7f, 0xff, 0x33, 0x5a, 0x29, 0xce, 0xe1, 0x3b, 0x0c, 0xd1, 0xae, 0xf4, 0x52, + 0xcd, 0x9a, 0xb0, 0x79, 0xa7, 0x38, 0xcd, 0xc4, 0xe5, 0x5b, 0x08, 0xa2, 0x00, 0xb3, 0x88, 0x9b, 0xcc, 0x2d, 0x29, + 0xde, 0x66, 0x8b, 0xe5, 0x02, 0xed, 0xd9, 0x3f, 0x98, 0xbc, 0x6e, 0x3a, 0x77, 0x91, 0xf2, 0xbf, 0x68, 0xdb, 0x23, + 0xb8, 0x60, 0xcc, 0x63, 0x7c, 0xcb, 0x6c, 0xa2, 0x60, 0xbe, 0x30, 0xcf, 0x18, 0x81, 0x1e, 0x55, 0xea, 0x2c, 0x30, + 0x5e, 0x05, 0x47, 0x54, 0xb7, 0x36, 0x3d, 0xd3, 0xc9, 0xd8, 0x5f, 0x65, 0xcb, 0x82, 0x3f, 0xcb, 0x6e, 0x94, 0xe7, + 0xd0, 0xa6, 0x68, 0x6f, 0x18, 0xfd, 0xfd, 0x05, 0x00, 0xd8, 0x53, 0x8e, 0xa2, 0x1e, 0x0e, 0x3a, 0x22, 0x9d, 0x4e, + 0xfb, 0x0f, 0xd5, 0x0f, 0x7d, 0x6d, 0x67, 0x2a, 0x3c, 0x63, 0xb9, 0x30, 0xd9, 0x2f, 0xb7, 0x60, 0x40, 0xbf, 0x51, + 0x87, 0x8c, 0xab, 0xb7, 0x70, 0x50, 0x7f, 0xab, 0x6a, 0xee, 0xcc, 0xc4, 0xc7, 0x94, 0xf3, 0x13, 0x93, 0xb6, 0xa0, + 0x36, 0x51, 0x1f, 0xfb, 0xea, 0x59, 0x4e, 0xa8, 0x1d, 0xef, 0xa6, 0xf5, 0x70, 0x0e, 0x88, 0x9c, 0x66, 0x37, 0xe2, + 0x23, 0x78, 0xfe, 0x73, 0x16, 0x45, 0xdb, 0xf1, 0x56, 0x5b, 0xe2, 0x27, 0xf7, 0xbd, 0x8d, 0x10, 0x3b, 0x1d, 0xe6, + 0x4d, 0x52, 0x1e, 0xe7, 0x26, 0xa3, 0xeb, 0x96, 0x3a, 0x44, 0x5f, 0x7a, 0x7e, 0xdf, 0x94, 0xdc, 0x24, 0x69, 0xaa, + 0x13, 0x29, 0xc0, 0x81, 0x55, 0x4c, 0x39, 0xa4, 0x43, 0x56, 0x88, 0xc9, 0x27, 0x51, 0xa3, 0x46, 0x6d, 0x5a, 0xae, + 0x48, 0x9c, 0x90, 0x72, 0xa9, 0x67, 0x54, 0x4f, 0xa8, 0xfa, 0x79, 0xec, 0x4c, 0xd1, 0x9b, 0x6b, 0x9e, 0xa7, 0xf1, + 0x9d, 0x47, 0xca, 0x4c, 0xd8, 0x31, 0xb9, 0x15, 0x2c, 0x31, 0x34, 0x96, 0xda, 0xff, 0xdf, 0xdc, 0xd5, 0x36, 0xb7, + 0x6d, 0x1c, 0xe1, 0xef, 0xfe, 0x15, 0x08, 0xed, 0x28, 0xa4, 0x0d, 0x1c, 0x01, 0xf0, 0x45, 0x10, 0x49, 0x50, 0x49, + 0x9a, 0x64, 0x92, 0x8e, 0x1d, 0xc7, 0xa9, 0xe3, 0x69, 0xeb, 0xf1, 0x18, 0x10, 0x75, 0x14, 0x19, 0x81, 0x00, 0x07, + 0x00, 0x25, 0x39, 0x14, 0xfa, 0x5b, 0xfa, 0x2f, 0xfa, 0x3d, 0xbf, 0xac, 0xb3, 0xbb, 0x77, 0x87, 0x03, 0x08, 0x92, + 0x56, 0x9a, 0x49, 0xfa, 0x41, 0x14, 0x78, 0xb7, 0xb8, 0x37, 0xde, 0xcb, 0xee, 0xde, 0xb3, 0xbb, 0x8d, 0xee, 0x6a, + 0xc1, 0xb2, 0x53, 0xeb, 0x04, 0x67, 0xeb, 0xf0, 0x8a, 0xff, 0xdd, 0xa4, 0xff, 0xff, 0xe8, 0x14, 0xe6, 0xcb, 0x54, + 0x55, 0xf4, 0xd3, 0xfa, 0x23, 0xaa, 0x91, 0xbe, 0x30, 0x1b, 0x27, 0xf3, 0x47, 0x0c, 0xf1, 0xbe, 0x4d, 0x02, 0x5a, + 0xf1, 0x3a, 0xd9, 0xcc, 0x16, 0x68, 0x15, 0xf3, 0xfb, 0xf5, 0x37, 0x87, 0x32, 0x79, 0xf6, 0xd6, 0x7e, 0xa7, 0xba, + 0x5e, 0x4b, 0x2a, 0x47, 0x01, 0xeb, 0xff, 0x1a, 0x42, 0xac, 0xfc, 0x89, 0xc3, 0xb0, 0x3b, 0xf1, 0x84, 0x17, 0x81, + 0x07, 0x6d, 0x43, 0x63, 0x74, 0xc9, 0x4d, 0xeb, 0x48, 0xfa, 0x25, 0x6b, 0xde, 0x81, 0x8b, 0xfa, 0x90, 0x89, 0x68, + 0xe1, 0x9f, 0xd4, 0x36, 0x9c, 0x06, 0xa7, 0xc1, 0x65, 0xa6, 0xb9, 0x3f, 0x9e, 0x89, 0x6c, 0x50, 0x8a, 0xba, 0x6a, + 0xe5, 0xba, 0xc5, 0x4c, 0xc5, 0xae, 0x2f, 0xfc, 0x19, 0x9b, 0x29, 0x6e, 0xfc, 0x31, 0x7c, 0xc2, 0x73, 0x78, 0x47, + 0xc1, 0xfb, 0xcc, 0x94, 0xb6, 0xfe, 0x18, 0xff, 0x99, 0xa9, 0x66, 0xd0, 0x0d, 0xfe, 0xbb, 0x82, 0xc6, 0xce, 0xd3, + 0x5d, 0x75, 0xf0, 0xc8, 0x30, 0x0c, 0x43, 0xf1, 0xe0, 0x86, 0x62, 0xc2, 0x31, 0x1d, 0x19, 0x70, 0xd0, 0xa1, 0x17, + 0xeb, 0x3b, 0x4a, 0x01, 0xde, 0x1c, 0xa1, 0x2e, 0x32, 0x41, 0x04, 0xe1, 0x80, 0x4b, 0x7f, 0x4a, 0x90, 0x32, 0x33, + 0xdc, 0x4c, 0x86, 0x29, 0xc4, 0x7a, 0x1a, 0x19, 0x28, 0x13, 0x63, 0xae, 0xd0, 0x29, 0x1a, 0x36, 0x7d, 0x0d, 0xc6, + 0x69, 0x73, 0xbc, 0x86, 0xa5, 0xb6, 0xd3, 0x81, 0x66, 0xba, 0x12, 0x91, 0x01, 0xfd, 0xd4, 0xec, 0x6e, 0xbc, 0x28, + 0xd2, 0xdc, 0xe5, 0x2b, 0x1e, 0x6f, 0x02, 0x13, 0x3d, 0x9b, 0x42, 0xe8, 0x0a, 0xa0, 0xf9, 0x8a, 0xf8, 0xb5, 0x36, + 0x05, 0xf2, 0x6b, 0x78, 0x73, 0x41, 0x0c, 0x41, 0x35, 0x60, 0x07, 0x9c, 0x4b, 0x63, 0x31, 0xf4, 0xbe, 0xb2, 0xb1, + 0x12, 0x96, 0x57, 0xfc, 0xd6, 0x10, 0xba, 0x16, 0x39, 0xa0, 0x71, 0x4d, 0x95, 0x92, 0xea, 0x10, 0x17, 0x41, 0x2b, + 0x2a, 0xda, 0x25, 0x5e, 0xee, 0x6b, 0xda, 0x35, 0xff, 0x40, 0xfb, 0x39, 0x75, 0xe8, 0x9a, 0x03, 0x08, 0x2c, 0xf8, + 0x1a, 0xd4, 0x0a, 0xc1, 0xfe, 0x93, 0x11, 0xca, 0x42, 0xae, 0xf8, 0xe0, 0xbc, 0xb6, 0x8b, 0x03, 0x5b, 0x6b, 0xd3, + 0xfc, 0x96, 0x4e, 0xb2, 0xf5, 0xe3, 0xb2, 0x8a, 0x5a, 0x13, 0xd6, 0x7c, 0xb5, 0xf7, 0xa4, 0x47, 0xc0, 0x7c, 0x5f, + 0xfe, 0x6a, 0x19, 0x03, 0xce, 0x68, 0x5f, 0x6e, 0x78, 0xd7, 0xb1, 0x72, 0x40, 0x1a, 0x4d, 0xed, 0xf3, 0x36, 0xb7, + 0xf2, 0xce, 0x53, 0xc7, 0xb6, 0xbb, 0xf1, 0xc8, 0x36, 0x97, 0xbe, 0x63, 0x5b, 0xe9, 0x53, 0xe6, 0x8e, 0x77, 0x1a, + 0x46, 0x51, 0x5e, 0x28, 0xde, 0x6e, 0x00, 0x4e, 0x5a, 0xdb, 0x60, 0x05, 0xf9, 0xa9, 0xf1, 0xcc, 0x68, 0x83, 0xed, + 0xea, 0xfa, 0xae, 0xd3, 0x09, 0x8a, 0x24, 0xc6, 0x21, 0xa1, 0x1f, 0x41, 0x6e, 0x63, 0x95, 0x03, 0x4a, 0xce, 0x04, + 0x1d, 0x65, 0x79, 0xf8, 0x44, 0xc2, 0x12, 0xc9, 0x53, 0x77, 0xb5, 0x5c, 0x88, 0x30, 0x85, 0xa6, 0xf4, 0xf5, 0x1e, + 0x9e, 0x4b, 0x60, 0x6b, 0x49, 0xb1, 0xff, 0x96, 0xa8, 0x59, 0xb7, 0xc7, 0x8f, 0xeb, 0xf6, 0xf2, 0x63, 0xba, 0x3d, + 0xb2, 0x79, 0x15, 0x60, 0x27, 0x69, 0xd3, 0x2b, 0xf9, 0xcd, 0xfb, 0x7b, 0xcd, 0xb0, 0x57, 0x57, 0x08, 0xa2, 0x89, + 0x6c, 0x03, 0x44, 0x8a, 0x4a, 0xc3, 0x8e, 0x91, 0xe9, 0x63, 0xc9, 0x6a, 0xb7, 0xa6, 0xa4, 0xc9, 0xfb, 0x5c, 0xf1, + 0x2b, 0x4a, 0xd9, 0xb7, 0xe7, 0x40, 0x07, 0xad, 0x20, 0x12, 0x6f, 0xd6, 0x75, 0xd2, 0xea, 0x91, 0x0c, 0x84, 0x78, + 0x78, 0xe1, 0xed, 0x8e, 0x46, 0xdb, 0x7c, 0x70, 0x2a, 0x72, 0x1e, 0x5f, 0xd6, 0x89, 0x6b, 0xa7, 0x1c, 0x2a, 0x26, + 0xcb, 0x2d, 0x46, 0x78, 0xfe, 0x69, 0xd8, 0x63, 0xd4, 0xdd, 0xa4, 0x3e, 0x8f, 0x0a, 0xa5, 0x8b, 0xc4, 0x4b, 0x42, + 0x5d, 0x75, 0xfa, 0x75, 0xa9, 0x3a, 0x25, 0xe3, 0x72, 0x65, 0x3e, 0xaa, 0x38, 0x79, 0xcd, 0x34, 0x5a, 0x71, 0xfa, + 0xa5, 0x89, 0x74, 0xf9, 0x13, 0x69, 0x96, 0xe2, 0x1a, 0x47, 0x55, 0x5a, 0x4f, 0x4b, 0x89, 0x41, 0x52, 0x92, 0xc5, + 0x78, 0x95, 0xb4, 0xb4, 0x19, 0x2e, 0xd3, 0xa1, 0xef, 0xd8, 0x64, 0x6d, 0x8c, 0xca, 0x85, 0x53, 0x73, 0xad, 0xa0, + 0x65, 0x6b, 0xab, 0x40, 0xd9, 0x9b, 0xd2, 0xcc, 0x92, 0x5a, 0xdc, 0xda, 0x65, 0x9e, 0x1a, 0x3b, 0x6c, 0x64, 0x83, + 0x31, 0xf9, 0x31, 0xe5, 0x2d, 0x45, 0x6f, 0xa4, 0x8b, 0x2e, 0xed, 0x6e, 0xcf, 0x81, 0x03, 0x4a, 0x17, 0xca, 0x71, + 0xa4, 0xdf, 0x6d, 0x1b, 0x4e, 0x2b, 0x3c, 0xac, 0xea, 0xdf, 0x71, 0x8e, 0x58, 0x84, 0x54, 0xa5, 0x14, 0x2d, 0x8a, + 0x9a, 0x6d, 0x48, 0x1d, 0x2e, 0x61, 0xcb, 0xe8, 0x8c, 0x03, 0x95, 0x99, 0x61, 0xef, 0xd6, 0x49, 0xea, 0x8a, 0xad, + 0xb0, 0x41, 0xc3, 0xc2, 0x1a, 0x88, 0x46, 0xb2, 0x65, 0x62, 0x7d, 0xa5, 0x9b, 0x38, 0x06, 0x31, 0xd7, 0xca, 0xd3, + 0x70, 0x76, 0xbd, 0xad, 0x2a, 0x98, 0xc7, 0x21, 0x86, 0xad, 0xe0, 0x23, 0xe6, 0x66, 0x7a, 0xc3, 0x1e, 0xdb, 0xbd, + 0xf0, 0x6c, 0xde, 0xaf, 0x69, 0xf8, 0xdc, 0x52, 0xe5, 0x88, 0xed, 0x15, 0x2a, 0xbe, 0x7e, 0xd3, 0x00, 0x8d, 0x46, + 0xd6, 0x2a, 0xf9, 0x45, 0x58, 0xc3, 0xff, 0xf1, 0x55, 0x67, 0xc7, 0xeb, 0xd4, 0x14, 0x2f, 0xf5, 0xdf, 0x44, 0xd4, + 0xad, 0x53, 0x3c, 0xa8, 0xee, 0xf9, 0x32, 0x8a, 0xac, 0x08, 0x60, 0xcb, 0xdb, 0x8f, 0xea, 0xd9, 0xc1, 0x72, 0x36, + 0x10, 0xeb, 0xeb, 0x7f, 0x28, 0xa7, 0x3a, 0x1d, 0xf2, 0xc5, 0x66, 0x75, 0x51, 0x1f, 0x96, 0x7d, 0x93, 0x59, 0xaf, + 0x74, 0x3e, 0xaf, 0xdf, 0x67, 0x1e, 0x50, 0xf8, 0xd2, 0x4c, 0xb6, 0x50, 0x21, 0xeb, 0xad, 0xef, 0xaa, 0x3a, 0x50, + 0xdb, 0xe8, 0x0b, 0xc5, 0xe6, 0xb1, 0x69, 0xd3, 0xd4, 0xd6, 0xe6, 0x36, 0x89, 0xf6, 0x7e, 0x6c, 0xfb, 0x1e, 0xd4, + 0x9e, 0xec, 0xff, 0xa2, 0x21, 0xb8, 0xf8, 0x8f, 0xad, 0xee, 0xdd, 0x59, 0x72, 0xa0, 0xa4, 0xfa, 0xfa, 0x7c, 0xd8, + 0xcb, 0x47, 0x66, 0xf9, 0x47, 0xbc, 0xba, 0x6f, 0x62, 0x17, 0xac, 0xe4, 0x27, 0xb6, 0x84, 0xbd, 0x58, 0xe6, 0x7c, + 0x95, 0x8d, 0x66, 0x1c, 0x07, 0xbe, 0x0a, 0xfc, 0xd0, 0xd8, 0x08, 0xdc, 0xbd, 0xad, 0x2b, 0x40, 0xa2, 0x38, 0x72, + 0x33, 0xb5, 0x0d, 0xbc, 0x28, 0x69, 0xb8, 0xe2, 0xd0, 0xd8, 0x8c, 0xed, 0x9e, 0xbb, 0x84, 0x81, 0xfd, 0x69, 0x85, + 0xce, 0x80, 0x93, 0x58, 0x87, 0x91, 0x88, 0x16, 0x95, 0x7a, 0xf0, 0xe3, 0x3b, 0x99, 0x7e, 0x57, 0x73, 0xa6, 0x01, + 0x02, 0xf0, 0x6e, 0x40, 0x47, 0x04, 0x38, 0x70, 0x91, 0xa1, 0xe3, 0x59, 0x60, 0x21, 0x55, 0x23, 0x03, 0xef, 0x36, + 0x1b, 0x05, 0x2f, 0x98, 0x6f, 0xa5, 0xae, 0x1a, 0x9f, 0x20, 0xcc, 0x40, 0x1b, 0xfa, 0x63, 0x7a, 0x70, 0x73, 0xf1, + 0x39, 0xfe, 0xf8, 0x52, 0x50, 0x32, 0x36, 0x69, 0x64, 0x51, 0xac, 0xdc, 0x76, 0x67, 0xdb, 0xd0, 0xe1, 0x7d, 0x65, + 0x39, 0x03, 0x28, 0x6c, 0x77, 0x88, 0xa4, 0x2e, 0x5d, 0xbb, 0x2b, 0x12, 0xab, 0xc6, 0x12, 0x8e, 0xaa, 0xf5, 0x55, + 0x02, 0x43, 0x0d, 0x16, 0xf7, 0x12, 0x3e, 0x51, 0x1d, 0x36, 0xea, 0x91, 0x96, 0x8b, 0xfb, 0xb5, 0x18, 0x52, 0x1c, + 0x98, 0x7a, 0x66, 0xfd, 0x56, 0xb4, 0xb2, 0x1b, 0x39, 0xe5, 0xee, 0x84, 0x25, 0x5b, 0x95, 0xd9, 0x51, 0xf9, 0xf9, + 0x71, 0xb3, 0x97, 0x03, 0x7a, 0x00, 0x2a, 0xf1, 0x4a, 0x57, 0x2a, 0x0b, 0x2b, 0xab, 0x06, 0x35, 0xf4, 0x9e, 0x17, + 0x56, 0xcb, 0x66, 0x5d, 0xfa, 0x3e, 0xf2, 0xf0, 0xee, 0x21, 0xe4, 0xc0, 0xef, 0x1d, 0xd1, 0xa2, 0x57, 0xe8, 0x81, + 0x67, 0xdc, 0xc5, 0x6d, 0xbc, 0xaa, 0xa9, 0xcd, 0x15, 0x73, 0x5a, 0x92, 0xbe, 0xd2, 0x54, 0xe7, 0xba, 0x0b, 0x1c, + 0x50, 0xa0, 0xbf, 0x22, 0x05, 0xfa, 0x75, 0x5a, 0xd3, 0x8f, 0xff, 0xc2, 0x2b, 0x0a, 0x72, 0x72, 0x62, 0x46, 0x0a, + 0x72, 0xa5, 0x1d, 0xcf, 0xfd, 0x6b, 0x93, 0x90, 0x78, 0x9f, 0xf8, 0xfe, 0x73, 0xce, 0xfe, 0xf2, 0xed, 0x77, 0xcf, + 0xbf, 0xaa, 0x78, 0x06, 0x17, 0xd7, 0xf8, 0xaa, 0x1c, 0x76, 0xb9, 0x4c, 0x39, 0xde, 0x08, 0x41, 0x5c, 0xc7, 0x67, + 0x41, 0xbb, 0x63, 0xcc, 0xc2, 0xd8, 0x48, 0xe2, 0xe8, 0x83, 0x71, 0xc1, 0x0d, 0x90, 0x1b, 0x30, 0x44, 0x2a, 0x68, + 0x04, 0x8c, 0x8b, 0x25, 0x3a, 0xe9, 0xce, 0x02, 0x25, 0xe2, 0x88, 0x00, 0xd9, 0xbe, 0xef, 0x5f, 0xdf, 0xdf, 0x73, + 0x0a, 0x37, 0x52, 0xb3, 0xb2, 0x13, 0xc6, 0x4b, 0xaa, 0x85, 0x14, 0xdf, 0xcb, 0xf7, 0xfd, 0x97, 0x92, 0x90, 0x8f, + 0xab, 0x91, 0xdd, 0x45, 0xfc, 0xe9, 0x87, 0xb7, 0x3b, 0x8a, 0xf8, 0xa5, 0x71, 0xbb, 0xcc, 0x17, 0x46, 0x08, 0xca, + 0x10, 0x8b, 0x0a, 0x32, 0x84, 0x62, 0x54, 0xd6, 0x2b, 0x1a, 0x52, 0x6b, 0xe6, 0xb8, 0x6c, 0x1f, 0x49, 0x84, 0x95, + 0x88, 0x26, 0x69, 0x78, 0xab, 0x82, 0xdc, 0xe4, 0xfe, 0xf6, 0xfd, 0x93, 0x68, 0x99, 0x03, 0xb4, 0xfb, 0xc9, 0x68, + 0xa7, 0x61, 0x29, 0xcf, 0x36, 0x11, 0x66, 0x9a, 0x54, 0x3f, 0x44, 0xfd, 0xc1, 0x26, 0x64, 0xe0, 0x1a, 0xb8, 0x28, + 0xc6, 0xd7, 0xb5, 0xd6, 0xfb, 0xc1, 0x26, 0xce, 0xc2, 0x39, 0xc6, 0x73, 0x0d, 0xcc, 0x6b, 0xbd, 0x08, 0xdf, 0xc1, + 0xc9, 0xf0, 0x45, 0xea, 0xff, 0xc8, 0xdb, 0xd7, 0x69, 0xc7, 0xfc, 0x39, 0xf5, 0x83, 0xc9, 0xf9, 0xdd, 0x2a, 0x32, + 0x6e, 0x78, 0x9a, 0x81, 0x77, 0xe1, 0x96, 0xc3, 0xec, 0x96, 0x81, 0x30, 0xf2, 0x65, 0x7c, 0xe5, 0xb7, 0x7e, 0x7a, + 0xfd, 0x8d, 0xe5, 0xb5, 0xce, 0x01, 0xc6, 0x71, 0x73, 0x85, 0xb2, 0xcf, 0xf3, 0xf0, 0x03, 0x4f, 0xdf, 0xbb, 0xc2, + 0xc0, 0x83, 0xa4, 0x1e, 0x4c, 0x33, 0xdc, 0x96, 0x71, 0xb7, 0x8a, 0xe2, 0xcc, 0x6f, 0x2d, 0xf2, 0x7c, 0x3d, 0xea, + 0x76, 0x6f, 0x6f, 0x6f, 0xd9, 0x6d, 0x8f, 0x25, 0xe9, 0x55, 0xd7, 0xb5, 0x6d, 0xbb, 0x0b, 0x01, 0x76, 0x8d, 0x9b, + 0x25, 0xbf, 0xfd, 0x32, 0xb9, 0xf3, 0x5b, 0x70, 0xe8, 0x3a, 0xae, 0x67, 0x38, 0x6e, 0x9f, 0x0d, 0xbd, 0xd6, 0xf4, + 0x91, 0x61, 0x4c, 0x2e, 0xf9, 0x3c, 0x9b, 0xa2, 0x96, 0x69, 0x82, 0x82, 0x02, 0x3d, 0x1b, 0x06, 0x9b, 0x45, 0x99, + 0xe5, 0x18, 0x5b, 0xf1, 0xd5, 0x30, 0xe0, 0x14, 0x1b, 0x19, 0x8f, 0xe7, 0xee, 0xbc, 0x3f, 0x3f, 0x1b, 0x8b, 0xe4, + 0xe2, 0x51, 0x85, 0xdc, 0xa4, 0xff, 0xae, 0xf6, 0x5a, 0x96, 0xa7, 0xc9, 0x35, 0x17, 0xf2, 0x85, 0xa1, 0xf4, 0x5f, + 0xf5, 0x57, 0xdd, 0xdd, 0x9a, 0x1c, 0xef, 0x62, 0x36, 0x77, 0x4b, 0x72, 0x6c, 0x63, 0x57, 0x35, 0x72, 0xd2, 0x95, + 0x4d, 0x9f, 0xe8, 0xc3, 0xe4, 0x58, 0x4d, 0x03, 0xe5, 0xb4, 0x44, 0x1f, 0xaf, 0x64, 0xff, 0x26, 0x10, 0xc4, 0xa5, + 0xb4, 0x81, 0xcb, 0xf0, 0x35, 0xbf, 0xf5, 0xc2, 0x71, 0x3d, 0xd3, 0x71, 0x86, 0x6c, 0xe8, 0xcd, 0x6c, 0xb3, 0xcf, + 0xfa, 0x56, 0x8f, 0x0d, 0x4d, 0xcf, 0xf2, 0x4c, 0xef, 0x5b, 0x6f, 0x66, 0xf5, 0x59, 0xdf, 0xb4, 0x2d, 0x0f, 0x12, + 0x2d, 0xcf, 0xf2, 0x6e, 0xac, 0xbe, 0x37, 0xb3, 0x31, 0xd5, 0x65, 0x83, 0x81, 0xe5, 0xd8, 0x6c, 0x30, 0x30, 0x07, + 0x6c, 0x38, 0xb4, 0x9c, 0x1e, 0x1b, 0x0e, 0x9f, 0x0f, 0x3c, 0xd6, 0x83, 0xbc, 0x5e, 0x6f, 0xd6, 0x63, 0x8e, 0x63, + 0xc1, 0x87, 0xe9, 0x31, 0x97, 0x1e, 0x1c, 0x87, 0xf5, 0x1c, 0xd3, 0x8e, 0x06, 0x2e, 0x1b, 0x9e, 0x99, 0xf8, 0x89, + 0x64, 0x26, 0x7e, 0x40, 0x31, 0xe6, 0x19, 0x73, 0x87, 0xf4, 0x84, 0x05, 0xde, 0xf4, 0xbd, 0x7f, 0xb6, 0xba, 0x7b, + 0xfb, 0xe0, 0x50, 0x1f, 0xbc, 0x01, 0xeb, 0xf5, 0xcc, 0xbe, 0xc3, 0xbc, 0xde, 0xc2, 0xea, 0xbb, 0x6c, 0x78, 0x3a, + 0xb3, 0x1c, 0x76, 0x7a, 0x6a, 0xda, 0x56, 0x8f, 0xb9, 0xa6, 0xc3, 0xfa, 0x3d, 0x7c, 0xe8, 0x31, 0xf7, 0xe6, 0xf4, + 0x8c, 0x0d, 0x07, 0x8b, 0x21, 0xeb, 0xbf, 0xe9, 0x7b, 0xcc, 0xed, 0x2d, 0x7a, 0x43, 0xe6, 0x9e, 0xde, 0x0c, 0x59, + 0x7f, 0x61, 0xb9, 0xc3, 0x83, 0x6f, 0x3a, 0x2e, 0x83, 0x31, 0xc2, 0x6c, 0xc8, 0x30, 0x45, 0x06, 0xfc, 0x2d, 0xf0, + 0xdd, 0x3f, 0xb0, 0x98, 0x6c, 0xf7, 0xd5, 0x33, 0xe6, 0x9d, 0xce, 0x88, 0x1c, 0x12, 0x2c, 0x49, 0x01, 0xaf, 0xdc, + 0x58, 0x54, 0x2d, 0x16, 0x67, 0xc9, 0x82, 0xe4, 0x9f, 0xa8, 0xec, 0xc6, 0x82, 0x8a, 0xa9, 0xde, 0x3f, 0xb5, 0x1c, + 0xf5, 0x93, 0x4f, 0xba, 0x57, 0x34, 0xf5, 0xaf, 0xa6, 0x8f, 0x26, 0xb0, 0xb8, 0xa7, 0x81, 0xf9, 0xa2, 0x7e, 0xd0, + 0xa8, 0x40, 0x31, 0x42, 0x07, 0x02, 0xd2, 0xbf, 0x2f, 0x45, 0xfe, 0x0a, 0x4b, 0x55, 0x64, 0x37, 0x57, 0xdb, 0x5d, + 0x59, 0x0f, 0x9f, 0xab, 0x84, 0xc1, 0x8e, 0x4e, 0xec, 0x8b, 0xb4, 0xfd, 0x33, 0xc4, 0xe4, 0x1d, 0xbf, 0x48, 0xab, + 0x60, 0xc6, 0x04, 0x0e, 0xc1, 0x17, 0x29, 0x9d, 0x82, 0xdf, 0xa7, 0x7e, 0x12, 0x30, 0xc1, 0xa9, 0x2e, 0x2f, 0xad, + 0x45, 0x18, 0xcd, 0xb7, 0xf8, 0x04, 0xae, 0x1a, 0x80, 0xb7, 0x02, 0xb9, 0x73, 0xb3, 0x8a, 0x33, 0x80, 0xac, 0x02, + 0x32, 0x64, 0x5e, 0xb2, 0xbc, 0x40, 0x57, 0xd4, 0x5e, 0x66, 0xd2, 0xe7, 0xea, 0x7b, 0x61, 0xd2, 0xb9, 0x37, 0x1f, + 0xe1, 0xaa, 0xcd, 0x55, 0x39, 0xf3, 0xb4, 0x5e, 0xae, 0x01, 0xd8, 0x38, 0x89, 0xe5, 0x05, 0x1c, 0x56, 0x53, 0x7e, + 0x15, 0x66, 0xba, 0x03, 0x31, 0x3e, 0xd4, 0x12, 0x7a, 0x1f, 0x6f, 0x62, 0xa9, 0x84, 0xfd, 0x0d, 0xa7, 0x8e, 0x35, + 0x54, 0xa8, 0xe3, 0x5a, 0xf7, 0x42, 0x62, 0x55, 0xa9, 0xf5, 0x0a, 0x6a, 0x3f, 0x7d, 0x63, 0xff, 0xcb, 0xb9, 0x50, + 0xe2, 0x66, 0x4b, 0xd9, 0xc2, 0x36, 0x80, 0x71, 0xd5, 0x72, 0x2a, 0x25, 0xea, 0x48, 0xdb, 0xa7, 0x5b, 0x14, 0xf5, + 0x96, 0xbf, 0x00, 0xaf, 0x2f, 0xd8, 0xd7, 0x8b, 0x44, 0x1f, 0xd4, 0xad, 0x56, 0x2a, 0xc8, 0x86, 0xc5, 0xc2, 0x69, + 0x10, 0x35, 0x76, 0xd4, 0x45, 0x84, 0x86, 0x22, 0xc0, 0x79, 0x0d, 0x2c, 0xef, 0xf0, 0x55, 0x41, 0x26, 0x01, 0x08, + 0xb5, 0x3f, 0x54, 0x98, 0xa4, 0x7b, 0x0c, 0xd3, 0x55, 0x18, 0x7d, 0x19, 0xba, 0x4b, 0xa3, 0xed, 0x3c, 0x4a, 0xc2, + 0x7c, 0x84, 0x1c, 0xf7, 0xb8, 0x06, 0x87, 0xd3, 0xa4, 0x16, 0x97, 0x40, 0xf4, 0x7a, 0x69, 0xe2, 0x4d, 0x44, 0xdc, + 0xef, 0xe0, 0xe8, 0xd4, 0x4d, 0xb5, 0xc2, 0x55, 0xdb, 0x67, 0x97, 0x8e, 0x7d, 0x31, 0x2f, 0xe4, 0xda, 0xd1, 0x5f, + 0xaf, 0x74, 0x8f, 0xaf, 0xb4, 0x7a, 0x45, 0x24, 0x68, 0xf0, 0x20, 0xbe, 0x3a, 0x60, 0x78, 0x30, 0x7e, 0x18, 0x58, + 0xfb, 0xe7, 0x4d, 0x96, 0xc3, 0x00, 0x48, 0x39, 0x06, 0x2d, 0x12, 0xac, 0x0b, 0x9e, 0xdf, 0x72, 0x1e, 0x57, 0xe5, + 0x50, 0xc2, 0xaa, 0x5d, 0xe4, 0xb1, 0xf8, 0x19, 0x25, 0x40, 0xbe, 0x08, 0xc6, 0x15, 0x5b, 0x9e, 0xf2, 0x52, 0xe7, + 0x6f, 0xf8, 0xbd, 0x0d, 0x41, 0xa3, 0x9e, 0x05, 0x5d, 0x92, 0x8b, 0x82, 0x4e, 0x19, 0x6d, 0xed, 0x87, 0xb4, 0xd4, + 0xe5, 0xa3, 0xd2, 0x15, 0xa3, 0x10, 0x71, 0xc5, 0xf4, 0x29, 0xb3, 0x6e, 0x11, 0x0b, 0x31, 0x62, 0x3f, 0x0a, 0xd9, + 0x16, 0x6e, 0x3c, 0xbf, 0x49, 0xd2, 0x55, 0x88, 0xde, 0x93, 0x83, 0x0e, 0x18, 0x5a, 0xc1, 0x17, 0x1b, 0xec, 0xe1, + 0x67, 0x49, 0x7c, 0x29, 0x6e, 0xf1, 0x62, 0xff, 0x2d, 0x09, 0x03, 0xc1, 0x07, 0x1e, 0xa6, 0x81, 0xb9, 0xca, 0x46, + 0x3d, 0xc7, 0xb1, 0xfb, 0x7c, 0x58, 0x98, 0x22, 0x63, 0x95, 0xc4, 0x10, 0xa1, 0x7b, 0x05, 0xfa, 0xa5, 0x33, 0x57, + 0xcb, 0xb8, 0xe5, 0xfc, 0x1a, 0xd3, 0x87, 0x76, 0xdf, 0xe3, 0x03, 0x95, 0x7e, 0x19, 0x7e, 0xc0, 0x64, 0x6f, 0xd8, + 0xd7, 0x52, 0x17, 0xc9, 0x46, 0x94, 0x3f, 0xd4, 0x52, 0x57, 0xcb, 0x78, 0x03, 0x37, 0x12, 0x50, 0x0a, 0xef, 0xab, + 0x64, 0xd1, 0x46, 0x48, 0x76, 0x78, 0xaf, 0x78, 0x67, 0xa6, 0x00, 0x3d, 0x59, 0xfa, 0x47, 0xfb, 0x69, 0x86, 0xbe, + 0xad, 0xfc, 0xd2, 0x27, 0xe0, 0x97, 0x3e, 0x96, 0x8e, 0xce, 0x70, 0x00, 0xf3, 0x74, 0x13, 0xcf, 0xda, 0xf8, 0x18, + 0x5e, 0x64, 0x6d, 0xde, 0x4d, 0xd8, 0x2a, 0xeb, 0xe0, 0x80, 0xc6, 0x53, 0x9b, 0x48, 0xc1, 0xa6, 0x4d, 0x0c, 0x57, + 0xfc, 0x34, 0x37, 0x13, 0x14, 0x3d, 0x68, 0xcc, 0x2d, 0x3f, 0x7e, 0x0a, 0x6f, 0x3c, 0xcd, 0xcd, 0xf4, 0x99, 0x0f, + 0x31, 0x71, 0xed, 0x93, 0x93, 0x44, 0xc8, 0x26, 0xb2, 0xd5, 0xe7, 0x59, 0xe9, 0xdd, 0xd7, 0x08, 0xaf, 0x12, 0x72, + 0xf0, 0x3b, 0xca, 0xcc, 0xf0, 0xd9, 0xb3, 0xa9, 0xef, 0x74, 0x28, 0xfa, 0xb4, 0xf4, 0x0e, 0x99, 0x62, 0x9c, 0xb3, + 0x27, 0x07, 0x71, 0x43, 0x2a, 0x12, 0x79, 0xa3, 0xf5, 0xe0, 0x1a, 0x38, 0x64, 0x5b, 0xc2, 0xd2, 0xeb, 0x11, 0xc0, + 0xc1, 0xb2, 0x83, 0x50, 0x15, 0x92, 0xe6, 0xfd, 0x22, 0xcc, 0xfe, 0x9a, 0x25, 0xf1, 0x4f, 0x6b, 0xf0, 0xbd, 0x55, + 0x82, 0x84, 0x04, 0xeb, 0x1d, 0xf4, 0x98, 0xcd, 0x6c, 0x05, 0x73, 0x87, 0xc0, 0x3b, 0xfe, 0x36, 0xc9, 0x43, 0x08, + 0x53, 0x1f, 0x25, 0x57, 0x60, 0x41, 0x94, 0x2f, 0xf3, 0x08, 0x22, 0x94, 0x83, 0x29, 0x11, 0x68, 0x0f, 0x28, 0x58, + 0x39, 0x5e, 0x5b, 0x84, 0x29, 0xc4, 0x36, 0x4d, 0x3f, 0xc8, 0xf0, 0x80, 0xe8, 0x61, 0xf3, 0x05, 0xec, 0xca, 0xed, + 0xa0, 0x0d, 0x0a, 0x06, 0x9e, 0x66, 0x96, 0x6e, 0x56, 0x31, 0x32, 0xe0, 0x9d, 0x4e, 0x20, 0xfa, 0x36, 0x4f, 0xc3, + 0x15, 0xc4, 0x66, 0xdb, 0x16, 0xa6, 0xd8, 0x0f, 0xc0, 0xe5, 0x50, 0xd8, 0xb6, 0x4d, 0xc3, 0x39, 0x1b, 0x9a, 0x86, + 0xeb, 0x98, 0x86, 0xcd, 0x4e, 0x07, 0x9d, 0xa0, 0x30, 0xb7, 0x45, 0xd5, 0x64, 0x92, 0xbc, 0x9e, 0xbf, 0x0e, 0x2f, + 0xa4, 0xbd, 0x94, 0x8f, 0xc0, 0x85, 0xf6, 0x0e, 0x28, 0xa7, 0x76, 0xc3, 0x0f, 0x7e, 0xd0, 0x6b, 0x3b, 0x7f, 0xd0, + 0xe9, 0x1c, 0xf2, 0x6d, 0x2e, 0x8e, 0xa3, 0xa0, 0x16, 0xbd, 0xe9, 0x79, 0x72, 0xf5, 0x87, 0xd4, 0x8e, 0x76, 0x13, + 0x9d, 0x62, 0x7c, 0x18, 0xb8, 0x90, 0xcd, 0xd2, 0xe5, 0x3a, 0x7f, 0x4c, 0x3f, 0x21, 0x20, 0xa7, 0x60, 0xf7, 0x17, + 0x26, 0xbc, 0x2a, 0xb0, 0x2d, 0x44, 0x86, 0x44, 0x82, 0x76, 0x25, 0x86, 0x38, 0x06, 0xcb, 0x16, 0x19, 0xbc, 0xb3, + 0x45, 0x43, 0xc3, 0x65, 0x6c, 0xf0, 0xfb, 0xfb, 0x36, 0x07, 0x9b, 0x17, 0x5f, 0x9b, 0x1d, 0xf0, 0xbd, 0x53, 0x99, + 0x2e, 0xbc, 0xbc, 0x80, 0xc7, 0xa9, 0x02, 0x17, 0xa1, 0xf0, 0x1f, 0xc2, 0xba, 0x85, 0xf1, 0xd5, 0xc9, 0x49, 0x5b, + 0xe5, 0xcb, 0x07, 0x81, 0x67, 0xc0, 0x7c, 0x9f, 0xc8, 0x3a, 0x3b, 0x18, 0x2d, 0x42, 0x37, 0xd5, 0x52, 0x85, 0x64, + 0xbb, 0x0f, 0x1f, 0xb1, 0xe2, 0x79, 0x18, 0x80, 0x63, 0x09, 0x42, 0xb5, 0x81, 0xd8, 0x07, 0x27, 0x72, 0x60, 0xe6, + 0x4c, 0xec, 0xe9, 0x7e, 0x80, 0x87, 0xa0, 0x4f, 0x31, 0x07, 0x48, 0x28, 0x33, 0x0d, 0x71, 0x9c, 0x58, 0x88, 0xf3, + 0xf4, 0x1d, 0x93, 0x70, 0xfa, 0xb3, 0x30, 0x02, 0x5d, 0xab, 0x1f, 0x27, 0x41, 0xd9, 0x47, 0x38, 0xea, 0x2a, 0x20, + 0x83, 0x5c, 0x6e, 0xae, 0xfb, 0x7e, 0x9a, 0x68, 0x19, 0x5f, 0xbf, 0x4d, 0x79, 0xf4, 0x2f, 0xff, 0x33, 0x38, 0x59, + 0x3f, 0x03, 0xab, 0xf7, 0x18, 0xe3, 0x63, 0x2c, 0x52, 0x3e, 0xf7, 0xd1, 0x24, 0x7b, 0x84, 0xe0, 0x59, 0xe0, 0x67, + 0x9f, 0xdd, 0xad, 0x22, 0x13, 0x05, 0x5f, 0x6a, 0x68, 0xab, 0xe7, 0x96, 0xce, 0x07, 0x7b, 0x1f, 0x25, 0xee, 0x4e, + 0x85, 0x1c, 0x0b, 0xb2, 0xd1, 0xb6, 0x22, 0x7d, 0x3a, 0x63, 0x94, 0x2c, 0x2f, 0xa2, 0x70, 0x76, 0x3d, 0xa6, 0x9c, + 0xca, 0x17, 0x0b, 0x4e, 0xdc, 0x59, 0xb8, 0x1e, 0xe1, 0x69, 0xaa, 0x27, 0x82, 0x6d, 0x30, 0xa5, 0x2a, 0xbe, 0xab, + 0x71, 0x81, 0xe3, 0xfa, 0xde, 0x62, 0xcd, 0x58, 0xd5, 0xed, 0x62, 0x99, 0x73, 0x59, 0x15, 0x7e, 0x29, 0x0a, 0x29, + 0xc2, 0x92, 0xf0, 0x86, 0x22, 0x27, 0xeb, 0x19, 0x8e, 0xf7, 0xed, 0xe0, 0xc6, 0xb1, 0x17, 0xae, 0xc3, 0xbc, 0x37, + 0x8e, 0xb7, 0xe8, 0xb1, 0xd3, 0xc8, 0xea, 0xb1, 0x53, 0xf8, 0x7b, 0x73, 0xca, 0xbc, 0x85, 0xe5, 0xb2, 0xfe, 0x1b, + 0xc7, 0x8d, 0x2c, 0x8f, 0x9d, 0xc2, 0xdf, 0x73, 0x7a, 0x0b, 0x44, 0x03, 0x21, 0x09, 0x54, 0xb7, 0x4c, 0xed, 0x59, + 0xdd, 0xb9, 0x56, 0x0d, 0x6d, 0x1b, 0x60, 0x14, 0xb0, 0xbf, 0x12, 0x86, 0x02, 0xa3, 0xb3, 0x63, 0x68, 0x6a, 0x69, + 0x00, 0x7d, 0x20, 0x3e, 0x1b, 0x4d, 0x79, 0xcd, 0xd5, 0x6d, 0xbb, 0xb6, 0xe0, 0xf6, 0x45, 0x52, 0x33, 0x73, 0xb6, + 0xa1, 0xad, 0x59, 0xf9, 0xc8, 0xa1, 0x4d, 0x86, 0xa0, 0x03, 0xb4, 0x6d, 0x43, 0x40, 0x8b, 0x76, 0xe3, 0x76, 0x2e, + 0x77, 0xf9, 0x8c, 0xe7, 0x82, 0x54, 0x96, 0xf7, 0xd4, 0xe1, 0xbd, 0x4e, 0xa7, 0x80, 0x60, 0x9e, 0x46, 0x63, 0x89, + 0xe3, 0xfa, 0x89, 0x01, 0x96, 0xdc, 0x2c, 0x4e, 0x6e, 0x11, 0x16, 0x72, 0x6c, 0x9c, 0xd0, 0x18, 0x99, 0xab, 0xe0, + 0x77, 0x95, 0x66, 0xc9, 0xe8, 0x82, 0xb5, 0x0a, 0x77, 0x8e, 0xa8, 0x07, 0x55, 0x28, 0xd0, 0x0c, 0xaa, 0xca, 0xdf, + 0x5a, 0x8e, 0xf0, 0x31, 0x50, 0xa2, 0xdc, 0xb4, 0x53, 0xd4, 0x69, 0x8e, 0xf3, 0x24, 0xa3, 0x78, 0x0a, 0xca, 0x65, + 0x12, 0x2b, 0xd0, 0x1c, 0x86, 0x99, 0xbe, 0x09, 0xa3, 0x76, 0x63, 0x79, 0x9f, 0xa8, 0x23, 0xfb, 0xe4, 0xa4, 0x6c, + 0xa4, 0x55, 0x6b, 0xff, 0xc4, 0x19, 0xf0, 0x5e, 0x61, 0x0e, 0x78, 0xef, 0x20, 0x5c, 0xf4, 0x78, 0x5c, 0x8c, 0x83, + 0xc7, 0xe3, 0xc1, 0xb2, 0x8f, 0x18, 0x14, 0xef, 0x3f, 0xf6, 0x7e, 0x1b, 0x36, 0xb5, 0x71, 0x38, 0xb5, 0xc5, 0x83, + 0x90, 0x3f, 0x35, 0xb4, 0x8d, 0xd4, 0xc7, 0x00, 0xae, 0xbf, 0xdf, 0x68, 0xed, 0xb3, 0xc5, 0xff, 0xad, 0x03, 0x56, + 0xdb, 0x91, 0x2a, 0xd6, 0x7e, 0x8a, 0xa3, 0x22, 0x56, 0x8a, 0x67, 0xe7, 0x01, 0x24, 0x05, 0xa3, 0x00, 0x2d, 0xca, + 0x02, 0x85, 0x78, 0x55, 0xe7, 0x63, 0x99, 0x60, 0x0a, 0x10, 0xad, 0x30, 0xc6, 0xec, 0x9c, 0x9c, 0xec, 0x3d, 0x77, + 0x09, 0xf0, 0x94, 0xf1, 0x5c, 0xc5, 0xec, 0x0e, 0xf4, 0x4d, 0x3c, 0xd0, 0xb7, 0x51, 0x55, 0x2e, 0xee, 0x8c, 0x12, + 0x7e, 0x4d, 0x73, 0x1a, 0x1f, 0x2f, 0x78, 0x98, 0x33, 0x71, 0xd1, 0xde, 0xd6, 0xd8, 0x3a, 0x13, 0x36, 0xa0, 0x82, + 0x36, 0x23, 0xd5, 0xcd, 0xe0, 0xc9, 0xf6, 0x87, 0x54, 0xf8, 0x64, 0x80, 0x32, 0xc0, 0x97, 0xbb, 0x52, 0xad, 0xbc, + 0xcc, 0x43, 0xcd, 0xf7, 0x9a, 0xe0, 0x37, 0x92, 0x3c, 0x6c, 0x76, 0x27, 0xa7, 0xb9, 0x36, 0x98, 0xbe, 0x7c, 0xfd, + 0x85, 0x21, 0x16, 0x13, 0x41, 0x47, 0x50, 0x3c, 0x23, 0xcf, 0x26, 0x7e, 0x0b, 0x3c, 0x9b, 0xb4, 0x0c, 0x11, 0xca, + 0xae, 0xf5, 0x64, 0x0b, 0x22, 0x58, 0xd1, 0xa5, 0x91, 0x43, 0xbd, 0x33, 0x61, 0x6a, 0x56, 0x9b, 0x28, 0x5f, 0xae, + 0xc3, 0x34, 0xef, 0xa2, 0x67, 0x13, 0xd8, 0xd9, 0x5b, 0xfb, 0x7c, 0x1e, 0x10, 0x2c, 0x47, 0x7a, 0x23, 0xce, 0x63, + 0x89, 0xcb, 0x99, 0x2f, 0x23, 0x05, 0xcb, 0x91, 0x15, 0x84, 0xb3, 0x19, 0x5f, 0xe7, 0x7e, 0x4b, 0xf7, 0xa0, 0x92, + 0xcc, 0x72, 0x9e, 0x83, 0x76, 0x9f, 0x87, 0xab, 0x96, 0x72, 0x65, 0xb4, 0x5b, 0x5e, 0xb6, 0xb9, 0x58, 0x2d, 0x4b, + 0xa7, 0x4a, 0xd4, 0x47, 0x00, 0xc8, 0x40, 0x13, 0x95, 0xef, 0xb0, 0xe7, 0xc9, 0x55, 0x6d, 0x22, 0x95, 0xcc, 0xda, + 0x39, 0xc6, 0xe0, 0x10, 0xee, 0xf0, 0x2f, 0xd1, 0x1a, 0xf2, 0xbd, 0x70, 0xd3, 0xa0, 0x7c, 0xd4, 0xb7, 0xa6, 0x13, + 0x21, 0x7e, 0x1b, 0xe8, 0xb9, 0xa4, 0x35, 0xb0, 0x21, 0xa2, 0xc8, 0x3e, 0x07, 0x0e, 0x5d, 0x41, 0x0c, 0xc7, 0x2e, + 0x95, 0x8c, 0x5e, 0xa7, 0xa9, 0x2d, 0xaf, 0xe1, 0x20, 0xac, 0x00, 0xc7, 0x16, 0xce, 0x54, 0x19, 0x5f, 0x62, 0xab, + 0xf0, 0xac, 0xbc, 0xbf, 0xff, 0x2a, 0xf8, 0xf5, 0xdf, 0xe0, 0x8f, 0x73, 0xe1, 0x48, 0xb7, 0x09, 0x6f, 0x75, 0x2a, + 0x21, 0x6e, 0xa0, 0x69, 0x48, 0x9a, 0xf3, 0x4b, 0xe9, 0x5b, 0x4d, 0xce, 0xa8, 0x22, 0x78, 0xa7, 0xfb, 0x10, 0x95, + 0xee, 0x4b, 0x8c, 0x5f, 0xff, 0x63, 0xec, 0x38, 0xf6, 0xab, 0xb6, 0x07, 0x27, 0xcd, 0x74, 0x12, 0x1a, 0xc8, 0x7f, + 0x21, 0x27, 0x95, 0x8d, 0xba, 0xd0, 0xab, 0x45, 0xb2, 0xe2, 0x6c, 0x99, 0x74, 0x6f, 0xf9, 0x85, 0x15, 0xae, 0x97, + 0x04, 0x47, 0x03, 0xad, 0x44, 0xcb, 0x20, 0xde, 0x56, 0x81, 0x9d, 0x48, 0x7e, 0x2a, 0xca, 0x91, 0x4b, 0x6a, 0xce, + 0xad, 0xdc, 0xf2, 0xde, 0xb7, 0x2f, 0x1c, 0x47, 0x49, 0xca, 0xe9, 0xa4, 0x1b, 0x4e, 0xab, 0x7e, 0xad, 0x99, 0x8c, + 0xa8, 0x55, 0x3d, 0x42, 0xce, 0x03, 0x74, 0x58, 0x2d, 0x7d, 0x53, 0x97, 0x5f, 0xac, 0x64, 0x3e, 0xd7, 0xbd, 0x53, + 0xb3, 0x6a, 0xf3, 0xd4, 0x18, 0x95, 0x13, 0x38, 0x59, 0x53, 0x4d, 0xbb, 0x55, 0xa8, 0x47, 0x0c, 0xbf, 0x45, 0x7d, + 0x86, 0x45, 0xbd, 0xe3, 0xe5, 0x5a, 0x8d, 0xd8, 0x63, 0x22, 0xa2, 0x19, 0xa1, 0x9b, 0xe1, 0x6a, 0xd8, 0xf1, 0x1d, + 0x1e, 0x0c, 0xe0, 0xa8, 0xb8, 0x99, 0x9d, 0x8b, 0xcd, 0x6c, 0x44, 0x5f, 0x31, 0xc0, 0x40, 0x43, 0x74, 0x31, 0xe8, + 0x6c, 0x0e, 0x2f, 0x5a, 0x64, 0x4d, 0x0b, 0xc4, 0x3b, 0xdd, 0xd9, 0x6d, 0x63, 0x37, 0x94, 0xb3, 0xad, 0x32, 0x1f, + 0x61, 0x9e, 0x89, 0xdf, 0x1d, 0x64, 0x30, 0x59, 0x4e, 0x55, 0x14, 0x03, 0xce, 0xb9, 0xb6, 0x54, 0x64, 0x7c, 0xa8, + 0x86, 0xe5, 0xa2, 0x07, 0x72, 0x3a, 0xb6, 0x5a, 0x74, 0xda, 0x6a, 0xfb, 0x70, 0xd3, 0x2b, 0xca, 0x95, 0x54, 0xc9, + 0xc4, 0x85, 0x5d, 0x4c, 0xba, 0xd0, 0x64, 0x0a, 0xb4, 0x93, 0x2b, 0x76, 0x6a, 0x5b, 0xea, 0x03, 0xf8, 0x3e, 0x7d, + 0x40, 0x9d, 0x93, 0xa9, 0xb3, 0x64, 0xe0, 0xd0, 0x24, 0xcc, 0x08, 0x9c, 0xf7, 0xdd, 0xa5, 0xd8, 0xd0, 0xb5, 0x5a, + 0x34, 0xef, 0x7f, 0x1a, 0x5d, 0xe7, 0xa0, 0xb7, 0x10, 0x0c, 0x52, 0xf6, 0x7d, 0x8a, 0x11, 0xca, 0xca, 0xa0, 0x5b, + 0x4f, 0x3e, 0xc6, 0x5f, 0x40, 0x85, 0x88, 0x38, 0xf1, 0x83, 0x24, 0xe5, 0xcc, 0x3d, 0x4c, 0x57, 0xf2, 0x5a, 0x55, + 0x42, 0xde, 0x0e, 0x1e, 0xc3, 0x4c, 0x0f, 0xea, 0x2f, 0x60, 0xa2, 0x22, 0x7d, 0xa2, 0xa9, 0xf7, 0xc3, 0xf5, 0x1a, + 0xa9, 0x3b, 0xe3, 0x49, 0x97, 0x64, 0xee, 0x29, 0xcd, 0xac, 0xe9, 0x04, 0xe0, 0xe7, 0x34, 0x33, 0xc2, 0xf5, 0x5a, + 0xfc, 0xee, 0xf4, 0x44, 0x39, 0xdd, 0x45, 0xbe, 0x8a, 0xa6, 0xff, 0x05, 0x65, 0xcb, 0xbd, 0x71, 0x26, 0x30, 0x01, + 0x00}; #else // Brotli (default, smaller) constexpr uint8_t INDEX_BR[] PROGMEM = { - 0x5b, 0x7b, 0x7b, 0x53, 0xc1, 0x6e, 0x19, 0x03, 0xf5, 0x04, 0xe0, 0xf8, 0xbb, 0x25, 0x3d, 0x34, 0x51, 0x94, 0xb1, - 0xe6, 0x22, 0x2f, 0x61, 0xbb, 0xc2, 0x70, 0x9e, 0x80, 0x65, 0x6b, 0x78, 0xad, 0x47, 0x01, 0x40, 0x55, 0x13, 0x0e, - 0xd8, 0x18, 0x92, 0x41, 0xc7, 0x81, 0x6a, 0xd1, 0xee, 0xdb, 0xf0, 0xa6, 0x22, 0xc8, 0x31, 0x97, 0xd9, 0x3c, 0xcc, - 0xe5, 0xa4, 0xd5, 0x13, 0x8c, 0x3a, 0x44, 0xf9, 0x1a, 0x8c, 0x4b, 0x4c, 0x51, 0x7e, 0x10, 0x4b, 0xea, 0xba, 0xe6, - 0x24, 0x45, 0x6e, 0xf3, 0x72, 0x99, 0x36, 0xac, 0xdb, 0x79, 0x37, 0x0a, 0x4f, 0x92, 0xc8, 0x21, 0xb3, 0xaa, 0x10, - 0x8e, 0x77, 0x8e, 0xb5, 0x29, 0xe5, 0xbf, 0x10, 0x83, 0x6d, 0xc3, 0xba, 0x2d, 0x5d, 0x36, 0x49, 0x12, 0x9a, 0x5b, - 0x46, 0xa5, 0x0a, 0x42, 0x62, 0xf0, 0x33, 0xd7, 0x94, 0x37, 0x3f, 0x57, 0x6b, 0x9c, 0x30, 0x61, 0xbd, 0xf1, 0x5b, - 0x28, 0xf2, 0xda, 0x5a, 0xe3, 0x0b, 0x44, 0xe0, 0x2e, 0xa4, 0xbe, 0x68, 0xed, 0xa7, 0x5b, 0x5f, 0x57, 0x34, 0xde, - 0x43, 0xba, 0xff, 0x8d, 0xbf, 0x8b, 0x43, 0x72, 0x99, 0xdb, 0x59, 0x36, 0xac, 0xdb, 0xf2, 0xa6, 0xee, 0x77, 0xca, - 0x1c, 0x5e, 0x9c, 0x1b, 0x62, 0x68, 0x1d, 0x10, 0x8f, 0xcd, 0xa1, 0x4a, 0x44, 0x8b, 0x11, 0x2b, 0xf6, 0xda, 0x13, - 0xf3, 0x5f, 0x65, 0xcd, 0x7a, 0x7d, 0x47, 0xb5, 0x8c, 0x9c, 0x1d, 0x4d, 0x37, 0x55, 0x02, 0x7c, 0x97, 0xc6, 0xd7, - 0x09, 0x1e, 0xf0, 0xb1, 0x63, 0x19, 0x43, 0x51, 0x9d, 0xdd, 0x4a, 0x10, 0x59, 0x4d, 0x65, 0x8a, 0x4b, 0xf2, 0xff, - 0xa6, 0xaa, 0xe7, 0xf8, 0x72, 0xa2, 0xbf, 0xfa, 0x1c, 0xb2, 0x16, 0x10, 0x7c, 0x80, 0xe0, 0x90, 0xca, 0x4c, 0xc9, - 0x59, 0xb2, 0xbb, 0x24, 0x27, 0x5b, 0x06, 0x49, 0x70, 0xa4, 0x1c, 0x29, 0x01, 0x6a, 0x44, 0xce, 0xfd, 0x92, 0x7d, - 0x55, 0xed, 0xa7, 0x3d, 0x4f, 0xd7, 0xa6, 0xdf, 0xb6, 0xdf, 0xdd, 0x7b, 0xe2, 0x85, 0x47, 0x51, 0x90, 0x08, 0x99, - 0x06, 0x14, 0x02, 0x6a, 0xf6, 0xb5, 0xb7, 0xb4, 0xff, 0xaf, 0xdf, 0x91, 0x10, 0xe0, 0x4a, 0x70, 0x16, 0x75, 0xe6, - 0x2d, 0x5b, 0xcf, 0x85, 0xb3, 0x2c, 0x5b, 0x5f, 0xc3, 0x61, 0x58, 0x47, 0x5d, 0x35, 0xa1, 0xc9, 0x7e, 0x24, 0x15, - 0xbb, 0x23, 0xd8, 0xcf, 0x7d, 0x96, 0x7d, 0x7d, 0x2f, 0x5a, 0x3f, 0xd7, 0x0a, 0xcf, 0x78, 0x8a, 0x0b, 0xb1, 0xfe, - 0x2e, 0xa4, 0x84, 0xe9, 0x5a, 0x35, 0xa7, 0x16, 0xc8, 0xc0, 0x38, 0x3e, 0xfb, 0x6c, 0x5f, 0x55, 0xa7, 0x6b, 0x47, - 0x9a, 0x25, 0x26, 0x47, 0xae, 0x17, 0x3d, 0x73, 0x14, 0x38, 0x9a, 0xfd, 0x5e, 0x2e, 0x1a, 0x1d, 0xe8, 0x0c, 0xe5, - 0x04, 0xb6, 0x31, 0x50, 0x0b, 0x44, 0x55, 0xb7, 0x19, 0xb2, 0xea, 0x7d, 0xf5, 0xfd, 0xaf, 0x5f, 0x72, 0xa3, 0x40, - 0x3d, 0xc6, 0x2c, 0x69, 0x29, 0xef, 0x81, 0x47, 0x88, 0x2c, 0x47, 0xc7, 0x8a, 0x1f, 0xf2, 0x95, 0x74, 0x1e, 0x2e, - 0x86, 0x45, 0x43, 0xc4, 0x92, 0x42, 0x0e, 0xb4, 0xe0, 0xc5, 0x2e, 0x2d, 0xd0, 0xc4, 0x06, 0xfe, 0xbf, 0xaa, 0x59, - 0xfd, 0xbe, 0x37, 0x2b, 0x09, 0x4b, 0x21, 0x2e, 0x71, 0x82, 0x40, 0xdd, 0xf3, 0x7b, 0x38, 0xde, 0xf3, 0x9f, 0x87, - 0xec, 0x30, 0x05, 0xad, 0xa2, 0x32, 0xc9, 0x41, 0xa4, 0x01, 0x35, 0x7a, 0x5c, 0x4b, 0xd3, 0xca, 0xd7, 0x57, 0x10, - 0xb0, 0x03, 0x97, 0xa6, 0xd8, 0xd3, 0x0c, 0x4d, 0x51, 0x24, 0x6c, 0x3a, 0xa5, 0xb7, 0xb3, 0x2e, 0x6b, 0x2f, 0x27, - 0xf3, 0xd0, 0xa9, 0x4d, 0xbb, 0x87, 0x49, 0x14, 0xd1, 0x36, 0x97, 0xb4, 0x86, 0x49, 0xc1, 0xdb, 0x49, 0x77, 0xc2, - 0x8a, 0x51, 0x79, 0x24, 0x4c, 0xf8, 0x87, 0x87, 0xe4, 0x03, 0x6a, 0xf5, 0x0d, 0xff, 0x69, 0x6a, 0xf6, 0xfa, 0xc6, - 0x0b, 0x3d, 0xe4, 0x54, 0x2e, 0xf2, 0x76, 0x80, 0xac, 0xee, 0xba, 0xb5, 0x69, 0x4e, 0x72, 0x9d, 0x98, 0x61, 0x93, - 0x02, 0xb6, 0x1b, 0x0e, 0x25, 0xd2, 0x46, 0x2c, 0x2d, 0xd5, 0xd7, 0x3b, 0x79, 0x1d, 0x25, 0x4a, 0x86, 0xf2, 0x0a, - 0x16, 0xd9, 0xb4, 0x5f, 0x29, 0x6d, 0xe0, 0xdb, 0xf8, 0xc6, 0x85, 0x03, 0x50, 0x4b, 0xf7, 0x84, 0x48, 0xea, 0xa0, - 0x10, 0x15, 0x28, 0x6c, 0xb0, 0xfc, 0xff, 0xbd, 0x95, 0x96, 0xdb, 0x1f, 0x91, 0xae, 0x08, 0x91, 0x3d, 0x00, 0x39, - 0xce, 0x70, 0x64, 0xfd, 0xbe, 0x33, 0xb3, 0x0a, 0x9c, 0x06, 0x48, 0xf6, 0x38, 0xb3, 0x92, 0xd6, 0x5a, 0x6c, 0x2a, - 0xee, 0xbd, 0xef, 0x5d, 0xe6, 0x77, 0xd1, 0x19, 0x3f, 0x0c, 0x2b, 0x4c, 0x66, 0x23, 0xed, 0xb0, 0x6c, 0x57, 0x96, - 0xd3, 0x00, 0x20, 0x78, 0xdf, 0x7b, 0x3f, 0x0a, 0xff, 0xff, 0xc8, 0xe2, 0xfc, 0x88, 0x2c, 0x50, 0x91, 0x59, 0xc5, - 0x39, 0x99, 0x05, 0xcc, 0xa8, 0x0a, 0xe0, 0x8c, 0x0a, 0x60, 0x1f, 0x1d, 0x90, 0x63, 0x41, 0xd0, 0x68, 0x9a, 0x6c, - 0xf6, 0xd1, 0x90, 0x2d, 0xef, 0x57, 0x5a, 0xac, 0x20, 0xca, 0xf5, 0x8c, 0x6c, 0x4b, 0x7e, 0xb7, 0x03, 0x65, 0xcd, - 0x52, 0x5a, 0xe9, 0xe8, 0xff, 0xe6, 0xd4, 0x66, 0x40, 0x8e, 0x40, 0x75, 0x53, 0x57, 0x21, 0xdc, 0xf2, 0xff, 0x5d, - 0xf2, 0x7a, 0x97, 0x52, 0xd2, 0xd1, 0xa5, 0x78, 0x19, 0x26, 0x1d, 0x95, 0x60, 0xe0, 0x2a, 0x27, 0xa7, 0xe7, 0x66, - 0x2c, 0xb2, 0x71, 0x53, 0x7f, 0x0c, 0xbf, 0x87, 0xd2, 0xc2, 0x60, 0xea, 0x4c, 0xd3, 0xf4, 0xdf, 0x6d, 0xa2, 0xab, - 0xae, 0x2c, 0x2c, 0xbf, 0xed, 0x66, 0x12, 0x57, 0x59, 0x96, 0x25, 0xb9, 0x24, 0x31, 0x01, 0xfe, 0x21, 0xba, 0xef, - 0x6f, 0xa8, 0xcf, 0x1b, 0x4b, 0xdb, 0x0c, 0x42, 0x26, 0x04, 0x48, 0xdb, 0xff, 0x37, 0x99, 0xeb, 0x9c, 0xb8, 0x78, - 0x7c, 0x49, 0xd3, 0x34, 0xb3, 0x6c, 0x7f, 0xae, 0xa3, 0xb4, 0x94, 0x6e, 0x9b, 0xed, 0x36, 0x7d, 0xa4, 0x0e, 0xdf, - 0xc0, 0x6f, 0x0c, 0x18, 0xc3, 0xe4, 0x6e, 0x15, 0x53, 0x43, 0x76, 0x69, 0xb6, 0xa5, 0xcd, 0x02, 0xd4, 0xb2, 0xfe, - 0x87, 0xa4, 0xdc, 0x5b, 0x42, 0x27, 0xf6, 0x34, 0xac, 0x62, 0x92, 0x7c, 0x83, 0x6f, 0x4c, 0xdf, 0x5a, 0x48, 0x2c, - 0x43, 0xd3, 0xda, 0xfe, 0x65, 0xb6, 0xf9, 0x75, 0x18, 0xb3, 0xcc, 0x14, 0x5b, 0x92, 0x63, 0x5b, 0x09, 0x76, 0xef, - 0x8a, 0x4c, 0xac, 0x3d, 0x0e, 0x00, 0xa7, 0xe5, 0x88, 0xb6, 0xe0, 0x33, 0x10, 0x8e, 0x73, 0x17, 0xbf, 0xfc, 0x55, - 0x09, 0xa6, 0xa3, 0x3d, 0x14, 0x7c, 0x75, 0x8c, 0x42, 0x2c, 0x41, 0x14, 0x79, 0xee, 0xe2, 0xde, 0x07, 0x26, 0xdf, - 0x0e, 0xaa, 0xe8, 0x1f, 0xba, 0xa6, 0x27, 0x9c, 0x21, 0x50, 0x8f, 0x5e, 0xf2, 0x0b, 0x07, 0xde, 0xfd, 0x7b, 0x00, - 0xa2, 0x12, 0x51, 0xea, 0xdb, 0x6f, 0xb8, 0x4e, 0x30, 0x7d, 0xdf, 0x4d, 0xdb, 0x03, 0xee, 0x0e, 0x1e, 0x12, 0x78, - 0x52, 0x0a, 0xcb, 0xfd, 0x97, 0xaa, 0x2b, 0x6e, 0x96, 0xa1, 0xd7, 0x31, 0x9d, 0xef, 0x26, 0xd8, 0x14, 0x2d, 0x6b, - 0x29, 0x18, 0x7a, 0xe6, 0xf1, 0xd6, 0x58, 0xfd, 0x0c, 0x56, 0xc9, 0xc0, 0x2d, 0x2d, 0xcc, 0xe4, 0xd4, 0xcf, 0xd7, - 0x54, 0xf5, 0xc1, 0x48, 0x12, 0x01, 0x90, 0xbc, 0xf9, 0x10, 0x27, 0x44, 0xe2, 0xfa, 0x7a, 0x3e, 0x5f, 0x95, 0x97, - 0xd9, 0x7e, 0x98, 0x60, 0x20, 0xd9, 0x20, 0x03, 0x98, 0xed, 0x3d, 0x5c, 0x7d, 0xb8, 0x57, 0xf3, 0x32, 0x6a, 0xfa, - 0xd7, 0x79, 0xb4, 0xa1, 0x33, 0x6d, 0x40, 0x1e, 0xb7, 0x69, 0x59, 0x9a, 0x92, 0x82, 0xc4, 0x86, 0x43, 0x06, 0x77, - 0x83, 0x39, 0xad, 0xc7, 0xa4, 0xe6, 0x9c, 0xac, 0xc9, 0x15, 0x97, 0x06, 0x37, 0xeb, 0xa3, 0x0f, 0xf7, 0xbe, 0xa4, - 0xc3, 0x2d, 0x3e, 0x6c, 0xfa, 0x24, 0x93, 0x7b, 0xde, 0x84, 0xcf, 0x4d, 0xb9, 0xbe, 0x1c, 0x02, 0x7b, 0xf3, 0x13, - 0x76, 0x85, 0xa0, 0x59, 0xdf, 0xea, 0xc8, 0x37, 0xde, 0xb5, 0xeb, 0xa1, 0x44, 0x32, 0x1a, 0x7d, 0xef, 0x41, 0xf3, - 0xa2, 0xdc, 0x88, 0x47, 0xd8, 0x2b, 0xd4, 0xb7, 0x3f, 0xb1, 0xc2, 0xb2, 0xbb, 0x99, 0x3f, 0x6c, 0x74, 0x7b, 0xf6, - 0xdd, 0xcb, 0xc1, 0xa3, 0x2f, 0xc2, 0x5c, 0x7d, 0xb8, 0xbf, 0xdd, 0x3a, 0xc1, 0x63, 0x42, 0x29, 0x76, 0x43, 0xc2, - 0xa1, 0xe6, 0xf7, 0x6e, 0xf6, 0x6e, 0xf2, 0x73, 0x59, 0x8b, 0x59, 0x4d, 0xfe, 0x93, 0xdf, 0xfe, 0xea, 0x77, 0x6a, - 0x9b, 0x8f, 0xf0, 0xed, 0x09, 0xc2, 0xd3, 0xbb, 0xa3, 0x8c, 0xb0, 0xe6, 0x30, 0xfe, 0xac, 0xa7, 0xca, 0x3f, 0xdb, - 0x2c, 0x6c, 0x73, 0x98, 0xaf, 0x4b, 0xda, 0x9e, 0xc3, 0xa4, 0x75, 0x57, 0xa2, 0xde, 0x4d, 0x94, 0xf2, 0xa0, 0x09, - 0xf2, 0xf2, 0xb9, 0x03, 0x7d, 0xe3, 0x7c, 0xcd, 0xa0, 0xc8, 0x6e, 0xa9, 0xe5, 0xd2, 0x9a, 0xc7, 0x9b, 0xf9, 0x60, - 0x59, 0xa2, 0x40, 0xbf, 0x4a, 0xbd, 0x77, 0xad, 0xbb, 0x7e, 0x21, 0xaa, 0x1f, 0x6d, 0xe6, 0x6a, 0x04, 0x42, 0xa4, - 0x5c, 0x37, 0x01, 0x22, 0x4b, 0xa4, 0xc8, 0x33, 0xf1, 0x5c, 0xa7, 0x4d, 0x86, 0x1e, 0xb9, 0xbf, 0xf2, 0x6b, 0xa4, - 0xe1, 0xf9, 0x84, 0x76, 0xf8, 0xd1, 0x66, 0x25, 0xd4, 0x2b, 0x54, 0xc8, 0x1b, 0x67, 0xc5, 0x7f, 0xee, 0x43, 0xa9, - 0xd6, 0x44, 0x0c, 0xcf, 0xcd, 0x64, 0x90, 0xf7, 0x2c, 0xbb, 0x92, 0xea, 0x58, 0x5b, 0x5b, 0x55, 0xd7, 0xb7, 0x50, - 0xde, 0xcc, 0x50, 0xee, 0x45, 0x95, 0x22, 0xf9, 0x60, 0x18, 0xd2, 0x73, 0xfc, 0xdb, 0xd6, 0x37, 0x3f, 0x15, 0x88, - 0x73, 0x91, 0x37, 0x28, 0x75, 0x43, 0x4d, 0x96, 0x12, 0xfb, 0x59, 0x9d, 0xb2, 0xdd, 0x23, 0xed, 0xa0, 0x23, 0x57, - 0x03, 0x98, 0xc2, 0x54, 0xb0, 0xe7, 0xd5, 0x4b, 0x56, 0x9d, 0xe7, 0x05, 0xf9, 0xb6, 0xe2, 0x47, 0x04, 0x40, 0xa3, - 0x78, 0x43, 0x34, 0x2b, 0xa0, 0x2a, 0x91, 0x26, 0x0b, 0xc7, 0x4e, 0xf3, 0x4f, 0x68, 0x43, 0xcd, 0x7e, 0xbf, 0xed, - 0x64, 0x50, 0xc2, 0xc5, 0x37, 0x9f, 0x7d, 0xa0, 0x09, 0x7e, 0xfb, 0x99, 0x8c, 0xac, 0x95, 0xa0, 0xa3, 0x9c, 0xbc, - 0xee, 0x40, 0xca, 0x2c, 0x53, 0x61, 0xa1, 0x8b, 0xa4, 0x84, 0x6e, 0x98, 0x9c, 0x2f, 0x78, 0x7b, 0x83, 0xf3, 0xb5, - 0xac, 0x56, 0x5a, 0xbe, 0x99, 0xaa, 0x85, 0x79, 0x07, 0x54, 0x7d, 0xec, 0x04, 0x9e, 0xd0, 0x6d, 0x32, 0xef, 0x96, - 0xd2, 0x23, 0x5a, 0xf9, 0xde, 0x4b, 0x91, 0x66, 0xb7, 0xfe, 0x84, 0xe8, 0xd5, 0x11, 0x81, 0xfb, 0x22, 0xd9, 0x8a, - 0xbe, 0x37, 0x8c, 0x88, 0xe2, 0xfe, 0x1e, 0xfd, 0x12, 0x3f, 0xcb, 0xaf, 0x5d, 0x21, 0x34, 0x56, 0xc0, 0x23, 0x69, - 0x7d, 0xef, 0x6a, 0x8f, 0x21, 0x80, 0x4e, 0xaf, 0x42, 0x31, 0xec, 0xb6, 0x22, 0x66, 0xc7, 0x99, 0x38, 0xee, 0xf3, - 0x19, 0x96, 0xf9, 0xda, 0x34, 0xa1, 0x1b, 0xaa, 0x4f, 0x71, 0x21, 0x65, 0x92, 0x36, 0x45, 0x55, 0x17, 0x8d, 0xbf, - 0x35, 0xc8, 0x98, 0x62, 0xde, 0x7a, 0x34, 0xe8, 0x2f, 0xf6, 0x05, 0xf1, 0xe0, 0x48, 0xd0, 0xcb, 0x74, 0xf4, 0xc6, - 0xb1, 0x6a, 0x2c, 0x6f, 0x2c, 0x3b, 0x30, 0x13, 0x36, 0x09, 0xd1, 0xd8, 0x60, 0xeb, 0xc8, 0x82, 0x55, 0xcf, 0x18, - 0x9b, 0x77, 0xe9, 0x2d, 0x12, 0xde, 0x95, 0x2d, 0x1c, 0xa6, 0xfa, 0x42, 0xc6, 0x59, 0x2f, 0xd7, 0xf2, 0xe9, 0x3a, - 0x01, 0x0e, 0x12, 0x86, 0x17, 0xc4, 0x18, 0xfe, 0xe2, 0xbc, 0x49, 0x55, 0xb0, 0x28, 0xb4, 0x6d, 0x7c, 0x51, 0x7b, - 0x10, 0xcf, 0x4a, 0x10, 0xdf, 0xca, 0xb8, 0xea, 0xa0, 0x1b, 0x8e, 0x30, 0x57, 0xc3, 0x26, 0x84, 0x56, 0x10, 0x81, - 0x9a, 0xfa, 0x33, 0x0d, 0xd5, 0xb5, 0xae, 0xf2, 0x42, 0xa2, 0xe4, 0xb3, 0x68, 0x1c, 0x41, 0x21, 0x07, 0x83, 0xc2, - 0x09, 0x3d, 0xd8, 0x3d, 0xf8, 0x8d, 0x83, 0x71, 0xc1, 0x71, 0x43, 0xfe, 0xda, 0x2d, 0x6b, 0xdc, 0x33, 0x30, 0x95, - 0x97, 0x2b, 0xcd, 0xe6, 0x00, 0x2a, 0x83, 0x5d, 0x6c, 0x48, 0x3e, 0x5b, 0xf4, 0x84, 0xbe, 0xbb, 0xa1, 0x01, 0x0c, - 0x0f, 0x8f, 0xbc, 0x99, 0x7f, 0x23, 0x01, 0x0f, 0x0e, 0x66, 0xe5, 0x97, 0x0b, 0xa1, 0x58, 0x7d, 0x11, 0x20, 0x40, - 0x7c, 0x8d, 0xee, 0x07, 0x41, 0x74, 0x84, 0x60, 0x45, 0x1d, 0x0b, 0xe0, 0x44, 0xc5, 0x29, 0x39, 0x22, 0xc0, 0x38, - 0x41, 0x7d, 0x13, 0x34, 0xf3, 0x7b, 0xa3, 0xfc, 0x0b, 0xb7, 0x9b, 0x79, 0xe2, 0x59, 0x3f, 0x9b, 0xd7, 0x8b, 0x24, - 0x4f, 0xe0, 0x51, 0xd3, 0x81, 0x12, 0x85, 0xd2, 0x0d, 0xee, 0xa6, 0x14, 0x71, 0x9a, 0x88, 0xd5, 0x42, 0x00, 0xb6, - 0xb5, 0xb2, 0x96, 0x7e, 0xa3, 0x74, 0x8e, 0x3a, 0x87, 0x3d, 0x0b, 0xbe, 0x50, 0x7e, 0x6f, 0x09, 0x5d, 0xd5, 0x68, - 0x3b, 0x97, 0x9a, 0x1f, 0xae, 0x36, 0xb2, 0xa1, 0x75, 0xcd, 0xde, 0x42, 0x50, 0x53, 0x54, 0x86, 0x9a, 0xf2, 0x22, - 0x19, 0xdb, 0x9d, 0x98, 0xfd, 0xd0, 0x48, 0xf2, 0x1a, 0x79, 0x65, 0x7f, 0x43, 0x3b, 0xd3, 0x26, 0x1e, 0xbb, 0x12, - 0x0c, 0xbf, 0x68, 0x29, 0x7d, 0x2d, 0x9c, 0x5d, 0xcb, 0xcf, 0x97, 0xb0, 0x36, 0xa6, 0x00, 0x82, 0x90, 0x7e, 0x36, - 0xda, 0xaa, 0x31, 0xba, 0xd5, 0x63, 0xca, 0x3e, 0xea, 0x31, 0xdf, 0xfd, 0x1e, 0xa9, 0x92, 0x85, 0x20, 0x39, 0x34, - 0xf4, 0xd7, 0x63, 0x64, 0x18, 0xa0, 0x48, 0x22, 0xe4, 0x5b, 0x29, 0x03, 0xf7, 0xef, 0x57, 0x8c, 0x0e, 0xb6, 0xd4, - 0x9c, 0x49, 0xb3, 0xab, 0x67, 0x34, 0x20, 0x6c, 0xb4, 0x1e, 0x26, 0xce, 0x08, 0xe1, 0xa4, 0xb1, 0x7d, 0xaa, 0x22, - 0x12, 0xe9, 0xbd, 0x14, 0x31, 0xd8, 0xb8, 0x52, 0xba, 0xc4, 0x08, 0x6b, 0x66, 0x2c, 0xc7, 0x06, 0x50, 0x39, 0x73, - 0x5b, 0x94, 0xc6, 0x37, 0xad, 0xa0, 0x04, 0xb8, 0x47, 0x0c, 0xf6, 0x41, 0x23, 0x40, 0xae, 0x0b, 0x2a, 0x48, 0x68, - 0x9f, 0x0b, 0xc8, 0x84, 0x06, 0x19, 0x19, 0x13, 0xeb, 0x46, 0x20, 0xb9, 0x7b, 0x7a, 0xd3, 0x2e, 0x01, 0xa6, 0x72, - 0xb2, 0x9a, 0x21, 0x62, 0xe2, 0x78, 0x5d, 0x2d, 0x9c, 0xc0, 0x58, 0x0a, 0xd8, 0x31, 0x76, 0x54, 0x72, 0x2e, 0x76, - 0x68, 0xb4, 0x69, 0xe6, 0x17, 0xba, 0x3e, 0x43, 0xe1, 0x87, 0xb5, 0x0b, 0xc8, 0xc8, 0xa9, 0xdb, 0x4b, 0x0f, 0x46, - 0x06, 0x12, 0x57, 0xeb, 0x4e, 0x8b, 0xa4, 0x15, 0x91, 0xcf, 0x8a, 0x7e, 0x75, 0x6c, 0x72, 0x25, 0x2e, 0xd6, 0x8a, - 0x1a, 0x43, 0x91, 0x07, 0xb7, 0xc1, 0x3f, 0x76, 0xf4, 0xb8, 0x75, 0xc2, 0x02, 0x80, 0xf5, 0x58, 0x4e, 0x06, 0x9c, - 0xab, 0xee, 0xe0, 0xd7, 0x40, 0x95, 0xc0, 0x2b, 0x47, 0x9d, 0x45, 0x1c, 0x5f, 0x58, 0xa0, 0x18, 0xfc, 0xeb, 0x14, - 0x79, 0x0c, 0x76, 0x83, 0x2c, 0xe9, 0xa6, 0x59, 0x04, 0x7b, 0x4a, 0x79, 0x26, 0x62, 0xfe, 0xaa, 0x91, 0x34, 0x2a, - 0xac, 0x78, 0x9a, 0x6a, 0xa9, 0x13, 0x3e, 0x55, 0x09, 0x05, 0xc2, 0x1e, 0x82, 0xa6, 0x00, 0xde, 0x9b, 0x12, 0xf3, - 0xf8, 0xa6, 0x85, 0xc4, 0xf9, 0xc9, 0x3a, 0x9b, 0x35, 0x63, 0x06, 0xba, 0x92, 0x80, 0x6e, 0x4e, 0x35, 0x0d, 0xb7, - 0xe8, 0xba, 0x2c, 0x85, 0xa5, 0x64, 0x85, 0x5a, 0x82, 0x89, 0x30, 0x19, 0xde, 0x06, 0x17, 0x90, 0xbc, 0x37, 0x69, - 0x66, 0xdc, 0x3c, 0xbd, 0xaa, 0xf2, 0x04, 0x9a, 0xc7, 0x7d, 0x99, 0x2f, 0x34, 0xa5, 0xb9, 0xc2, 0x01, 0x48, 0x7b, - 0xc1, 0x3c, 0x16, 0x1a, 0x67, 0x52, 0x32, 0xfd, 0x8e, 0x8b, 0x99, 0xd4, 0x54, 0x71, 0x17, 0xd6, 0x09, 0x2b, 0x40, - 0x22, 0x59, 0x32, 0x18, 0x3c, 0x03, 0x8a, 0xf7, 0x05, 0xe0, 0x88, 0x68, 0x14, 0xbe, 0xb3, 0xa3, 0x1c, 0xad, 0x4a, - 0x42, 0x88, 0xcc, 0x56, 0xec, 0xbc, 0x78, 0xa3, 0x1c, 0x45, 0xce, 0x38, 0xda, 0x01, 0x6c, 0x5e, 0x7f, 0xc8, 0x7c, - 0x06, 0x81, 0xac, 0x1f, 0x27, 0x3a, 0x9b, 0x9b, 0xa6, 0x4b, 0x91, 0xce, 0x46, 0x73, 0x96, 0x17, 0x78, 0xc6, 0x29, - 0x13, 0x3c, 0x96, 0x8d, 0xe2, 0x86, 0xa8, 0xf3, 0x4f, 0xd4, 0x01, 0xa7, 0xda, 0x66, 0x7b, 0x33, 0x58, 0x3d, 0x2d, - 0x4e, 0x0e, 0x18, 0x95, 0x9c, 0xcd, 0xa3, 0xd5, 0xeb, 0xfd, 0x5f, 0x4e, 0xbe, 0x2a, 0x63, 0x81, 0xc6, 0xab, 0x9c, - 0xaa, 0xc8, 0xc8, 0x74, 0xc0, 0x89, 0x97, 0x9a, 0xcf, 0xc5, 0x00, 0x2d, 0x32, 0xaf, 0x4a, 0x32, 0x14, 0x92, 0xd5, - 0xb0, 0xf2, 0x06, 0x1a, 0x64, 0xd3, 0xd5, 0x50, 0xa3, 0xe0, 0x08, 0x59, 0xd2, 0x62, 0x63, 0xb6, 0x58, 0xac, 0x79, - 0xad, 0x99, 0x36, 0xc7, 0x08, 0x22, 0xb0, 0x38, 0x20, 0xae, 0x3f, 0xab, 0x35, 0x36, 0x30, 0x89, 0x57, 0xbb, 0x11, - 0x06, 0xdd, 0x0d, 0x2d, 0xa9, 0x4e, 0x8c, 0xa5, 0x12, 0x44, 0x4e, 0x1d, 0x69, 0xec, 0x47, 0x9e, 0xaf, 0xf9, 0xe3, - 0x9e, 0x05, 0xc6, 0xb2, 0x3c, 0x18, 0x19, 0xaa, 0x18, 0x52, 0xda, 0x0d, 0x66, 0x1e, 0xa2, 0x7e, 0x7a, 0xa4, 0x56, - 0xe5, 0x4c, 0xed, 0x31, 0x3c, 0x16, 0x9d, 0x4b, 0xf2, 0xe1, 0x51, 0x37, 0x04, 0x64, 0x5b, 0x81, 0xd5, 0xa7, 0x0e, - 0x22, 0x8a, 0x40, 0xd8, 0xcf, 0xe9, 0x1f, 0xbb, 0x91, 0xff, 0x14, 0xb0, 0x54, 0xaf, 0x87, 0xba, 0xa5, 0xcc, 0x31, - 0x25, 0x6b, 0x79, 0xcb, 0x29, 0xa8, 0xb8, 0x74, 0x55, 0x3a, 0x79, 0x20, 0xb6, 0x10, 0x29, 0x58, 0xcc, 0x3e, 0x9f, - 0x2e, 0x1c, 0xa8, 0xa4, 0x50, 0x7d, 0xdf, 0x05, 0x79, 0x7e, 0xb8, 0x71, 0x50, 0x8b, 0x31, 0xc6, 0x43, 0xaa, 0xad, - 0xaf, 0x1d, 0xdc, 0x8a, 0xbd, 0x0d, 0x3c, 0x3f, 0xb1, 0xdf, 0xef, 0xb7, 0x6c, 0x94, 0x91, 0x95, 0xc2, 0x8a, 0xdc, - 0xd4, 0xa2, 0xf3, 0xc3, 0x49, 0x38, 0x79, 0x42, 0x19, 0x90, 0x97, 0x33, 0xd8, 0x02, 0x59, 0x74, 0x53, 0xf4, 0xc2, - 0x68, 0xb3, 0xbe, 0xe5, 0xe2, 0x5b, 0xbf, 0xc3, 0x21, 0x93, 0x94, 0x2e, 0x69, 0x3a, 0xdf, 0xeb, 0x52, 0x7d, 0x17, - 0x59, 0xb4, 0x48, 0x67, 0xd5, 0xb6, 0xfb, 0x45, 0xaa, 0xb5, 0x17, 0x22, 0x59, 0x32, 0x1c, 0xc5, 0xde, 0xb9, 0x20, - 0xb5, 0x74, 0x06, 0xd5, 0xf4, 0x63, 0x32, 0x8e, 0x5d, 0x02, 0xad, 0x15, 0x4c, 0x6f, 0xe1, 0xc5, 0x20, 0xdb, 0x48, - 0x61, 0x91, 0x16, 0x82, 0x35, 0x9a, 0x39, 0xd2, 0x7e, 0x90, 0x28, 0x2c, 0x03, 0x74, 0x96, 0xf4, 0x39, 0xb3, 0x87, - 0xa3, 0x78, 0x84, 0x2a, 0xa2, 0xd4, 0xfd, 0x61, 0x42, 0x85, 0x54, 0xa7, 0x79, 0x82, 0xa2, 0x3d, 0x1f, 0xb9, 0x63, - 0x03, 0xe6, 0xa7, 0x33, 0xd1, 0xae, 0xbf, 0x5a, 0x02, 0x16, 0x5e, 0x7e, 0x48, 0x71, 0x9b, 0xd2, 0xdb, 0xf9, 0x1f, - 0xf3, 0x39, 0xa5, 0x3c, 0x33, 0x74, 0x4a, 0xa9, 0xd0, 0xcc, 0xe6, 0xc2, 0x0a, 0x49, 0xa5, 0xf9, 0x70, 0x67, 0x0d, - 0xba, 0x19, 0x82, 0x12, 0x09, 0xc5, 0x8d, 0x60, 0x16, 0xa3, 0x18, 0x6b, 0xa0, 0x72, 0x37, 0x6f, 0xd5, 0x49, 0xa5, - 0xb9, 0x53, 0x95, 0x5c, 0xf1, 0xdd, 0xcf, 0x8d, 0x82, 0x61, 0x08, 0xb1, 0xe9, 0xf8, 0x22, 0x25, 0xcb, 0x4b, 0x39, - 0xac, 0xc6, 0x95, 0x21, 0x82, 0x96, 0x41, 0x9c, 0x10, 0xac, 0xe4, 0x12, 0xd4, 0x56, 0x98, 0xee, 0x54, 0x89, 0x52, - 0x41, 0x1f, 0x28, 0xbd, 0xba, 0x83, 0xe6, 0xc4, 0x36, 0x84, 0xb7, 0xa6, 0xa1, 0x80, 0x98, 0xf5, 0xdf, 0x07, 0x19, - 0x1d, 0x3a, 0x7e, 0x2b, 0x19, 0x53, 0x21, 0x50, 0x33, 0x47, 0xcb, 0xcb, 0x80, 0x4d, 0x0a, 0x71, 0xa5, 0x28, 0x4e, - 0x04, 0x71, 0xd8, 0xc7, 0xa6, 0xe6, 0xd3, 0xc7, 0x41, 0x62, 0x1a, 0xd6, 0x65, 0x03, 0xa4, 0xd6, 0x0b, 0x91, 0xf8, - 0x35, 0xf5, 0xe6, 0xa0, 0x09, 0xe3, 0x75, 0xa8, 0x20, 0x66, 0xc5, 0x69, 0x23, 0x05, 0x63, 0x95, 0x86, 0x43, 0x50, - 0x8e, 0x0c, 0xcb, 0xc4, 0xfa, 0xd2, 0x2c, 0xd1, 0x1b, 0x26, 0x06, 0xb6, 0x63, 0xa5, 0x84, 0x00, 0x38, 0x33, 0x66, - 0xdd, 0x8e, 0x49, 0xab, 0x0a, 0xea, 0x81, 0xea, 0xb3, 0xbe, 0xe8, 0x78, 0x86, 0x98, 0xf0, 0x21, 0x01, 0x47, 0xf3, - 0x45, 0xd2, 0x73, 0x6b, 0xa2, 0x25, 0x6d, 0x6a, 0x88, 0x3f, 0x31, 0xd2, 0x5a, 0xb4, 0xd2, 0x81, 0xaf, 0x00, 0x54, - 0x90, 0xa9, 0xe0, 0x12, 0x55, 0x52, 0x36, 0x15, 0x95, 0x07, 0x93, 0x72, 0x6d, 0x99, 0x95, 0x55, 0xee, 0x5d, 0x1f, - 0xe1, 0xcf, 0xb4, 0x50, 0xd2, 0xba, 0x43, 0x7c, 0xa9, 0xe0, 0xaf, 0x51, 0x48, 0x11, 0xf5, 0x99, 0x91, 0x5d, 0x1d, - 0xf3, 0xec, 0x91, 0x95, 0xff, 0xda, 0xc6, 0xaf, 0x5d, 0x28, 0x31, 0xca, 0xdd, 0x7b, 0x64, 0x32, 0xb2, 0x85, 0x80, - 0xa8, 0xdb, 0xd8, 0x0f, 0x47, 0xea, 0xf8, 0xe3, 0x90, 0xe2, 0x3f, 0x5d, 0x05, 0x51, 0x7b, 0xd2, 0x42, 0xaa, 0x83, - 0x9e, 0x03, 0x6b, 0xd0, 0x9a, 0x34, 0x7a, 0xd0, 0xbd, 0x07, 0x2a, 0x57, 0x04, 0xe7, 0x8f, 0x6e, 0xc2, 0x44, 0x05, - 0x9e, 0x02, 0xfe, 0xc2, 0x14, 0x84, 0x59, 0x23, 0x50, 0xdd, 0x2e, 0xda, 0x3e, 0x6f, 0x33, 0x66, 0x90, 0xf7, 0x6e, - 0xdf, 0x08, 0x3f, 0xa2, 0x1e, 0x36, 0x5b, 0xfd, 0x9b, 0x6f, 0x79, 0x94, 0xa8, 0x2c, 0x84, 0xa9, 0x91, 0x50, 0x53, - 0x67, 0x49, 0xe0, 0x47, 0x37, 0xb1, 0x86, 0xd9, 0x7e, 0xb2, 0x56, 0xb8, 0x54, 0x08, 0x99, 0x22, 0x10, 0x9d, 0x21, - 0xcc, 0xa8, 0xf3, 0x44, 0x01, 0xbc, 0xad, 0x00, 0xb4, 0x04, 0xfd, 0x18, 0x6c, 0x73, 0xfb, 0x84, 0xd0, 0x5c, 0xcc, - 0xf3, 0x47, 0x4c, 0x42, 0x41, 0x8a, 0x9f, 0xe5, 0xd3, 0xac, 0x79, 0xa1, 0x12, 0x15, 0xd7, 0x50, 0xb4, 0x15, 0xd7, - 0xc1, 0x03, 0x63, 0xd6, 0x47, 0xd1, 0xa9, 0x8d, 0x29, 0xcd, 0xe2, 0x66, 0x97, 0x68, 0x47, 0xea, 0x6e, 0x3c, 0x9f, - 0x34, 0xdc, 0x89, 0x24, 0xa1, 0x2c, 0x43, 0xab, 0xdb, 0xa6, 0x4b, 0x71, 0x0a, 0xe7, 0x74, 0x5e, 0x7e, 0xcb, 0x10, - 0xef, 0xbf, 0xe6, 0xf8, 0xf4, 0x39, 0xab, 0x66, 0x9e, 0x1f, 0x3d, 0x12, 0x5a, 0x60, 0x66, 0x2d, 0x76, 0xf3, 0x28, - 0x8b, 0x35, 0x24, 0xb0, 0xc3, 0x86, 0xa1, 0x13, 0x5e, 0x6f, 0x59, 0x3c, 0x54, 0x5b, 0x0f, 0x36, 0xde, 0x53, 0x18, - 0xba, 0x5b, 0xd2, 0x46, 0xd6, 0x35, 0x51, 0xd1, 0xcf, 0x6f, 0x91, 0xcd, 0xdd, 0xfe, 0xb8, 0x4c, 0x9a, 0x14, 0x15, - 0xa7, 0xa3, 0xdd, 0xe9, 0xc5, 0xdf, 0x18, 0x33, 0xf3, 0x18, 0x39, 0x65, 0x32, 0xd6, 0xd6, 0x19, 0x6d, 0xb9, 0xb5, - 0x73, 0x95, 0xf5, 0x64, 0xe0, 0x77, 0x82, 0xe4, 0xe7, 0x47, 0x39, 0x68, 0x44, 0x20, 0xa8, 0xdd, 0xae, 0x51, 0xc8, - 0x86, 0x03, 0x33, 0xc7, 0x7f, 0x67, 0x6d, 0xfb, 0x3e, 0x79, 0x9b, 0xf5, 0x62, 0x76, 0xc0, 0xf5, 0xc6, 0x46, 0x73, - 0x64, 0x6e, 0x57, 0x23, 0x1b, 0x3a, 0xdc, 0x91, 0x50, 0xdf, 0x1c, 0x99, 0x67, 0xc7, 0x7c, 0x69, 0x44, 0x70, 0x36, - 0x3a, 0x02, 0xc3, 0x41, 0x9b, 0xeb, 0xbf, 0x49, 0xf2, 0x3d, 0x93, 0x18, 0xe0, 0x80, 0x0d, 0xb2, 0x7a, 0x27, 0x0b, - 0x42, 0xc5, 0x2d, 0x1d, 0xf0, 0x72, 0x9f, 0x07, 0x14, 0x6f, 0xa2, 0x52, 0x72, 0xbd, 0x39, 0x13, 0x15, 0x9a, 0xbb, - 0x7b, 0xe3, 0x6d, 0xab, 0xf1, 0x42, 0xfd, 0xfb, 0x7a, 0x97, 0xda, 0xdf, 0xfc, 0xb1, 0xe9, 0xbb, 0x2c, 0x3f, 0x6b, - 0x51, 0xa7, 0xe7, 0x22, 0xe3, 0x79, 0xd3, 0x2e, 0xd1, 0x1e, 0x46, 0xaa, 0xc9, 0x6a, 0x09, 0xcd, 0x8d, 0xd8, 0xe6, - 0x1d, 0xb7, 0x3a, 0xe0, 0x55, 0x98, 0x55, 0xcd, 0x89, 0x78, 0xef, 0x49, 0xe0, 0x7a, 0xea, 0xc9, 0xda, 0x84, 0xdb, - 0xa1, 0x57, 0x76, 0xb3, 0x33, 0x86, 0xce, 0xa7, 0xd5, 0x3f, 0xd9, 0x47, 0xf0, 0x9b, 0x93, 0xcd, 0xbf, 0x37, 0x35, - 0xa5, 0xc9, 0xdb, 0x93, 0x69, 0xd6, 0x93, 0xa7, 0x1b, 0xc3, 0xd9, 0x96, 0xf6, 0xd3, 0xe6, 0xc3, 0x6c, 0xda, 0x7f, - 0x29, 0xdf, 0x54, 0x85, 0x49, 0xa9, 0xff, 0x04, 0x96, 0x7a, 0x64, 0xa1, 0xf7, 0x1a, 0x43, 0xfc, 0xaa, 0x0a, 0x07, - 0x17, 0x35, 0xdd, 0x0f, 0xe3, 0xdd, 0x68, 0xe2, 0xd6, 0xe5, 0x65, 0x69, 0xce, 0x6a, 0xc4, 0x49, 0xee, 0x49, 0xab, - 0xeb, 0x5d, 0xe6, 0x39, 0xb4, 0xcb, 0xbf, 0x17, 0x08, 0xb7, 0x26, 0x28, 0x68, 0x5d, 0x6a, 0x9b, 0x75, 0x7e, 0x16, - 0x58, 0xfe, 0x1b, 0x59, 0x4f, 0xd7, 0x57, 0xb1, 0xeb, 0x97, 0x2a, 0x3f, 0xff, 0x14, 0xfe, 0x5e, 0xf4, 0xa4, 0xf9, - 0xeb, 0xc1, 0xd9, 0xe7, 0xf9, 0x9f, 0xa3, 0x4c, 0x9b, 0x5a, 0x75, 0xeb, 0x29, 0xfc, 0xf3, 0x78, 0x28, 0x66, 0xb3, - 0xf1, 0xd7, 0x56, 0xf3, 0x3b, 0x84, 0x57, 0xff, 0xf1, 0xe2, 0xe7, 0x2f, 0xcd, 0xc0, 0x7c, 0xe8, 0x9f, 0xe6, 0x6c, - 0xea, 0x62, 0xfd, 0x17, 0x29, 0xeb, 0xeb, 0x3b, 0x6f, 0x4c, 0x34, 0xac, 0xf8, 0xb6, 0xe9, 0xd6, 0x6c, 0x56, 0x47, - 0x95, 0x7f, 0xe1, 0xda, 0xbf, 0x3d, 0xf5, 0x19, 0x04, 0xf9, 0xbc, 0x93, 0x7a, 0xde, 0x18, 0xee, 0x96, 0x14, 0xf6, - 0xd9, 0x72, 0xef, 0xd7, 0x0b, 0x3f, 0x1e, 0x2f, 0xca, 0xd6, 0x51, 0x37, 0x59, 0x59, 0x35, 0xd7, 0x7e, 0xb1, 0x26, - 0x39, 0xdb, 0x15, 0x38, 0xff, 0xb4, 0x7c, 0x3c, 0xfe, 0xe7, 0xe4, 0x69, 0x5d, 0x8e, 0x66, 0x30, 0xe3, 0x3d, 0x9a, - 0x27, 0x9a, 0x37, 0x26, 0xd3, 0x66, 0xbf, 0xfd, 0x10, 0xdf, 0x9a, 0x6e, 0xdd, 0x9b, 0xaf, 0xf8, 0x01, 0x57, 0xcc, - 0xa9, 0xef, 0x5a, 0xf9, 0x5d, 0x4f, 0x0d, 0x71, 0xc1, 0xd8, 0x04, 0x12, 0x8f, 0xfd, 0xdf, 0xc1, 0xd8, 0x0f, 0xbd, - 0x97, 0xde, 0x6c, 0x11, 0xdf, 0x09, 0x61, 0xd7, 0xac, 0x94, 0x73, 0x91, 0x8e, 0xd8, 0xc6, 0x70, 0x9c, 0xf9, 0x40, - 0x45, 0xdb, 0x27, 0xef, 0x37, 0x3e, 0xea, 0x77, 0xa1, 0xf6, 0xe0, 0xfa, 0xe1, 0xf2, 0xb5, 0x78, 0xef, 0x9f, 0x09, - 0xe1, 0x65, 0x03, 0x62, 0x5e, 0xf1, 0xee, 0xf6, 0x3f, 0x46, 0xc5, 0x29, 0x14, 0x75, 0xa2, 0xb2, 0x66, 0xdb, 0x66, - 0xf6, 0x7d, 0xb4, 0x78, 0xe8, 0x40, 0xcd, 0xc7, 0xfb, 0x84, 0xc8, 0xa3, 0x8b, 0x74, 0x97, 0xef, 0xa7, 0x12, 0x08, - 0xec, 0x11, 0x05, 0x76, 0x0d, 0xf2, 0x69, 0xd7, 0x83, 0xbf, 0xc0, 0x9b, 0xb0, 0xb1, 0xb9, 0x7a, 0xb7, 0x73, 0xc8, - 0x1e, 0xae, 0xe6, 0xc5, 0xfa, 0x14, 0x40, 0x12, 0x9b, 0x84, 0x80, 0xf9, 0x3f, 0xb9, 0xa0, 0x86, 0xad, 0xd7, 0xe9, - 0xe7, 0x17, 0xa3, 0xee, 0xd4, 0xa4, 0x59, 0x47, 0x18, 0xe9, 0x5e, 0x78, 0xb5, 0xa1, 0x13, 0x1e, 0x72, 0x8c, 0xf5, - 0x8a, 0xd2, 0x4a, 0x0b, 0xee, 0xd4, 0x47, 0x9d, 0x95, 0x9f, 0x1b, 0x90, 0x88, 0x6c, 0x95, 0x0d, 0xee, 0x32, 0xb3, - 0xf7, 0x0a, 0x6e, 0x58, 0xa5, 0x36, 0x2f, 0xa1, 0xce, 0xf8, 0x3d, 0x57, 0x53, 0x6a, 0xeb, 0xab, 0x6e, 0xde, 0xc4, - 0xcf, 0xed, 0xc5, 0x42, 0x7a, 0xc3, 0x2e, 0xad, 0x0d, 0x48, 0xe0, 0xea, 0x1b, 0xda, 0xed, 0xd4, 0x68, 0xc4, 0x40, - 0x3e, 0x4e, 0x82, 0xf3, 0x5c, 0x33, 0x53, 0x18, 0xef, 0x1a, 0x6a, 0x65, 0xd1, 0x2d, 0xc7, 0x45, 0x93, 0xb7, 0xed, - 0xff, 0x5d, 0x46, 0x8e, 0xeb, 0xe1, 0x0c, 0xe0, 0x36, 0x0f, 0xa0, 0x9f, 0x55, 0x17, 0x56, 0xb9, 0x99, 0x3f, 0xdd, - 0x1a, 0x0c, 0x2a, 0x1f, 0x7a, 0x98, 0x72, 0xfc, 0x46, 0x4e, 0xff, 0x11, 0xb0, 0x6b, 0xeb, 0xb9, 0x96, 0x7b, 0xde, - 0xec, 0xc5, 0x7b, 0x33, 0x9d, 0xcd, 0x4c, 0x99, 0xf5, 0x58, 0xc5, 0x94, 0x13, 0x5f, 0xdb, 0xd5, 0xb7, 0x8b, 0xef, - 0xf6, 0xe1, 0x93, 0x0d, 0x4e, 0x01, 0x2b, 0x68, 0x28, 0x88, 0x83, 0xca, 0xcf, 0xf7, 0x6f, 0xee, 0x98, 0xdc, 0x06, - 0xc9, 0xf4, 0x6a, 0xe1, 0x3a, 0x9e, 0xf4, 0x17, 0x16, 0xfd, 0x59, 0x2b, 0xa1, 0xbf, 0x00, 0xc3, 0x07, 0x6e, 0xcf, - 0x99, 0xe9, 0xdc, 0xc5, 0xa2, 0x7c, 0x9a, 0x71, 0x2b, 0xb9, 0x9b, 0x33, 0x6a, 0x4d, 0x73, 0x00, 0x90, 0x16, 0x4a, - 0x8d, 0x3f, 0x51, 0xd5, 0xa1, 0xa4, 0xc6, 0xb7, 0x91, 0x2a, 0x74, 0x74, 0x59, 0xe4, 0xa7, 0x8b, 0x2b, 0x62, 0xe1, - 0x75, 0x70, 0x7b, 0x8a, 0xe1, 0x8b, 0xef, 0x99, 0xd3, 0xf2, 0x83, 0xca, 0x37, 0x85, 0xe2, 0x6c, 0xd8, 0x18, 0x79, - 0xeb, 0xfe, 0xd4, 0x12, 0x34, 0x7c, 0x8b, 0xde, 0x9a, 0x57, 0xff, 0xed, 0x69, 0x15, 0xa0, 0x5b, 0x1c, 0xe1, 0xe9, - 0x0e, 0x8a, 0x66, 0xee, 0xa9, 0x78, 0x51, 0x06, 0xca, 0xe4, 0x75, 0x3f, 0xe3, 0x45, 0x70, 0x52, 0x68, 0x9f, 0xd7, - 0xcf, 0xeb, 0x05, 0x55, 0x33, 0xc9, 0xe9, 0xed, 0xc2, 0xbc, 0xe1, 0xfb, 0xeb, 0x16, 0x5f, 0x67, 0x29, 0x53, 0xb1, - 0x1d, 0x94, 0xd1, 0x6f, 0x0b, 0x60, 0xbe, 0xfa, 0x92, 0x89, 0x05, 0x9d, 0xac, 0xb9, 0x59, 0xcd, 0xf7, 0xb6, 0x67, - 0x7e, 0x8f, 0xe0, 0xe5, 0x5b, 0xa5, 0x68, 0xeb, 0x67, 0x95, 0x67, 0x2d, 0x30, 0x77, 0x08, 0x31, 0x37, 0x91, 0x06, - 0x8b, 0x02, 0xf2, 0xdd, 0xcd, 0x4b, 0xcb, 0x28, 0xf3, 0x68, 0xde, 0xfc, 0xb3, 0x5e, 0x50, 0x07, 0xa4, 0x17, 0xdf, - 0xb9, 0xdc, 0x40, 0x42, 0x8b, 0x7b, 0xa1, 0xc6, 0xdb, 0xe8, 0x71, 0xca, 0xac, 0x3c, 0x40, 0xb2, 0x86, 0x0e, 0x5a, - 0xdd, 0x87, 0x74, 0x5c, 0x1c, 0x5f, 0xa3, 0xe9, 0xfb, 0x26, 0xde, 0x4e, 0x74, 0x35, 0x79, 0x4f, 0xd9, 0x6d, 0x96, - 0x81, 0x12, 0xcb, 0xcb, 0x0b, 0x79, 0x27, 0xac, 0xa5, 0xa4, 0xb9, 0x0e, 0x13, 0x67, 0x83, 0xfa, 0xeb, 0x99, 0x97, - 0x5e, 0xd6, 0x3e, 0xe0, 0x1b, 0x85, 0x0a, 0xee, 0xe7, 0x09, 0x35, 0x82, 0xfd, 0x20, 0x45, 0xea, 0x41, 0x9d, 0x30, - 0xa3, 0x06, 0x23, 0x69, 0xba, 0xb4, 0x14, 0x67, 0x4e, 0xfa, 0x8b, 0x8a, 0xd2, 0x85, 0x5d, 0xbe, 0xad, 0x62, 0xa9, - 0x4e, 0x6f, 0x63, 0xa4, 0x3c, 0x6a, 0xde, 0x9b, 0xb7, 0x45, 0xde, 0x4e, 0x1b, 0x12, 0x22, 0xe9, 0x05, 0x72, 0xd9, - 0x3a, 0x3f, 0x84, 0xee, 0xe7, 0x2c, 0x1e, 0xc1, 0xa6, 0x84, 0x51, 0x90, 0xeb, 0x32, 0xd7, 0x7b, 0x43, 0x03, 0x13, - 0xf2, 0x63, 0x7e, 0x96, 0x80, 0xa5, 0x6d, 0xdd, 0x7a, 0x67, 0x7c, 0x68, 0x99, 0x43, 0xef, 0x96, 0x00, 0x32, 0xb7, - 0x6b, 0xf6, 0xae, 0xd6, 0x39, 0x99, 0x38, 0x24, 0x35, 0xa0, 0xef, 0x19, 0x75, 0xfa, 0xc6, 0x32, 0xb1, 0x48, 0xa4, - 0xa6, 0x37, 0x89, 0x95, 0xe6, 0xb1, 0xa7, 0xaf, 0x4e, 0x3d, 0x03, 0xbe, 0x36, 0xf7, 0x9a, 0xdd, 0xc7, 0x06, 0xec, - 0xb0, 0xd0, 0xc6, 0xee, 0x02, 0xe6, 0xf2, 0xa6, 0xdd, 0x4e, 0xa8, 0x3c, 0xba, 0x71, 0xcc, 0x0d, 0xc1, 0x40, 0x7a, - 0x11, 0x8d, 0xa2, 0xfc, 0xbe, 0xea, 0x49, 0xec, 0x75, 0x07, 0x76, 0xb7, 0xfb, 0xb3, 0x23, 0x55, 0xb8, 0xbd, 0x4c, - 0x06, 0x7e, 0xb2, 0x3d, 0x23, 0x79, 0x68, 0x2a, 0xf6, 0x80, 0x26, 0x1b, 0xde, 0x05, 0xe2, 0x86, 0xf1, 0xbe, 0x0f, - 0xfb, 0xfb, 0x92, 0xaf, 0x09, 0xa8, 0x71, 0x20, 0x41, 0xb5, 0x64, 0xcf, 0x5f, 0xae, 0xcc, 0xe6, 0x32, 0xcc, 0x26, - 0x5e, 0xb9, 0xa8, 0xf3, 0xfe, 0xe9, 0xb5, 0x83, 0xfb, 0x2d, 0x35, 0x94, 0x9b, 0xf1, 0xcc, 0xff, 0x47, 0x4d, 0x61, - 0x43, 0xe0, 0x01, 0x59, 0x69, 0x21, 0xb9, 0xb2, 0xc0, 0xa7, 0x6f, 0x0e, 0x75, 0x3e, 0x8c, 0xe7, 0x2d, 0x66, 0x65, - 0x46, 0xe4, 0x62, 0x7c, 0x80, 0x48, 0x36, 0x50, 0x0c, 0x13, 0x2e, 0x60, 0xf4, 0xd1, 0x65, 0xda, 0xa2, 0x79, 0x20, - 0xed, 0xca, 0xd6, 0x1f, 0xcf, 0x0c, 0xbc, 0x92, 0xff, 0xc6, 0x79, 0x5c, 0x86, 0x39, 0xbe, 0xd2, 0xd8, 0x9e, 0x92, - 0xe7, 0xc2, 0x15, 0x19, 0xe5, 0xa1, 0xaa, 0x3c, 0xe9, 0x9c, 0xbb, 0xbb, 0x7a, 0x32, 0x1d, 0xd9, 0x0c, 0x60, 0x6e, - 0x69, 0xda, 0xd8, 0xb1, 0x52, 0x5d, 0xf2, 0x10, 0x6f, 0x30, 0x18, 0xec, 0xcb, 0xd6, 0xad, 0x3f, 0xdb, 0x28, 0x68, - 0xb8, 0x42, 0x10, 0x58, 0x82, 0x81, 0xab, 0x92, 0x04, 0xe9, 0x0f, 0x45, 0xde, 0xb9, 0x29, 0x79, 0x4f, 0x3d, 0xb9, - 0x78, 0x25, 0x79, 0x70, 0x68, 0x09, 0x70, 0xd1, 0x7f, 0xd6, 0x5a, 0xc9, 0xda, 0x52, 0xbe, 0x3b, 0xce, 0x3e, 0x76, - 0xba, 0x99, 0x05, 0xd9, 0xd2, 0x87, 0x51, 0x6c, 0xcf, 0xbd, 0x1e, 0xe6, 0xa1, 0x25, 0xb0, 0x90, 0xb9, 0x59, 0xda, - 0x01, 0xf1, 0x2d, 0x9a, 0xd4, 0x66, 0xc9, 0xff, 0xc4, 0x2d, 0x6f, 0x20, 0x44, 0xd4, 0xb6, 0xbe, 0x6b, 0x68, 0x74, - 0x12, 0x27, 0xb9, 0x41, 0xde, 0x7f, 0x53, 0x0a, 0x28, 0x50, 0xb6, 0x54, 0x76, 0x92, 0xdf, 0x7f, 0xe2, 0x21, 0x84, - 0x66, 0x36, 0x5e, 0x5a, 0xb5, 0x6e, 0x33, 0x6b, 0x09, 0xa7, 0x91, 0x30, 0xb3, 0x9b, 0x83, 0xae, 0x2a, 0x12, 0x8e, - 0x92, 0x34, 0xa6, 0x48, 0x47, 0x38, 0xdc, 0x69, 0xbe, 0xbb, 0x93, 0xba, 0x63, 0x01, 0x6b, 0x9b, 0x39, 0x6e, 0x01, - 0x02, 0x8c, 0xfa, 0x5d, 0x03, 0xd1, 0x44, 0x93, 0x53, 0xa8, 0xe5, 0x8d, 0xdc, 0xd5, 0xa3, 0x5b, 0xf3, 0x58, 0x83, - 0xf6, 0x59, 0xfd, 0x29, 0x21, 0xe0, 0xb6, 0xa2, 0xde, 0x93, 0x81, 0x15, 0xa9, 0x0b, 0xc1, 0x35, 0x10, 0x58, 0xef, - 0x8c, 0xd6, 0x3e, 0x35, 0x26, 0xd2, 0xfe, 0xa2, 0xc1, 0x05, 0x24, 0x04, 0x02, 0x98, 0x97, 0x65, 0xb3, 0x84, 0x4f, - 0x22, 0x39, 0x80, 0xaa, 0xc7, 0xa5, 0xb7, 0x5a, 0x4a, 0x44, 0xc3, 0xa3, 0x1a, 0x01, 0xd7, 0xed, 0x02, 0xe5, 0x03, - 0x46, 0x58, 0x39, 0x85, 0x79, 0x26, 0xa4, 0x6a, 0x52, 0x8c, 0xba, 0x99, 0x4d, 0xa4, 0x3c, 0x33, 0xce, 0x53, 0x49, - 0xd4, 0x69, 0xfd, 0x6b, 0xe5, 0x4b, 0x1b, 0x44, 0xdb, 0xf0, 0xd9, 0x70, 0x7d, 0xac, 0xb9, 0x1e, 0x6d, 0x06, 0xa6, - 0xb5, 0xab, 0x59, 0x04, 0x88, 0x7a, 0x2a, 0xbb, 0xab, 0xcf, 0x5c, 0x90, 0x87, 0x1a, 0x3f, 0xf2, 0xe2, 0x14, 0xec, - 0x4a, 0x3f, 0xbf, 0x69, 0x28, 0x40, 0x18, 0x2f, 0x1d, 0xf1, 0x92, 0x55, 0x5e, 0x6c, 0x8a, 0x36, 0xee, 0x30, 0xf6, - 0x7a, 0xb4, 0x02, 0x52, 0x8f, 0x4d, 0xdd, 0x49, 0x96, 0xac, 0x8b, 0x73, 0xca, 0xab, 0xb8, 0x67, 0xba, 0x34, 0x7d, - 0x4c, 0xfd, 0x87, 0x4a, 0xe7, 0xc4, 0x0a, 0xe1, 0x7f, 0x4b, 0xca, 0xce, 0x2a, 0x65, 0x5a, 0x90, 0x88, 0xb5, 0x20, - 0x0a, 0x9c, 0xef, 0x04, 0xc9, 0xc2, 0xb2, 0x88, 0x24, 0x4f, 0x63, 0x79, 0xad, 0x4b, 0xf0, 0x24, 0x7b, 0xa0, 0xc8, - 0x87, 0x5d, 0xd9, 0x25, 0xc1, 0xdc, 0xf3, 0x83, 0xb4, 0x61, 0xa2, 0xb0, 0x0f, 0x5a, 0xf2, 0xb8, 0x66, 0x01, 0x38, - 0x3d, 0xf4, 0x6b, 0xef, 0xf9, 0xd8, 0x36, 0x7e, 0x8b, 0xe0, 0x5d, 0x4e, 0x84, 0xfb, 0x39, 0x97, 0x04, 0xcb, 0xaf, - 0xae, 0x53, 0x66, 0xb1, 0x5a, 0x83, 0x8a, 0x97, 0x3b, 0xbc, 0x6d, 0xdd, 0x5f, 0x96, 0xf0, 0xbe, 0x93, 0xcd, 0x70, - 0x37, 0x1d, 0x91, 0xcd, 0xc4, 0x39, 0x92, 0x8a, 0x44, 0x5c, 0x75, 0x32, 0x8d, 0xc5, 0x87, 0x39, 0x01, 0x04, 0x93, - 0xfa, 0x37, 0x2a, 0x84, 0x36, 0x24, 0x74, 0x7c, 0xec, 0xf2, 0xb5, 0x61, 0xed, 0xd6, 0xd7, 0xca, 0xd6, 0xbe, 0x75, - 0x23, 0x8a, 0x0a, 0xed, 0x58, 0x2c, 0x86, 0x64, 0x8c, 0x5e, 0xe9, 0x37, 0xd6, 0x34, 0xc9, 0xe2, 0xe1, 0xab, 0xdb, - 0x68, 0x31, 0x0e, 0x62, 0x17, 0x78, 0xfb, 0xd1, 0xec, 0x6d, 0x2d, 0x29, 0x7e, 0xff, 0xea, 0x8c, 0xa2, 0x56, 0xfc, - 0x43, 0xe9, 0xcf, 0xba, 0xc0, 0x25, 0x2a, 0x03, 0x2d, 0x66, 0xf8, 0x83, 0x48, 0xab, 0x57, 0xc8, 0xb9, 0xcf, 0xb9, - 0x3e, 0x24, 0xff, 0xc5, 0x03, 0x6f, 0x28, 0x8b, 0x42, 0xa8, 0xeb, 0x11, 0x37, 0x52, 0xc4, 0x62, 0xdd, 0x7d, 0x79, - 0xd0, 0x16, 0x39, 0x0b, 0x66, 0xcd, 0x6e, 0xca, 0x34, 0xdc, 0x85, 0x4b, 0x8b, 0x6e, 0xd3, 0x6c, 0x13, 0xbc, 0x0c, - 0x3b, 0xe9, 0x38, 0x7a, 0x67, 0x03, 0xa1, 0x28, 0x08, 0x10, 0x4a, 0x1a, 0xfa, 0x67, 0x28, 0x6d, 0xa5, 0x98, 0x87, - 0x96, 0x72, 0xca, 0x65, 0x21, 0xe6, 0x7e, 0x42, 0x86, 0x81, 0xfb, 0xc5, 0x8d, 0xdc, 0xb4, 0x16, 0x48, 0x16, 0x89, - 0x1e, 0xf5, 0xbc, 0x7b, 0x72, 0x95, 0xc5, 0xa0, 0x07, 0x44, 0x0e, 0x70, 0xbd, 0x9b, 0xaa, 0x67, 0x25, 0xc1, 0xc0, - 0xd1, 0x7d, 0xc0, 0x5a, 0x5f, 0x5b, 0xc3, 0x44, 0x2b, 0x04, 0x5e, 0x42, 0x8d, 0x19, 0x12, 0xed, 0x03, 0xf5, 0x90, - 0x98, 0x00, 0x34, 0x05, 0xaf, 0xb1, 0x25, 0xd0, 0xb6, 0x6b, 0x4c, 0x09, 0x14, 0xb0, 0x32, 0xd5, 0x88, 0xc6, 0xcc, - 0x43, 0x47, 0x8c, 0xc4, 0x71, 0xee, 0x47, 0xe4, 0xc1, 0x86, 0xd4, 0x21, 0xda, 0xfe, 0xa6, 0x7e, 0xb0, 0xc6, 0x99, - 0x31, 0x8d, 0x5c, 0x20, 0x1c, 0xaf, 0x41, 0xe1, 0x86, 0xb1, 0x61, 0xfb, 0xaa, 0x26, 0xab, 0x3a, 0x23, 0x32, 0xab, - 0x9e, 0x39, 0xec, 0x57, 0xf1, 0x47, 0x97, 0x58, 0x49, 0xb3, 0xe1, 0x9b, 0xa4, 0xd4, 0xb3, 0xe5, 0xd5, 0x37, 0x46, - 0x22, 0x3d, 0xdd, 0x07, 0x5c, 0x70, 0x0d, 0xa2, 0x9b, 0x92, 0x9f, 0x7d, 0x32, 0x6a, 0x00, 0x8f, 0xda, 0xb4, 0x43, - 0x15, 0x14, 0x83, 0x81, 0x91, 0xa6, 0xd3, 0xd2, 0x98, 0x2e, 0xd1, 0x6c, 0xa0, 0x99, 0xc7, 0x78, 0x22, 0xd2, 0x89, - 0xed, 0x1d, 0xcf, 0x57, 0x2d, 0x1a, 0x59, 0xad, 0xda, 0x20, 0xcb, 0x6f, 0xd3, 0x7a, 0xad, 0x32, 0x32, 0xde, 0x96, - 0x01, 0xf1, 0x47, 0x28, 0x0b, 0x86, 0x8a, 0x8a, 0x24, 0xc5, 0x14, 0x15, 0x97, 0xc6, 0x47, 0xae, 0x02, 0x74, 0x19, - 0x56, 0xad, 0xcd, 0xab, 0xf0, 0xf6, 0x49, 0x0c, 0xf7, 0x41, 0xa9, 0xc2, 0xe9, 0xe5, 0x62, 0xb6, 0x3c, 0x56, 0xe1, - 0x8f, 0x5d, 0x75, 0x12, 0x3c, 0x6d, 0xcf, 0xde, 0x39, 0xd5, 0xe8, 0x54, 0x5f, 0x1c, 0xb2, 0x63, 0x2f, 0xce, 0x18, - 0x88, 0x90, 0x93, 0xd9, 0x6a, 0x17, 0x7d, 0x92, 0xee, 0x35, 0x02, 0x7d, 0x39, 0xc2, 0x55, 0xcf, 0x9b, 0x13, 0xca, - 0x6c, 0x35, 0xd2, 0x51, 0x50, 0x9a, 0x21, 0x8a, 0xe1, 0x29, 0x12, 0x07, 0x9e, 0xe6, 0xc4, 0x61, 0xc2, 0x00, 0x25, - 0x6c, 0x73, 0xa2, 0x8b, 0xf6, 0x9f, 0x61, 0x96, 0xef, 0x59, 0xc6, 0x96, 0xe6, 0xd1, 0x80, 0x14, 0x01, 0x26, 0x95, - 0x62, 0x15, 0xff, 0x60, 0x2e, 0x1c, 0x0f, 0x13, 0x83, 0xc9, 0xcf, 0xb0, 0x0f, 0xe5, 0x4d, 0x0f, 0x2f, 0x8f, 0xca, - 0x81, 0x34, 0xb1, 0x4a, 0x3d, 0x45, 0x6b, 0xa4, 0x76, 0xdb, 0x0d, 0x6c, 0xb9, 0xd2, 0x0d, 0xd5, 0xf8, 0xa2, 0x08, - 0x46, 0xff, 0x52, 0x03, 0xe1, 0xe3, 0x93, 0x18, 0x63, 0x30, 0x29, 0x7a, 0x53, 0x3b, 0x30, 0xed, 0x9b, 0x52, 0x75, - 0x2d, 0x80, 0x8f, 0x4d, 0x15, 0xf8, 0xcf, 0xc1, 0x29, 0x22, 0xe6, 0xce, 0x58, 0x4c, 0x56, 0x67, 0x50, 0x97, 0xfb, - 0xdf, 0x0f, 0x1d, 0x41, 0xd8, 0xbf, 0x4e, 0xe7, 0xe8, 0x2c, 0x40, 0x26, 0x7b, 0xe0, 0x82, 0x58, 0x2a, 0xc6, 0x31, - 0x8f, 0x46, 0x84, 0xa5, 0x22, 0x6b, 0xbc, 0x8f, 0x4b, 0x49, 0xf3, 0xb5, 0x0e, 0x1c, 0x10, 0x85, 0x83, 0xf9, 0xad, - 0x41, 0xdf, 0x42, 0xc8, 0xbc, 0xaa, 0x72, 0x00, 0xa8, 0x8b, 0x71, 0x31, 0xae, 0x25, 0x24, 0x23, 0x3f, 0xee, 0xa8, - 0x1d, 0xa3, 0xa1, 0xc9, 0xc7, 0xa7, 0xeb, 0x54, 0xd3, 0xbd, 0xfa, 0x87, 0x1a, 0x8a, 0xf9, 0x7b, 0x99, 0x18, 0x24, - 0x6a, 0x96, 0xec, 0xbd, 0xf8, 0xe9, 0x3c, 0x72, 0x9e, 0x9a, 0x9e, 0x1a, 0xc6, 0xac, 0x56, 0x37, 0x26, 0x5b, 0xa6, - 0x76, 0xe4, 0x0e, 0xb4, 0x3a, 0xe3, 0xeb, 0xf4, 0x06, 0xe2, 0x78, 0x2f, 0x24, 0x6e, 0x45, 0x47, 0x8a, 0xd2, 0x8f, - 0x2b, 0x23, 0xa0, 0x46, 0xd1, 0xa1, 0x2a, 0x99, 0xe6, 0x6f, 0x86, 0x5c, 0x55, 0x41, 0x87, 0x55, 0x50, 0x4d, 0x31, - 0x33, 0xcd, 0xca, 0xa1, 0x91, 0x06, 0x14, 0x4a, 0x69, 0x0c, 0x8a, 0x5a, 0xaa, 0x90, 0xec, 0x79, 0x89, 0xa5, 0xe7, - 0x38, 0x09, 0x1d, 0xca, 0xa6, 0x83, 0xe7, 0x51, 0xb8, 0x24, 0xec, 0x79, 0xcd, 0x0c, 0xd3, 0x64, 0x2b, 0x2d, 0xab, - 0x5a, 0x54, 0x42, 0x21, 0xd7, 0xe7, 0xa5, 0x52, 0x9e, 0x46, 0xb8, 0x8d, 0xa7, 0x34, 0x5a, 0x45, 0xf9, 0x0a, 0xfb, - 0x38, 0xf9, 0x14, 0xf9, 0x77, 0xa0, 0xac, 0xbe, 0x14, 0x40, 0x06, 0x22, 0x09, 0x56, 0x02, 0xf9, 0x7e, 0xf1, 0x82, - 0x8b, 0xf0, 0x8b, 0x00, 0x5e, 0x45, 0xbc, 0xce, 0x74, 0x43, 0x9e, 0xaf, 0x7f, 0xfd, 0x9f, 0xea, 0xf5, 0x9f, 0x29, - 0x1c, 0x6e, 0x80, 0xf4, 0x06, 0xd2, 0x2c, 0xe8, 0x1f, 0xad, 0x57, 0x5f, 0xa9, 0x4b, 0x99, 0xbd, 0x8e, 0xc2, 0x77, - 0xb7, 0x74, 0x6d, 0xf4, 0x6c, 0x24, 0x42, 0xb3, 0x52, 0xfa, 0x5e, 0x48, 0x5a, 0x06, 0x6a, 0xe4, 0x8b, 0xbd, 0xd9, - 0x80, 0x69, 0x6b, 0x9c, 0xc2, 0xed, 0xbd, 0xa4, 0xc6, 0x5b, 0x8b, 0x13, 0xa0, 0xca, 0x62, 0x8a, 0xef, 0xd8, 0x79, - 0x20, 0xf7, 0xc1, 0xa3, 0x36, 0x7e, 0xbb, 0x73, 0x7b, 0x3e, 0x0d, 0xec, 0x12, 0x51, 0x0e, 0xa2, 0x6d, 0x58, 0x65, - 0xec, 0xf5, 0x45, 0x84, 0xcd, 0x65, 0x49, 0x83, 0x92, 0x0a, 0xbc, 0xf1, 0xca, 0x5d, 0xb8, 0xb9, 0x3d, 0x82, 0x00, - 0xfa, 0x4d, 0x13, 0xe6, 0x76, 0x88, 0x54, 0x18, 0x77, 0xe9, 0x71, 0x52, 0xe6, 0xf9, 0x77, 0x7a, 0x1c, 0x33, 0xc6, - 0xce, 0xcc, 0x33, 0xab, 0xd0, 0xd0, 0xb2, 0xa1, 0xf1, 0x53, 0xb0, 0x5b, 0x64, 0x14, 0x6b, 0x45, 0x01, 0xfb, 0xa0, - 0x14, 0x68, 0x79, 0x10, 0x8a, 0xea, 0x22, 0x3e, 0xc1, 0xf1, 0xe1, 0x8f, 0x86, 0x03, 0x25, 0x86, 0x16, 0x09, 0xb6, - 0xd8, 0x23, 0x1d, 0x36, 0xe5, 0xa6, 0xde, 0xa9, 0xb3, 0x0a, 0xe7, 0x4d, 0x63, 0x59, 0x07, 0xa5, 0xdf, 0xd5, 0xe3, - 0x75, 0xfd, 0x84, 0x37, 0xf8, 0x5b, 0x29, 0xd5, 0xe3, 0x17, 0xf5, 0x7e, 0x8d, 0x5d, 0xa5, 0x3a, 0x8c, 0xd1, 0xe2, - 0x4f, 0x26, 0xa4, 0x31, 0x2e, 0xec, 0xa1, 0x7e, 0x25, 0x1d, 0x7c, 0x41, 0xd9, 0xf5, 0xc8, 0xc6, 0x64, 0x3d, 0x28, - 0x80, 0xfb, 0xbc, 0x7f, 0xfb, 0xa8, 0x9f, 0x05, 0x39, 0x34, 0x22, 0x45, 0x4d, 0xfc, 0x6e, 0xc8, 0x4d, 0xaa, 0x51, - 0x10, 0xbb, 0x36, 0xa5, 0x76, 0x78, 0x0f, 0xb5, 0xf7, 0x6f, 0x32, 0xa8, 0x00, 0x6a, 0x7b, 0xd3, 0x8f, 0x65, 0x70, - 0x5a, 0x3d, 0x4d, 0x4e, 0x18, 0xa9, 0x01, 0x52, 0x53, 0xc4, 0x66, 0xc2, 0xca, 0xc5, 0xe7, 0xc0, 0x6c, 0xd6, 0xa4, - 0xb3, 0xf6, 0x16, 0x5c, 0x5a, 0x46, 0xdd, 0xef, 0x59, 0xb8, 0xfb, 0x58, 0x06, 0x9f, 0x17, 0x6e, 0xa9, 0x3b, 0x68, - 0x85, 0x2c, 0x46, 0xad, 0xdc, 0x84, 0x43, 0x7b, 0x55, 0x25, 0x30, 0xd6, 0x6f, 0xd3, 0xc6, 0x59, 0x2f, 0x70, 0x60, - 0xe8, 0xbd, 0x1f, 0xb8, 0xac, 0xfc, 0x14, 0x88, 0x61, 0x78, 0xd5, 0xbc, 0x39, 0xe6, 0x8c, 0x17, 0xef, 0x79, 0x7b, - 0x86, 0x73, 0xfb, 0x5c, 0xf1, 0x47, 0xcf, 0x37, 0x65, 0xa3, 0x7a, 0x92, 0x38, 0x33, 0xeb, 0x58, 0x52, 0xf5, 0xc8, - 0x50, 0x2e, 0xee, 0x01, 0xa0, 0x42, 0x32, 0x2a, 0x82, 0x48, 0x23, 0x8d, 0xf2, 0x53, 0xe5, 0x95, 0xea, 0x7d, 0xc2, - 0x44, 0x89, 0x80, 0x19, 0x7c, 0xff, 0xa4, 0xd2, 0x15, 0xbb, 0x1e, 0xe0, 0x1f, 0x11, 0x2b, 0x88, 0x68, 0x16, 0x49, - 0x28, 0x0a, 0x48, 0xc6, 0xef, 0x8e, 0xe5, 0x91, 0x9d, 0x49, 0x88, 0xe0, 0xa0, 0xee, 0x06, 0x08, 0x10, 0xf3, 0x35, - 0x42, 0xbb, 0xfc, 0x2b, 0x3d, 0xae, 0xd7, 0xac, 0x50, 0x87, 0x59, 0x76, 0xa1, 0x01, 0x6f, 0xb3, 0xe8, 0x97, 0xca, - 0x85, 0xef, 0xb5, 0x76, 0xb2, 0xbe, 0xbc, 0xfd, 0xb8, 0x5c, 0x93, 0xd2, 0xc1, 0xd2, 0x02, 0x50, 0xb2, 0xb1, 0xcc, - 0xc6, 0xa9, 0x5c, 0xb5, 0x5e, 0x59, 0x8a, 0xd2, 0x09, 0xc3, 0x76, 0x08, 0x29, 0x1e, 0x8c, 0x6a, 0xc4, 0xcc, 0xb1, - 0xa6, 0xc7, 0xbd, 0xf4, 0x60, 0x8f, 0x7b, 0x3f, 0x84, 0xce, 0x05, 0x3d, 0x62, 0x1e, 0x01, 0xe7, 0x65, 0xe5, 0xa9, - 0x90, 0x69, 0x42, 0x85, 0x38, 0x08, 0x20, 0x33, 0xae, 0x7b, 0x60, 0x4c, 0x99, 0x16, 0x3b, 0x2c, 0x26, 0xb3, 0x81, - 0x82, 0x90, 0x1b, 0x9b, 0x44, 0x0a, 0x39, 0x32, 0x89, 0xa5, 0x07, 0xf6, 0x33, 0x20, 0x6b, 0x3d, 0x8a, 0xd3, 0x9a, - 0x56, 0x44, 0x97, 0x22, 0x70, 0xb9, 0x91, 0xf2, 0x4d, 0x9f, 0xd0, 0x2b, 0x33, 0x47, 0xc3, 0xf7, 0xdb, 0x59, 0x09, - 0xc3, 0x72, 0x7c, 0xec, 0xec, 0x65, 0xfd, 0xe3, 0x39, 0x85, 0x6a, 0x6e, 0x67, 0x2e, 0x5f, 0x32, 0xf9, 0xef, 0x75, - 0x18, 0x48, 0x5e, 0x28, 0x7c, 0x56, 0x13, 0x88, 0xb4, 0x24, 0xa5, 0xe0, 0xad, 0xe1, 0xef, 0x45, 0x15, 0xc6, 0xfd, - 0x87, 0xef, 0xc2, 0xc5, 0x8d, 0xef, 0xaf, 0xea, 0xbe, 0x8a, 0xae, 0xbd, 0x11, 0x90, 0x74, 0xce, 0x96, 0x3b, 0x6c, - 0xa0, 0xd6, 0x5b, 0x84, 0xb2, 0xce, 0xeb, 0x8b, 0xfb, 0x9a, 0x3c, 0xbb, 0x6e, 0x3f, 0xee, 0x02, 0x8f, 0x98, 0xac, - 0xcd, 0xda, 0x42, 0xf3, 0xc8, 0x1a, 0xdc, 0xfd, 0x0c, 0xc3, 0x3d, 0x80, 0x1d, 0x4d, 0xdd, 0xe2, 0x17, 0xde, 0x8b, - 0xf4, 0x3e, 0x65, 0xab, 0xb7, 0xfa, 0xa7, 0xcd, 0x2f, 0x7f, 0x6e, 0x1c, 0x53, 0xa8, 0x61, 0xed, 0xa6, 0xba, 0x27, - 0x33, 0x7b, 0x30, 0x2d, 0x83, 0x14, 0xae, 0x74, 0xf5, 0x55, 0xc0, 0x51, 0xd0, 0x73, 0x42, 0x07, 0x9b, 0x28, 0x34, - 0x8f, 0x5f, 0x10, 0xaa, 0x64, 0xfe, 0xf1, 0x72, 0x65, 0x0c, 0x82, 0xf0, 0xb7, 0x23, 0xd6, 0x8a, 0xa8, 0xb3, 0x63, - 0x7f, 0xcc, 0xd5, 0x04, 0xbf, 0xa4, 0x1e, 0x8e, 0x16, 0xe1, 0x5f, 0xea, 0xb0, 0xdd, 0x61, 0x96, 0x1e, 0x68, 0xdc, - 0xec, 0x37, 0xf0, 0x8d, 0xe8, 0xcc, 0xc2, 0x8e, 0x2f, 0x4b, 0xb5, 0x43, 0x87, 0x43, 0xcd, 0xb0, 0x04, 0x7a, 0x1e, - 0x06, 0xe8, 0xa1, 0x1b, 0x7b, 0xbb, 0x54, 0x07, 0xe5, 0x20, 0x11, 0xbd, 0x87, 0x42, 0xe8, 0xd1, 0x5c, 0x9d, 0xf6, - 0xa8, 0x07, 0x6e, 0x2b, 0x0c, 0xc8, 0x83, 0xfe, 0xe0, 0x63, 0x56, 0x48, 0xd5, 0x45, 0x75, 0x1d, 0x35, 0xad, 0x31, - 0x23, 0x1f, 0xd3, 0x77, 0xbf, 0xbc, 0x21, 0xa2, 0x1d, 0x59, 0xaf, 0x31, 0xce, 0xb0, 0xf2, 0xa1, 0x4c, 0x85, 0x29, - 0xd5, 0x05, 0xdb, 0x63, 0x43, 0x7f, 0xd6, 0x76, 0x19, 0x59, 0xa1, 0x88, 0x8e, 0x60, 0xe1, 0x7f, 0x7c, 0x59, 0xdc, - 0x0a, 0x32, 0xb2, 0xe6, 0xb7, 0x25, 0x39, 0x63, 0x1c, 0xfa, 0xba, 0x5c, 0xce, 0xbb, 0x58, 0x3d, 0xfa, 0xf0, 0x24, - 0xa4, 0x48, 0xd6, 0x3e, 0x86, 0x56, 0x03, 0x43, 0x04, 0x21, 0xf9, 0x66, 0xad, 0xf5, 0x1c, 0x70, 0x12, 0xf3, 0xbb, - 0x0e, 0xec, 0xb7, 0xf3, 0x3c, 0xef, 0x10, 0x10, 0x20, 0xff, 0x1a, 0x62, 0x9c, 0x55, 0xd4, 0x3b, 0xd3, 0xa2, 0xaa, - 0x97, 0x8b, 0x59, 0x61, 0x4d, 0xc7, 0x98, 0x34, 0x54, 0x5e, 0xca, 0xa6, 0x52, 0x17, 0x32, 0x9a, 0xc7, 0x82, 0x7e, - 0x74, 0x79, 0x9d, 0xe1, 0xac, 0xa1, 0x3d, 0x4d, 0xbf, 0x19, 0x00, 0x23, 0x6d, 0x17, 0x61, 0xa2, 0x72, 0x58, 0x95, - 0x23, 0x23, 0x57, 0x59, 0x81, 0x8f, 0x32, 0x3e, 0x6f, 0xa0, 0x05, 0x2e, 0xac, 0x2e, 0x39, 0x92, 0x15, 0xa2, 0xa3, - 0xb8, 0xf1, 0x7e, 0x42, 0x0c, 0x1f, 0xc5, 0x4c, 0x74, 0xd2, 0x8c, 0x63, 0xde, 0xfd, 0x39, 0x08, 0xad, 0x39, 0xa2, - 0xc1, 0xc2, 0x5b, 0x1a, 0x72, 0x98, 0x25, 0xaf, 0xac, 0x48, 0x25, 0xc3, 0x6f, 0x05, 0x2a, 0xd3, 0x29, 0x44, 0x6b, - 0x5c, 0x02, 0xa7, 0xed, 0x27, 0xf3, 0x2e, 0x78, 0x66, 0x0a, 0xe7, 0xc2, 0xf1, 0x62, 0xc6, 0x9a, 0x12, 0x43, 0xb1, - 0x1c, 0x95, 0x0e, 0x79, 0xaa, 0x50, 0x77, 0xab, 0x88, 0x5a, 0x5b, 0xf7, 0x93, 0x7e, 0x52, 0x10, 0x4f, 0x5b, 0x82, - 0x8c, 0x9a, 0x1c, 0xef, 0x7a, 0x34, 0x7a, 0x62, 0x51, 0x6a, 0xa4, 0xb8, 0xf9, 0xee, 0x13, 0x96, 0x31, 0x02, 0xcf, - 0x55, 0x4a, 0x8e, 0x0d, 0x55, 0x99, 0xfd, 0x81, 0xfa, 0x66, 0x82, 0x83, 0xbd, 0x84, 0x22, 0xb5, 0x55, 0x72, 0x82, - 0xe9, 0x83, 0x2e, 0xe5, 0x78, 0x14, 0xf6, 0x8d, 0xda, 0xfc, 0x25, 0x82, 0x0b, 0x2c, 0xb9, 0xcb, 0xa7, 0x33, 0xb5, - 0x45, 0x79, 0x26, 0xb7, 0x88, 0xb8, 0x58, 0x87, 0xda, 0xa3, 0x86, 0x0c, 0xe2, 0x4d, 0xd7, 0x56, 0x0c, 0xc3, 0x27, - 0x29, 0x45, 0x38, 0xef, 0x8a, 0xc1, 0x7d, 0xdb, 0x35, 0xe6, 0x12, 0x8a, 0xc9, 0xdf, 0xdb, 0xfd, 0x2c, 0x2d, 0x15, - 0x5f, 0xb5, 0xdd, 0x1c, 0xe5, 0xf9, 0x23, 0x81, 0xee, 0x71, 0x2c, 0xb7, 0x37, 0x69, 0xe2, 0xb3, 0x3c, 0x7d, 0x9b, - 0x8d, 0xc1, 0x42, 0xfe, 0x7f, 0xb3, 0x14, 0x2f, 0xb0, 0x7a, 0x60, 0x52, 0x90, 0x3b, 0x1a, 0x53, 0xb9, 0x76, 0x6c, - 0x6c, 0x2b, 0xdf, 0x5d, 0x8c, 0x75, 0x32, 0xb5, 0xf2, 0x6d, 0xec, 0xd8, 0xf0, 0xab, 0x68, 0xbe, 0xbb, 0xd8, 0xac, - 0x2b, 0x5e, 0xdb, 0xea, 0x17, 0xdc, 0xf1, 0x9f, 0xc3, 0x71, 0xeb, 0x3c, 0x6f, 0x1e, 0x47, 0x1f, 0xf7, 0x6c, 0xdf, - 0xa5, 0x45, 0x88, 0xf5, 0x97, 0x8c, 0x3d, 0x52, 0xe7, 0xc7, 0xc4, 0xdb, 0xf1, 0xb5, 0xdf, 0xae, 0xe3, 0x88, 0x3a, - 0x55, 0xfe, 0x87, 0x85, 0xe9, 0x53, 0xb3, 0x1e, 0xed, 0xf9, 0x34, 0x4d, 0xdf, 0x09, 0xd2, 0x6d, 0x9a, 0xa6, 0xbf, - 0x15, 0x1d, 0x6d, 0xbc, 0x58, 0xd7, 0x80, 0xd9, 0x3b, 0xa0, 0x6e, 0xf6, 0x41, 0xac, 0xe4, 0x58, 0x62, 0x31, 0xac, - 0xf5, 0x38, 0x6c, 0x44, 0xde, 0x34, 0xfa, 0xe0, 0x62, 0x61, 0x62, 0x07, 0x8c, 0xfc, 0x18, 0x16, 0x86, 0x0e, 0x49, - 0x55, 0xdb, 0x35, 0x7e, 0x38, 0xa9, 0x8f, 0xb0, 0x30, 0x56, 0x13, 0xd9, 0xff, 0x2c, 0xc8, 0x7b, 0x50, 0x60, 0x8b, - 0xeb, 0x4e, 0xe3, 0x52, 0x3a, 0xf0, 0xe5, 0x2b, 0x41, 0x33, 0x39, 0xa0, 0x49, 0x6f, 0x31, 0xb6, 0x73, 0x9e, 0x44, - 0x2f, 0x0e, 0x29, 0x4d, 0xa1, 0x88, 0xae, 0xaa, 0xa4, 0xa9, 0x2d, 0xfb, 0x38, 0x1a, 0xac, 0x7d, 0xe9, 0x70, 0xf4, - 0x58, 0x01, 0xc3, 0xca, 0x7f, 0xa7, 0x29, 0x07, 0xea, 0x2e, 0xd8, 0x7c, 0xf4, 0x15, 0x0e, 0x13, 0x7c, 0x1d, 0x34, - 0x59, 0x59, 0xa2, 0x9b, 0xda, 0x50, 0x78, 0x4c, 0xfb, 0x6d, 0x0c, 0x38, 0x54, 0xe1, 0x25, 0x37, 0x61, 0xd5, 0x2d, - 0xc7, 0xfd, 0xad, 0x4c, 0x78, 0xb9, 0x1d, 0x26, 0x5b, 0xc3, 0xd6, 0x40, 0x3c, 0x63, 0x18, 0x0c, 0xa2, 0xa1, 0xc5, - 0x25, 0x89, 0x57, 0x30, 0x6b, 0x64, 0xcf, 0x45, 0xa3, 0x64, 0x58, 0x63, 0xdc, 0x98, 0x50, 0xf1, 0x7a, 0x21, 0x86, - 0xf3, 0x69, 0x9a, 0xa6, 0x28, 0x1f, 0x58, 0x70, 0x83, 0x05, 0xad, 0x0a, 0x87, 0x03, 0x9a, 0x6d, 0x8b, 0x46, 0x8b, - 0xd2, 0xa4, 0x4d, 0x25, 0x9d, 0xc4, 0x57, 0xfa, 0xb9, 0x8c, 0x75, 0xb6, 0xaa, 0x26, 0x8c, 0x38, 0xda, 0x0f, 0x8d, - 0x52, 0x75, 0x10, 0xa1, 0x3a, 0x00, 0xce, 0x26, 0x18, 0xf0, 0xd0, 0x46, 0xf7, 0x03, 0x54, 0x17, 0x32, 0xb4, 0x6b, - 0x58, 0xe4, 0xba, 0x99, 0x38, 0xe2, 0x95, 0x7e, 0xa6, 0x6f, 0xe7, 0x68, 0x68, 0x23, 0x49, 0x9b, 0x20, 0x46, 0x1c, - 0xcd, 0x98, 0xfe, 0x60, 0xd3, 0x46, 0xfb, 0xd8, 0xc4, 0x83, 0x1d, 0xf4, 0x72, 0x5c, 0x90, 0x46, 0x9f, 0x55, 0x72, - 0x50, 0xb8, 0x0c, 0xac, 0x79, 0x25, 0xe5, 0xde, 0x2f, 0xf6, 0x65, 0xac, 0xf1, 0xad, 0x5a, 0x99, 0xad, 0x9e, 0x31, - 0x12, 0x23, 0x7b, 0x21, 0x0c, 0x7e, 0x25, 0x7b, 0x3d, 0x6f, 0x79, 0x4d, 0x71, 0xdf, 0xcf, 0x21, 0x3b, 0x26, 0x0c, - 0x18, 0xe8, 0xa2, 0x4c, 0x4e, 0xbb, 0xfa, 0xe8, 0xd5, 0xe7, 0x77, 0xc3, 0xe5, 0x05, 0xe9, 0xf2, 0xc9, 0x5e, 0x47, - 0xae, 0xfb, 0xe1, 0xcf, 0xbc, 0x22, 0xd8, 0x8f, 0x95, 0xff, 0x1c, 0xa2, 0x88, 0x00, 0x60, 0x05, 0x89, 0x8d, 0x66, - 0x73, 0xb0, 0xaf, 0x8b, 0x8e, 0x76, 0x9d, 0xc8, 0x14, 0x95, 0xe1, 0x25, 0x7b, 0x11, 0x61, 0x17, 0xd1, 0x70, 0xb0, - 0x21, 0x6c, 0x62, 0x8b, 0x69, 0xe8, 0x62, 0xf9, 0x66, 0x7e, 0x5a, 0xe3, 0x76, 0xcc, 0xad, 0x43, 0xa1, 0x93, 0xd4, - 0xe8, 0x36, 0x03, 0x9f, 0xe3, 0x4f, 0xe1, 0x84, 0x63, 0x57, 0x69, 0x83, 0x0a, 0xcb, 0xb1, 0x59, 0xcd, 0xa3, 0x28, - 0x78, 0x3e, 0x5b, 0xe7, 0x50, 0xcc, 0x6d, 0x59, 0x2d, 0x58, 0x91, 0x23, 0xde, 0x71, 0xbd, 0x6e, 0xdb, 0x66, 0x17, - 0x9a, 0x1c, 0x51, 0x45, 0x0e, 0xcc, 0xb2, 0xa5, 0x02, 0x6a, 0xb1, 0xf0, 0xa4, 0x1d, 0x06, 0x13, 0xca, 0x22, 0x9e, - 0x5e, 0x74, 0x99, 0x2f, 0x4a, 0x93, 0xb2, 0x30, 0x17, 0x5b, 0x61, 0x0e, 0x6c, 0xed, 0x23, 0x6b, 0x18, 0x2c, 0x25, - 0x20, 0x8d, 0x7d, 0x58, 0xde, 0xa2, 0x4d, 0xb9, 0x63, 0xb4, 0xff, 0x99, 0xa5, 0xf6, 0xb1, 0x4b, 0x9b, 0x94, 0xbe, - 0xea, 0x0f, 0x2b, 0x13, 0x3e, 0x74, 0xfd, 0xaa, 0xdf, 0x6c, 0x8e, 0x4d, 0x50, 0x3f, 0x84, 0x2f, 0x49, 0x26, 0x35, - 0x38, 0x58, 0x18, 0xe8, 0xad, 0x0a, 0x1b, 0x83, 0x35, 0x01, 0x8f, 0xd2, 0x25, 0xd2, 0x44, 0x5c, 0x1b, 0x15, 0x55, - 0xf9, 0x22, 0x6b, 0xaf, 0xf4, 0x92, 0x7d, 0x40, 0xf0, 0xc6, 0x77, 0xb7, 0xd5, 0x68, 0xf8, 0x8e, 0x35, 0x89, 0x72, - 0x10, 0x1f, 0x56, 0xc3, 0x93, 0x66, 0x70, 0xf9, 0x8b, 0x76, 0xe2, 0x53, 0xb2, 0x5b, 0x5c, 0xa0, 0x81, 0xb3, 0xe0, - 0xe8, 0x9f, 0x11, 0xac, 0xaa, 0xab, 0xc8, 0x6a, 0xb3, 0x21, 0x41, 0x34, 0x0d, 0x96, 0x31, 0xb3, 0x36, 0x47, 0xd5, - 0x26, 0xb1, 0xc6, 0x38, 0x1a, 0xaf, 0xff, 0xce, 0x26, 0xf0, 0xf2, 0xac, 0x41, 0x7b, 0xe2, 0xba, 0xed, 0x52, 0x8b, - 0xc7, 0xe3, 0x3f, 0x1f, 0x79, 0x4c, 0xe0, 0xa0, 0xc5, 0x50, 0xcc, 0x0e, 0xc7, 0x7a, 0xd5, 0xe9, 0x55, 0x7c, 0x15, - 0x7a, 0x68, 0x7d, 0xbd, 0x99, 0xa0, 0xc8, 0xd1, 0x16, 0x66, 0xd9, 0xcc, 0x8d, 0x64, 0x6b, 0x8e, 0xbe, 0x59, 0x5b, - 0x24, 0x7b, 0x07, 0x0d, 0x96, 0x33, 0xf1, 0xc5, 0xa7, 0xd8, 0xbc, 0xd3, 0xd6, 0x31, 0x79, 0xc2, 0xb0, 0x23, 0xf8, - 0xa2, 0xa3, 0x2d, 0xc6, 0xe0, 0x7a, 0x8b, 0x75, 0xec, 0x61, 0x82, 0x94, 0x60, 0xb6, 0x00, 0x17, 0x1d, 0x3b, 0x9f, - 0x0c, 0x5f, 0xc5, 0xde, 0x19, 0xb0, 0x0d, 0xb4, 0x90, 0x3d, 0xf9, 0x45, 0x29, 0x4d, 0xe3, 0xe5, 0x53, 0x8b, 0xe0, - 0xc7, 0x0d, 0x75, 0x4e, 0xe5, 0xff, 0x8c, 0x46, 0x29, 0xe5, 0x49, 0x3a, 0xa1, 0x86, 0xc7, 0x56, 0xc0, 0x00, 0xb5, - 0xec, 0x59, 0xa5, 0xcf, 0x3e, 0xa4, 0x09, 0x5b, 0x88, 0x2d, 0xa9, 0xba, 0x79, 0x82, 0xf8, 0x3b, 0xbc, 0xe2, 0x22, - 0x06, 0x18, 0x39, 0xac, 0x1b, 0xfd, 0xe3, 0x16, 0xe9, 0x3c, 0x9e, 0xae, 0x0f, 0xe6, 0x84, 0xa3, 0xe1, 0xd7, 0x23, - 0x55, 0x26, 0x36, 0x1f, 0xaf, 0xdb, 0xd7, 0xa4, 0xb0, 0x83, 0x97, 0x4a, 0xb6, 0x7f, 0x1d, 0xbd, 0xf5, 0x66, 0x2b, - 0x23, 0x56, 0x24, 0xaf, 0x9c, 0xa2, 0x0a, 0xfa, 0xd5, 0xa7, 0xac, 0x92, 0x41, 0x0d, 0x18, 0xd6, 0x90, 0x51, 0x8d, - 0x18, 0xd7, 0x98, 0xcf, 0x04, 0x95, 0xcf, 0x0d, 0x3d, 0x5f, 0x18, 0x06, 0x2e, 0x0c, 0x23, 0x97, 0x82, 0x89, 0x57, - 0x86, 0x46, 0x85, 0x51, 0x4d, 0xab, 0x59, 0x35, 0xaf, 0xea, 0x4a, 0xd1, 0x1f, 0xf4, 0x6f, 0x81, 0xf1, 0x2f, 0x08, - 0x30, 0x1f, 0x62, 0xb2, 0xbc, 0x96, 0xed, 0x9b, 0xe7, 0x2f, 0x16, 0xcb, 0x2b, 0x18, 0x39, 0x42, 0x49, 0xeb, 0xb3, - 0x5f, 0xd4, 0x19, 0xda, 0xce, 0x01, 0xf4, 0x2d, 0x5d, 0xca, 0x78, 0x52, 0xec, 0xf7, 0x3f, 0xdf, 0xbb, 0xfd, 0x13, - 0xcf, 0x43, 0x5c, 0x36, 0xbe, 0x2c, 0x89, 0x7b, 0xec, 0x83, 0xdd, 0x06, 0x2d, 0x5e, 0x5c, 0x98, 0x51, 0x59, 0x5e, - 0xf4, 0xcc, 0xbb, 0x79, 0xcc, 0x82, 0xa1, 0x4e, 0xed, 0xa1, 0xe6, 0x5a, 0xf1, 0xf6, 0x07, 0x1d, 0xd6, 0x53, 0x71, - 0x6a, 0x25, 0xfb, 0xe6, 0x04, 0x56, 0xa2, 0x69, 0x26, 0xfe, 0x8c, 0xaa, 0x7f, 0xb0, 0xb2, 0x6b, 0x1d, 0xb2, 0x71, - 0xb3, 0xd3, 0xdb, 0x1f, 0xf5, 0x02, 0xf7, 0x71, 0x8d, 0x2b, 0x4b, 0xe0, 0x2c, 0x5f, 0x48, 0x67, 0x45, 0x53, 0x09, - 0x05, 0x68, 0x67, 0x7c, 0xc0, 0x4a, 0x46, 0xd0, 0x9f, 0x0d, 0xfd, 0x78, 0xed, 0x2e, 0xec, 0x14, 0xf9, 0xed, 0xdd, - 0xd3, 0x9d, 0xff, 0x09, 0x27, 0x94, 0x09, 0x8b, 0x44, 0xc5, 0x9f, 0x49, 0x17, 0x49, 0x2f, 0x50, 0xc5, 0xcd, 0xc4, - 0x99, 0x30, 0xd9, 0x8b, 0xb0, 0xd8, 0xed, 0x63, 0x53, 0x02, 0x2e, 0x50, 0x7f, 0xcc, 0x4f, 0x59, 0x3d, 0x8d, 0xa7, - 0xdf, 0xbd, 0x6c, 0x2a, 0x7a, 0xa3, 0xa7, 0xc5, 0x27, 0xff, 0xaa, 0xff, 0x96, 0x7a, 0x3b, 0xcb, 0xcd, 0x7c, 0xbf, - 0x26, 0x85, 0x3f, 0x98, 0x5c, 0xf5, 0x8e, 0x2f, 0x67, 0x9d, 0x87, 0x8d, 0xf3, 0x59, 0xe5, 0x6d, 0xea, 0xe6, 0x52, - 0xaa, 0xd4, 0xc6, 0x06, 0x9b, 0xdc, 0xfc, 0x53, 0xd5, 0x1e, 0x6d, 0x55, 0xb2, 0xfd, 0xf5, 0x38, 0xee, 0xc7, 0x77, - 0xfa, 0x0b, 0xfc, 0x92, 0x5e, 0x9a, 0xd9, 0x74, 0x7e, 0xfc, 0x73, 0x2b, 0xdd, 0x64, 0xf5, 0xcf, 0xe3, 0x52, 0xb7, - 0x54, 0x9b, 0xd4, 0x34, 0x8f, 0xba, 0x66, 0xc4, 0x03, 0xb4, 0xa6, 0xb7, 0x77, 0x3f, 0x65, 0xf5, 0x37, 0xea, 0xa4, - 0xda, 0xc3, 0xfd, 0x5f, 0x93, 0x37, 0x5b, 0x73, 0x31, 0x22, 0x85, 0xb1, 0x78, 0x3b, 0xa0, 0x7a, 0xbf, 0x7b, 0x0e, - 0xe9, 0xdc, 0xf8, 0x4f, 0x4f, 0x08, 0x12, 0xb3, 0x20, 0xf9, 0x7a, 0x7f, 0x43, 0xf1, 0xe0, 0x03, 0x4a, 0x7d, 0x0c, - 0xad, 0x0f, 0xfc, 0x6f, 0x9e, 0xc3, 0x1b, 0x8c, 0x5d, 0xa6, 0x03, 0xb7, 0xdc, 0x5c, 0xe8, 0xe7, 0x2f, 0xc4, 0x59, - 0x10, 0xee, 0xe1, 0x8b, 0xa9, 0x1d, 0x8c, 0x41, 0x39, 0x71, 0x04, 0x0e, 0xbe, 0x1d, 0x08, 0x93, 0x40, 0x7c, 0xbd, - 0xbf, 0xad, 0x78, 0xc8, 0x85, 0xdd, 0xcb, 0xfb, 0xd5, 0x9c, 0x4f, 0xdc, 0x71, 0x69, 0x57, 0x9f, 0x8e, 0x4f, 0xb2, - 0xdb, 0x3d, 0x0b, 0xaa, 0xdb, 0x39, 0xb7, 0x5b, 0x3e, 0x41, 0xd9, 0x2f, 0x3a, 0x52, 0xc3, 0x66, 0x35, 0xb4, 0x8c, - 0x7a, 0xd3, 0xfb, 0xf4, 0xb4, 0x70, 0xad, 0xe1, 0x2e, 0x80, 0x7f, 0x66, 0x40, 0xf6, 0x26, 0xc4, 0xde, 0x04, 0x84, - 0x6c, 0x33, 0xe3, 0x76, 0x33, 0x3e, 0x4e, 0x5e, 0xb3, 0x94, 0xb5, 0x77, 0x4e, 0x83, 0xf3, 0xb8, 0xde, 0x79, 0x5d, - 0xf9, 0x58, 0x94, 0x5c, 0xdd, 0xf1, 0x3a, 0x7d, 0xda, 0x43, 0xbe, 0x6f, 0x79, 0x2f, 0x49, 0x34, 0x38, 0x06, 0xf6, - 0xa2, 0x23, 0xa6, 0xb7, 0x2b, 0x43, 0x64, 0xda, 0x87, 0x31, 0xd4, 0x3d, 0xa9, 0xba, 0x14, 0x56, 0x5f, 0xf6, 0x4d, - 0x8d, 0x79, 0x2d, 0x8b, 0xad, 0x83, 0xae, 0xa6, 0x7b, 0x32, 0x63, 0x77, 0xcc, 0xb8, 0x8a, 0x99, 0xc1, 0x4e, 0x2f, - 0x9d, 0x11, 0x07, 0x2d, 0x1c, 0xfa, 0x23, 0x8b, 0xf7, 0xc9, 0xa8, 0x3b, 0x03, 0x43, 0xb5, 0x98, 0xbe, 0xcd, 0x56, - 0x0e, 0x98, 0x2d, 0x11, 0xe4, 0x35, 0x34, 0xbf, 0xd7, 0x14, 0x06, 0x3b, 0x85, 0x69, 0x63, 0xbd, 0xbd, 0x4b, 0xe5, - 0x52, 0x18, 0x88, 0x7a, 0xcf, 0x7d, 0x11, 0xd6, 0x3e, 0x28, 0x6e, 0xb0, 0x65, 0x82, 0xfd, 0xa2, 0xc4, 0xfe, 0x6d, - 0x3d, 0xcf, 0x0d, 0xec, 0xe2, 0x75, 0x61, 0x73, 0xd1, 0x52, 0x99, 0x22, 0x56, 0xa5, 0xe8, 0xb3, 0xfd, 0xbd, 0x72, - 0x36, 0x2a, 0x39, 0x5d, 0x4f, 0xe0, 0x2c, 0xa8, 0xba, 0xeb, 0xaa, 0x5d, 0xd1, 0x5c, 0xb6, 0x40, 0xef, 0x16, 0x38, - 0xbd, 0x3c, 0x49, 0xcb, 0xb3, 0x4d, 0x91, 0xc4, 0x52, 0x7a, 0xff, 0x89, 0xaf, 0x12, 0xf5, 0xe3, 0xec, 0xf1, 0xec, - 0x1b, 0xe1, 0x74, 0x83, 0xd3, 0xbc, 0x2c, 0x7f, 0xa6, 0x39, 0x7f, 0x57, 0xd1, 0x67, 0x96, 0xf5, 0xfc, 0xf6, 0xd1, - 0x23, 0x10, 0x4b, 0x13, 0xd8, 0x6b, 0x4b, 0xfd, 0x67, 0x6c, 0xfb, 0x10, 0xd3, 0x46, 0xd8, 0x68, 0x3c, 0xda, 0x04, - 0x9c, 0xb7, 0xf7, 0x6e, 0xe4, 0xdd, 0x75, 0x4b, 0x02, 0xae, 0xf1, 0x9e, 0xaf, 0xf9, 0xfe, 0x5e, 0xdb, 0x8a, 0x69, - 0xca, 0xb6, 0x62, 0x3e, 0xfb, 0xea, 0x5a, 0xc4, 0xdc, 0xb8, 0xdc, 0xc0, 0x5e, 0x55, 0x6b, 0xb5, 0x20, 0xd9, 0xde, - 0x87, 0x79, 0xfe, 0xd0, 0xcd, 0xec, 0xf0, 0x0c, 0x1e, 0xb5, 0x81, 0xc4, 0xcf, 0xfd, 0xf4, 0xeb, 0xd1, 0x54, 0xd6, - 0x17, 0x40, 0x98, 0x98, 0x11, 0x89, 0x4f, 0x1c, 0xdf, 0x17, 0x9e, 0x6f, 0xab, 0xf6, 0xdb, 0xe1, 0x3c, 0x6b, 0x8e, - 0x6c, 0x93, 0xee, 0x3e, 0x72, 0xb3, 0xf2, 0x03, 0x7a, 0xd5, 0x34, 0x45, 0x5c, 0xab, 0xfe, 0x89, 0x05, 0xd4, 0x52, - 0xe0, 0x40, 0x9e, 0xba, 0x9a, 0x28, 0x04, 0x3e, 0xe1, 0xf5, 0xf9, 0x4e, 0x01, 0xe8, 0xee, 0x45, 0xd0, 0x8c, 0x04, - 0xaf, 0x05, 0x15, 0x57, 0x75, 0x15, 0xcc, 0x56, 0xae, 0x12, 0x8c, 0xf5, 0x07, 0x0a, 0x9a, 0x27, 0xa5, 0x4c, 0x2a, - 0xa0, 0x07, 0xe4, 0x27, 0x1f, 0x55, 0xf1, 0x01, 0xcf, 0x35, 0x89, 0x5e, 0xaf, 0xe2, 0x9a, 0x38, 0x31, 0xa8, 0xc1, - 0xfd, 0x93, 0xaa, 0xf5, 0xa7, 0x62, 0x63, 0xc0, 0xc6, 0x1f, 0xa8, 0xcb, 0xed, 0xe1, 0x34, 0x2b, 0x49, 0x3a, 0x87, - 0x80, 0x1b, 0xd6, 0xf4, 0x18, 0xd5, 0x75, 0x1c, 0x60, 0xfa, 0xa3, 0xf4, 0x3d, 0xa2, 0xc3, 0x4d, 0x34, 0xdf, 0x0e, - 0xe4, 0x26, 0xdf, 0x0c, 0xbe, 0xd1, 0xc6, 0x7f, 0x1c, 0x7c, 0x35, 0xe8, 0xab, 0xe1, 0x8b, 0xc1, 0xe3, 0x6b, 0x6f, - 0xf8, 0x6c, 0xb0, 0xdd, 0x0d, 0x9f, 0x0c, 0xfe, 0x43, 0x7d, 0xaf, 0xfe, 0x68, 0x10, 0x5e, 0x55, 0xfc, 0x7a, 0xa7, - 0x2b, 0x0e, 0x7a, 0x1f, 0x4e, 0x75, 0xaf, 0xca, 0x7b, 0x6f, 0xf7, 0xee, 0x9d, 0xea, 0x67, 0xef, 0x3e, 0xdc, 0x3f, - 0xb5, 0x35, 0xef, 0x01, 0x50, 0xff, 0x54, 0x30, 0xef, 0xdd, 0xa9, 0x66, 0xf5, 0xde, 0x5e, 0x1d, 0xdf, 0xfd, 0xff, - 0xef, 0xbb, 0x86, 0xf7, 0x1e, 0x9e, 0x7a, 0x5a, 0x56, 0xde, 0x54, 0x7a, 0x9b, 0xf7, 0xfa, 0x5f, 0xcb, 0xea, 0x65, - 0x78, 0x65, 0xd0, 0x56, 0xc3, 0x4b, 0x83, 0xba, 0x1a, 0x5e, 0x18, 0x1c, 0x6a, 0xdb, 0x76, 0x86, 0x47, 0x06, 0x6e, - 0x35, 0x3c, 0x37, 0x58, 0x3f, 0x0d, 0x8f, 0x0d, 0xaa, 0xfd, 0xf7, 0x60, 0x78, 0x62, 0xe0, 0x66, 0xc3, 0xd3, 0xc2, - 0xbc, 0xad, 0xf7, 0xec, 0x9f, 0x89, 0x97, 0xa7, 0x31, 0x76, 0xe8, 0xb0, 0xcf, 0xb5, 0xfb, 0x2d, 0xc4, 0xbc, 0x5d, - 0x8e, 0x5d, 0x75, 0x6a, 0x03, 0x36, 0xea, 0x7f, 0x33, 0x2d, 0x37, 0x9c, 0xf0, 0x1b, 0x81, 0x04, 0x96, 0x67, 0xe7, - 0x0a, 0x30, 0xb5, 0x1f, 0x7a, 0x3c, 0x67, 0x60, 0x6a, 0x25, 0x2b, 0x46, 0xae, 0x62, 0xde, 0x9e, 0xfa, 0x3f, 0xf7, - 0x6d, 0x16, 0x6b, 0x94, 0x20, 0x3d, 0xe4, 0x0f, 0xf1, 0xe3, 0x23, 0x37, 0x84, 0x0e, 0xa3, 0x9f, 0x36, 0x29, 0xef, - 0x02, 0xfc, 0xad, 0x25, 0x39, 0xd0, 0xd7, 0x6e, 0x9f, 0x08, 0xdf, 0x82, 0xb3, 0x88, 0x33, 0x2e, 0x24, 0x22, 0x43, - 0x5c, 0xbd, 0xfe, 0x97, 0xab, 0xee, 0x28, 0x36, 0x9e, 0x69, 0x51, 0xfa, 0xc4, 0xfb, 0x62, 0x9b, 0xe4, 0x98, 0x69, - 0x6e, 0xc4, 0x3c, 0x8d, 0xeb, 0xe2, 0x1c, 0x36, 0x43, 0xa2, 0x72, 0x7b, 0x12, 0x5e, 0x22, 0x85, 0x8f, 0xe4, 0xea, - 0x05, 0xf6, 0x9e, 0x60, 0x8a, 0xfd, 0x1c, 0x98, 0xe5, 0x0c, 0xaa, 0x9c, 0xec, 0x40, 0x38, 0x62, 0x52, 0x8d, 0xbf, - 0x52, 0x1e, 0xdf, 0x8e, 0xaa, 0x3c, 0x0e, 0x80, 0xa8, 0xfd, 0x06, 0xde, 0x81, 0x50, 0x99, 0x72, 0xc8, 0x62, 0x82, - 0x17, 0xf4, 0x78, 0xd1, 0x00, 0xaf, 0x64, 0xc2, 0x6f, 0x6b, 0xe5, 0x96, 0xe0, 0x6c, 0x33, 0x32, 0x61, 0x02, 0x66, - 0x57, 0xb0, 0x0a, 0xe2, 0x7f, 0xd9, 0x93, 0x5e, 0x01, 0xa4, 0x40, 0x8b, 0x4d, 0xc3, 0xd0, 0xbd, 0xc4, 0x77, 0x6c, - 0x4c, 0xba, 0xc2, 0xb5, 0xf4, 0x1b, 0xd6, 0x26, 0xeb, 0x67, 0x40, 0xb1, 0xfb, 0xdb, 0x42, 0x1d, 0x80, 0xfe, 0x0b, - 0xa9, 0xfb, 0x97, 0x33, 0x5c, 0x74, 0xed, 0x22, 0x8a, 0x52, 0x4b, 0x0c, 0x0c, 0xb7, 0x11, 0x68, 0x3b, 0x0c, 0x1a, - 0xaf, 0xd3, 0x57, 0x22, 0xe1, 0x8b, 0x68, 0xa5, 0x5c, 0x78, 0x47, 0xb0, 0x83, 0x1a, 0x9d, 0xaa, 0x89, 0xe6, 0x8f, - 0xf2, 0x46, 0x5b, 0x58, 0x04, 0x61, 0xcb, 0x54, 0x8f, 0x14, 0x30, 0x9d, 0x07, 0xfd, 0x6f, 0x34, 0x7b, 0x49, 0xb5, - 0x84, 0x89, 0x7b, 0x7a, 0xcb, 0x7e, 0x42, 0x56, 0xfc, 0x53, 0x24, 0x8f, 0x9d, 0xa6, 0x3c, 0xf1, 0xc9, 0x79, 0x80, - 0x97, 0x5f, 0x8e, 0x80, 0xec, 0x9a, 0xa0, 0xc8, 0x87, 0xbc, 0xd0, 0x84, 0x89, 0x33, 0xe3, 0x11, 0xc1, 0x00, 0x93, - 0x05, 0xb8, 0xcd, 0xbe, 0xd5, 0x62, 0x3a, 0xe1, 0x80, 0xc9, 0x70, 0x59, 0xc9, 0x8b, 0x52, 0x9c, 0x8b, 0xda, 0xdc, - 0x6c, 0x8d, 0x67, 0x84, 0x21, 0x79, 0x73, 0x97, 0x76, 0x38, 0x18, 0x46, 0xfd, 0xad, 0x21, 0x57, 0x89, 0xd2, 0xbd, - 0x98, 0xb4, 0x2b, 0xd9, 0x95, 0x3e, 0xe9, 0x6c, 0x66, 0x3c, 0xbe, 0xf9, 0x6d, 0x48, 0x29, 0x50, 0xec, 0x0d, 0xe5, - 0xfa, 0x10, 0xbf, 0xb7, 0xda, 0x20, 0x7a, 0xe1, 0xf9, 0xf3, 0x53, 0xd0, 0x70, 0x16, 0x8c, 0x52, 0xe9, 0x00, 0x6d, - 0x10, 0x47, 0x67, 0x4d, 0x78, 0xd6, 0xc9, 0xed, 0xb3, 0x0b, 0xf1, 0x60, 0x55, 0x21, 0xe1, 0x0c, 0x9d, 0x7b, 0xda, - 0x58, 0xea, 0xcc, 0x30, 0x25, 0x31, 0x00, 0x1c, 0x01, 0x8f, 0xb6, 0xc3, 0x73, 0xea, 0x69, 0x2f, 0x05, 0xd0, 0x9b, - 0x3c, 0xef, 0xa7, 0x8f, 0x4a, 0xa5, 0x07, 0x3a, 0x8f, 0x5a, 0x7d, 0x76, 0x96, 0xd6, 0x97, 0x25, 0x64, 0x10, 0x18, - 0x8d, 0x1a, 0x9a, 0x2f, 0xa2, 0x72, 0xbf, 0x45, 0x0d, 0xd6, 0x52, 0x65, 0x8d, 0xbc, 0x79, 0xef, 0xfd, 0xc1, 0x35, - 0x6c, 0x76, 0x0d, 0x95, 0xbe, 0x1e, 0xd7, 0x1c, 0x94, 0x02, 0x73, 0x12, 0xe2, 0xd8, 0x16, 0xde, 0x9f, 0x8c, 0x70, - 0xbd, 0x7d, 0xa1, 0x66, 0x8b, 0x2d, 0x0e, 0x60, 0xee, 0x4f, 0x38, 0xe7, 0x92, 0xec, 0x78, 0xe7, 0x2c, 0x96, 0x5f, - 0xd7, 0x5a, 0x79, 0x49, 0xfe, 0xd5, 0x38, 0x3b, 0xb6, 0xac, 0x72, 0x56, 0x81, 0x10, 0x88, 0xfc, 0x74, 0x3a, 0x91, - 0x88, 0xd5, 0x16, 0x04, 0x8d, 0x14, 0x26, 0x84, 0x75, 0xf2, 0xee, 0xe8, 0x46, 0xbc, 0x75, 0x6a, 0x41, 0x66, 0xe2, - 0x40, 0x01, 0xa6, 0xe2, 0xd4, 0xda, 0x93, 0x3d, 0x03, 0x12, 0xec, 0xcb, 0x02, 0x96, 0x6a, 0x80, 0x5c, 0x48, 0x67, - 0xd2, 0x17, 0x44, 0xd1, 0x49, 0x63, 0x2e, 0xb9, 0x78, 0x0a, 0xd8, 0xd0, 0x29, 0x40, 0xa8, 0x34, 0x61, 0xd4, 0x73, - 0x7c, 0xb7, 0x26, 0xb5, 0xa3, 0x4e, 0x49, 0x98, 0xb9, 0x47, 0x0c, 0x9e, 0xcc, 0x9b, 0x0a, 0x71, 0xeb, 0xb3, 0x84, - 0x15, 0xeb, 0x7c, 0x08, 0xf8, 0x04, 0xc6, 0xdb, 0x88, 0xbd, 0x51, 0x1b, 0xf2, 0x06, 0xd6, 0x8f, 0x85, 0x11, 0x84, - 0x8d, 0x19, 0x26, 0xc7, 0x76, 0x83, 0x27, 0x81, 0x06, 0x58, 0xd8, 0x99, 0x9e, 0x13, 0x18, 0x78, 0x77, 0xd6, 0xda, - 0xd8, 0xf4, 0x7e, 0xd5, 0x89, 0x4a, 0xb5, 0x91, 0x59, 0xfe, 0x75, 0x01, 0x55, 0x5a, 0x5f, 0x01, 0xa8, 0x0a, 0xb8, - 0x88, 0xfc, 0xf1, 0x97, 0x9f, 0x27, 0xff, 0xda, 0x04, 0x19, 0x8c, 0xd8, 0x7c, 0x09, 0xb9, 0x41, 0x2d, 0xd8, 0xc8, - 0x77, 0x8c, 0xb9, 0x12, 0xab, 0xc2, 0x97, 0x30, 0x3c, 0x3f, 0xb5, 0xc3, 0x55, 0x1e, 0xd4, 0xa4, 0xc5, 0x47, 0x44, - 0x16, 0x26, 0x69, 0x79, 0x62, 0xa0, 0xa1, 0xaf, 0x84, 0xca, 0x2f, 0x2e, 0xae, 0xd1, 0xf8, 0x56, 0xf1, 0x18, 0x2c, - 0x3c, 0xbe, 0xe5, 0xda, 0x36, 0xd3, 0x46, 0xd9, 0x83, 0xa9, 0x91, 0xb9, 0xd2, 0x5b, 0xb5, 0xd1, 0x21, 0xae, 0xef, - 0xa1, 0x4d, 0x6e, 0xc2, 0x5e, 0xfc, 0x31, 0xa3, 0xac, 0xf6, 0x38, 0x5a, 0xbc, 0xc6, 0xc2, 0x15, 0x7e, 0x5d, 0x40, - 0xc1, 0xdb, 0xe9, 0x63, 0x87, 0x7e, 0x5c, 0xfa, 0x3a, 0x1c, 0x41, 0xa6, 0x4a, 0x54, 0x5c, 0x45, 0x50, 0x09, 0x51, - 0x0f, 0xd7, 0x00, 0x21, 0x4f, 0xe3, 0x4e, 0x34, 0x5a, 0xd5, 0xa6, 0xf4, 0x6a, 0xa4, 0x51, 0xe0, 0xec, 0x2e, 0xfa, - 0xb0, 0x12, 0x79, 0x4b, 0x95, 0x44, 0x0c, 0x94, 0x30, 0x45, 0xd6, 0xbf, 0x99, 0x38, 0x2b, 0x5b, 0xa2, 0x2a, 0x01, - 0x4c, 0x9d, 0x68, 0xc3, 0x4f, 0xbc, 0x11, 0x06, 0xaa, 0x48, 0xa6, 0x12, 0x09, 0x3a, 0x53, 0x65, 0x00, 0x25, 0x4d, - 0x40, 0x1d, 0xd3, 0xee, 0xc1, 0xc3, 0x0a, 0xcb, 0x4d, 0x96, 0x6b, 0x4c, 0x61, 0xb9, 0xbf, 0x7f, 0xca, 0xb3, 0x52, - 0x97, 0x71, 0x10, 0xb5, 0xf2, 0x34, 0xcd, 0x76, 0xaa, 0xaa, 0x84, 0x6e, 0xe3, 0x8a, 0xf3, 0x92, 0xb5, 0xc8, 0xfb, - 0x71, 0x36, 0x6d, 0x7c, 0x10, 0x34, 0x2c, 0x7a, 0xb7, 0xbc, 0x4c, 0xae, 0x24, 0xd6, 0x27, 0x98, 0x1d, 0x41, 0x66, - 0xd0, 0x49, 0x55, 0x2f, 0x48, 0x4a, 0x48, 0x50, 0xaa, 0x44, 0xfe, 0x47, 0xa5, 0xa4, 0x4e, 0xe2, 0xbe, 0x87, 0xf5, - 0x57, 0x95, 0xc5, 0x2b, 0x56, 0x68, 0xdc, 0xf7, 0xf5, 0xed, 0x24, 0xbf, 0x86, 0x11, 0x8a, 0x01, 0x10, 0x5f, 0x07, - 0x70, 0x84, 0x57, 0x2e, 0x9f, 0x8c, 0x60, 0x18, 0x85, 0x8a, 0x23, 0xd6, 0xb4, 0xc5, 0x95, 0xb8, 0x3c, 0x73, 0x05, - 0x23, 0x3c, 0xfc, 0xad, 0x8a, 0x1b, 0x88, 0x87, 0xaf, 0xdb, 0x80, 0x3e, 0x3e, 0xce, 0x97, 0xde, 0x0b, 0xfa, 0xd6, - 0x42, 0x93, 0x4c, 0x10, 0x67, 0xf3, 0x37, 0x8f, 0x97, 0xcd, 0x9e, 0x2f, 0xbf, 0x68, 0x1a, 0x25, 0x81, 0xbe, 0xe7, - 0x6a, 0xf2, 0xf8, 0x67, 0x91, 0x25, 0xc1, 0x21, 0x68, 0xf1, 0x66, 0x42, 0xe0, 0x8b, 0x5e, 0xb0, 0x6a, 0x56, 0x03, - 0xd3, 0x49, 0x71, 0x30, 0xba, 0xb6, 0x89, 0x3a, 0xc5, 0xea, 0x58, 0x9d, 0xd9, 0x11, 0x06, 0x95, 0x7a, 0x08, 0xd5, - 0x53, 0x3a, 0xd2, 0x9b, 0xaf, 0xe8, 0x47, 0xe1, 0xa6, 0xc4, 0xd7, 0xec, 0x52, 0x55, 0x0a, 0xab, 0xc0, 0x19, 0x88, - 0xae, 0x16, 0x1c, 0x27, 0x36, 0x74, 0xf5, 0x10, 0x2c, 0x1b, 0xc6, 0x06, 0x27, 0x6a, 0xa9, 0x42, 0xd1, 0x36, 0x1f, - 0xef, 0xf9, 0x5e, 0xe0, 0x43, 0xc2, 0xac, 0xf3, 0xe1, 0x81, 0x90, 0xed, 0x60, 0xdc, 0x65, 0xf4, 0x03, 0xaa, 0x3b, - 0x23, 0xe8, 0x35, 0xa6, 0xc7, 0xd4, 0x95, 0x44, 0x86, 0xf9, 0xf9, 0xa5, 0xc3, 0x5a, 0x67, 0xe0, 0xea, 0xa1, 0xfb, - 0x21, 0x35, 0x06, 0x35, 0xfc, 0xc1, 0xe8, 0x2a, 0x5c, 0xed, 0xee, 0x9b, 0xe9, 0x20, 0xb0, 0x55, 0x13, 0xa6, 0x66, - 0xc0, 0x34, 0x49, 0x91, 0x98, 0xac, 0x67, 0xd9, 0xd6, 0x8d, 0x7a, 0x5c, 0x50, 0x3e, 0xfb, 0x38, 0x69, 0xfb, 0xba, - 0xb2, 0x82, 0x34, 0x73, 0x21, 0x28, 0x63, 0xe8, 0xa8, 0x4f, 0xac, 0xb3, 0x1a, 0x41, 0x8e, 0x14, 0x96, 0xb6, 0x90, - 0x89, 0x62, 0xcd, 0x69, 0x57, 0x69, 0x5a, 0x59, 0xe2, 0x8f, 0xe9, 0x58, 0xe4, 0xc2, 0x26, 0x83, 0x96, 0x43, 0x29, - 0x4d, 0x9a, 0xf6, 0x4f, 0xf9, 0x44, 0xf8, 0xad, 0x44, 0xd6, 0xaf, 0x6f, 0xf0, 0xec, 0xd9, 0xed, 0x68, 0x03, 0x8c, - 0x97, 0xae, 0x91, 0x4e, 0xb1, 0x1e, 0x63, 0xb7, 0x7c, 0x8f, 0x91, 0xf0, 0x3d, 0x34, 0xd5, 0x57, 0xf9, 0x14, 0xe7, - 0x8e, 0xe8, 0x69, 0x63, 0xf9, 0x77, 0xcf, 0x6e, 0x41, 0xf9, 0x9a, 0xef, 0xb1, 0x20, 0x6d, 0xef, 0x73, 0x26, 0x95, - 0x2b, 0x4a, 0x0c, 0x39, 0x2a, 0xa9, 0xe0, 0x41, 0x03, 0x80, 0x59, 0x9d, 0x55, 0x8d, 0x06, 0x60, 0x17, 0xf9, 0x9d, - 0x52, 0x41, 0x86, 0x4b, 0x64, 0x81, 0x1b, 0x60, 0x7d, 0x00, 0x87, 0x32, 0x53, 0x32, 0x3c, 0x98, 0x5f, 0x61, 0x32, - 0x31, 0xd2, 0xef, 0x50, 0x1c, 0x8f, 0x3b, 0xde, 0xba, 0xe7, 0xa7, 0xa4, 0xd9, 0x69, 0x0f, 0x30, 0x37, 0x91, 0x3c, - 0x0b, 0x0b, 0xfb, 0x20, 0x67, 0xbf, 0x33, 0x0f, 0x84, 0xd1, 0x3a, 0x7f, 0xba, 0xd9, 0x4f, 0x4a, 0x24, 0x78, 0x48, - 0xa9, 0xed, 0xcd, 0x88, 0x72, 0x22, 0x73, 0x29, 0xf5, 0x8d, 0x6d, 0xab, 0x06, 0x53, 0xa4, 0x84, 0x41, 0xa7, 0x11, - 0xbd, 0xb6, 0xb1, 0xbb, 0xa3, 0xd1, 0xf9, 0x27, 0xaa, 0x05, 0x03, 0x99, 0xe1, 0x88, 0x03, 0x58, 0x13, 0xe1, 0x64, - 0x66, 0x67, 0x46, 0x16, 0x64, 0xde, 0x66, 0xee, 0xcf, 0xa4, 0xb9, 0x44, 0x74, 0x5b, 0x6d, 0xae, 0xc8, 0x0c, 0xd3, - 0x53, 0xdc, 0xbd, 0xad, 0xe4, 0xe8, 0xae, 0x77, 0x00, 0x5a, 0xe9, 0xc3, 0xf9, 0x5f, 0x8f, 0xe7, 0xc8, 0x68, 0xc0, - 0xeb, 0x39, 0x57, 0x41, 0xf3, 0x17, 0x38, 0x4f, 0x73, 0x6b, 0x6b, 0x62, 0xa4, 0x26, 0x73, 0x5a, 0xe5, 0xf9, 0x5e, - 0x46, 0x3f, 0x57, 0x8d, 0x3e, 0x6a, 0xe9, 0xd4, 0x6b, 0x90, 0x08, 0x95, 0x19, 0xf1, 0xe7, 0x92, 0xb7, 0x17, 0x10, - 0xdd, 0xa5, 0x12, 0xc6, 0xda, 0x09, 0x98, 0xb9, 0x17, 0xeb, 0x7c, 0x9e, 0x5e, 0x7f, 0x32, 0x69, 0x32, 0x5f, 0xee, - 0xde, 0x05, 0xf2, 0x8e, 0x13, 0x0c, 0x9f, 0x7d, 0x86, 0x21, 0xb2, 0xb8, 0xf8, 0xc5, 0xeb, 0xe9, 0xbd, 0x48, 0x40, - 0xef, 0x13, 0x66, 0x79, 0x4b, 0xc5, 0x2d, 0x98, 0x87, 0x5a, 0x1a, 0xcb, 0xcf, 0xe4, 0xf6, 0x8b, 0xde, 0x11, 0xec, - 0xbd, 0x17, 0x37, 0xbe, 0xfa, 0xbf, 0xb1, 0x67, 0x48, 0xec, 0x7f, 0x2e, 0x91, 0x8a, 0xab, 0xca, 0xdc, 0x8f, 0x25, - 0xa9, 0x82, 0xd5, 0x74, 0x9e, 0x22, 0x19, 0xec, 0xdd, 0x54, 0x83, 0x80, 0x4d, 0x91, 0x31, 0xed, 0x79, 0x80, 0xde, - 0xa0, 0xef, 0x2c, 0xc2, 0x46, 0x45, 0x11, 0xd3, 0x4f, 0x6a, 0x56, 0xe6, 0xe8, 0x74, 0x2c, 0x59, 0x39, 0xb0, 0xd3, - 0xef, 0x5e, 0x7c, 0xfb, 0x35, 0x52, 0xe5, 0xbd, 0xed, 0xdb, 0x59, 0x2b, 0x42, 0xd0, 0xf0, 0x21, 0xd3, 0xdb, 0xf3, - 0x3c, 0xcf, 0x55, 0x16, 0xf7, 0xf1, 0x77, 0x89, 0xc3, 0xc4, 0x28, 0x5b, 0xa3, 0x84, 0x27, 0x5a, 0xd0, 0xcb, 0x5f, - 0x34, 0x45, 0x83, 0xaf, 0x52, 0x14, 0x16, 0xe8, 0x55, 0x43, 0x8e, 0x96, 0xe5, 0xbb, 0x92, 0x06, 0xaa, 0x82, 0xeb, - 0x96, 0xc1, 0xc2, 0xdd, 0xa9, 0x90, 0xd6, 0xa9, 0xb9, 0x50, 0xb6, 0x4f, 0x25, 0xf8, 0x0f, 0xa9, 0xdd, 0x98, 0xa5, - 0x0a, 0xa9, 0x80, 0xea, 0x78, 0xc0, 0xdb, 0x1e, 0x03, 0x2d, 0x4f, 0x30, 0x7b, 0xaf, 0x95, 0x14, 0x83, 0x0a, 0x72, - 0x1b, 0x00, 0x5b, 0x6e, 0x08, 0xd7, 0xe0, 0xe9, 0x18, 0x44, 0xc2, 0x9d, 0x2f, 0x8b, 0xfe, 0xb7, 0x37, 0xf5, 0xac, - 0xfa, 0x4b, 0x86, 0x45, 0xf1, 0xde, 0xf4, 0x1f, 0xb5, 0x69, 0x08, 0x82, 0x6f, 0xa3, 0x44, 0xc4, 0x9f, 0xf9, 0x40, - 0xd5, 0x1a, 0x18, 0xeb, 0x3a, 0x0c, 0x1e, 0x48, 0x61, 0xb2, 0x65, 0x5a, 0x36, 0xa5, 0x4e, 0xdd, 0xc2, 0xee, 0x13, - 0x94, 0xb7, 0x41, 0xf5, 0x5e, 0x2a, 0x2b, 0x1f, 0x50, 0x04, 0x64, 0x45, 0x19, 0x94, 0x8a, 0x7b, 0xba, 0x9e, 0x55, - 0x6c, 0xc2, 0x4f, 0x2f, 0x2b, 0x67, 0xac, 0x83, 0x78, 0x29, 0xff, 0xeb, 0x51, 0xf9, 0x3d, 0xda, 0x1a, 0xea, 0x6b, - 0x51, 0x48, 0x98, 0xe3, 0x16, 0xe3, 0x07, 0x3b, 0x43, 0x27, 0x50, 0x4b, 0x29, 0x9f, 0x10, 0x5f, 0x1c, 0xa2, 0xb0, - 0x73, 0xa8, 0x50, 0x9b, 0x49, 0x08, 0x0b, 0xaf, 0x7e, 0x21, 0xbd, 0xec, 0x87, 0xe0, 0x5e, 0x71, 0x44, 0xaa, 0x4c, - 0xee, 0x58, 0xa7, 0xca, 0x6f, 0x10, 0x0b, 0xb3, 0xb7, 0xef, 0xfb, 0x7d, 0x1d, 0xfc, 0x9d, 0xfe, 0xc7, 0x4f, 0xf8, - 0x68, 0x4f, 0xfb, 0xd1, 0xce, 0xe7, 0x65, 0x40, 0xfd, 0xf1, 0xd4, 0xb4, 0x6d, 0x58, 0xd3, 0x6e, 0xb0, 0x48, 0x5f, - 0x93, 0x85, 0x99, 0x78, 0x68, 0xc6, 0xbf, 0x2d, 0xca, 0xfb, 0x94, 0xce, 0x56, 0x35, 0x83, 0xaa, 0x25, 0xff, 0xfa, - 0x57, 0x85, 0x0d, 0xc2, 0x34, 0x60, 0x27, 0x80, 0xd0, 0x17, 0x79, 0x3f, 0x73, 0x3d, 0x44, 0x08, 0xbe, 0x60, 0x00, - 0x77, 0x0e, 0x7d, 0x81, 0x3a, 0x87, 0xa1, 0x6a, 0xbd, 0x9c, 0xeb, 0xc8, 0x46, 0xcd, 0xf1, 0x6a, 0xd7, 0x47, 0x7f, - 0xa0, 0xef, 0xfd, 0x34, 0xf2, 0x67, 0x4b, 0x2d, 0xb8, 0x19, 0x37, 0xeb, 0x16, 0x70, 0x06, 0x67, 0xf1, 0x1c, 0x28, - 0xd3, 0x57, 0x83, 0x17, 0xe7, 0x32, 0x5a, 0x1b, 0x98, 0x82, 0x69, 0xe5, 0x86, 0x8b, 0xa2, 0x74, 0xec, 0xa8, 0x17, - 0xbb, 0xb6, 0x8a, 0x2e, 0xdd, 0x46, 0x8e, 0x72, 0xbe, 0x65, 0xef, 0x50, 0x95, 0xb0, 0xbe, 0x64, 0x13, 0x79, 0x17, - 0xd3, 0xcb, 0xab, 0xf3, 0x8a, 0x66, 0xbc, 0x6a, 0xcb, 0xda, 0x03, 0x11, 0x67, 0x42, 0xbe, 0xe8, 0x9e, 0xa2, 0x51, - 0xe0, 0xd0, 0x54, 0xed, 0xe2, 0xdf, 0x8f, 0xb8, 0xaa, 0x77, 0xbd, 0xf8, 0x37, 0xbb, 0x66, 0x5d, 0xcf, 0xc4, 0x80, - 0x51, 0x4e, 0xbe, 0x60, 0xe5, 0x30, 0xbc, 0xe2, 0x9e, 0xfa, 0xbe, 0x48, 0xcf, 0x33, 0xea, 0x55, 0x34, 0xb7, 0xef, - 0xd4, 0x9f, 0xe3, 0x59, 0xcd, 0xf5, 0x67, 0xdb, 0xb0, 0x87, 0x25, 0xef, 0xcb, 0xed, 0x93, 0x73, 0xd2, 0xaa, 0x53, - 0x4e, 0xa9, 0x5d, 0x78, 0x09, 0x8f, 0x6c, 0x6f, 0x68, 0x50, 0xe6, 0xce, 0xfa, 0xb4, 0x3b, 0xdc, 0x4f, 0x8e, 0x8a, - 0x32, 0x76, 0xc5, 0x61, 0x9f, 0x51, 0xd2, 0xfb, 0x8a, 0x9b, 0xc3, 0x10, 0x83, 0x53, 0x27, 0x50, 0x94, 0xf5, 0x08, - 0x2b, 0xcf, 0x03, 0xfb, 0xed, 0x8a, 0x9f, 0x81, 0x73, 0x98, 0xda, 0x6d, 0x4c, 0xee, 0xfa, 0x94, 0x4a, 0xee, 0xab, - 0x8a, 0xee, 0x23, 0xe3, 0x82, 0xbd, 0xc3, 0xfa, 0x83, 0x83, 0x3e, 0xe2, 0xb2, 0xc5, 0xc7, 0x8f, 0x59, 0x80, 0xbf, - 0xaa, 0xce, 0xfb, 0x86, 0x21, 0x14, 0x60, 0xb2, 0x4a, 0x4d, 0x1b, 0xc5, 0x4b, 0x86, 0xcd, 0xbd, 0x93, 0x8f, 0x4b, - 0xd4, 0x09, 0xee, 0xaf, 0xd1, 0xb2, 0xda, 0x0d, 0xf0, 0x79, 0x12, 0x4b, 0xcc, 0x89, 0xf6, 0xd8, 0x3f, 0xde, 0xac, - 0x66, 0xf2, 0x27, 0x66, 0xe8, 0x33, 0x54, 0x0b, 0xeb, 0x58, 0xfe, 0x20, 0xce, 0x4f, 0x7d, 0x7e, 0xbb, 0x24, 0xf9, - 0x9b, 0xa1, 0xc2, 0xc2, 0xa6, 0xb0, 0x82, 0xb0, 0x95, 0xaf, 0x2f, 0xec, 0x00, 0xea, 0xbd, 0xc9, 0xec, 0xfe, 0x0d, - 0xe3, 0xcb, 0x2e, 0xe1, 0xcb, 0xed, 0x12, 0xc5, 0xb2, 0x8b, 0xc3, 0x45, 0x2e, 0x23, 0x0a, 0x27, 0x1e, 0x8c, 0x80, - 0x17, 0x95, 0x75, 0xe0, 0x87, 0x75, 0xc4, 0xc7, 0xe7, 0x71, 0xb9, 0x20, 0x5a, 0x94, 0xe6, 0xcf, 0x83, 0x96, 0x25, - 0x1d, 0xd7, 0xf4, 0x4d, 0x74, 0x98, 0xd2, 0x04, 0x84, 0xec, 0xb1, 0x29, 0xf4, 0x63, 0x95, 0xa2, 0xba, 0x59, 0x3a, - 0x70, 0xe7, 0xc6, 0x76, 0xd5, 0x48, 0xf9, 0x5d, 0xbf, 0x4e, 0x77, 0xb2, 0x6b, 0xd9, 0x3f, 0x65, 0xc8, 0x7c, 0xd4, - 0x05, 0xf3, 0xc7, 0x99, 0x2a, 0x1d, 0x72, 0xed, 0xf5, 0x69, 0x57, 0x45, 0xd0, 0x14, 0xfb, 0x9f, 0x76, 0xf5, 0x92, - 0xee, 0x8b, 0x1f, 0x15, 0xd0, 0xea, 0xa2, 0x43, 0x8a, 0x1c, 0x18, 0xc3, 0x21, 0x61, 0xb8, 0x11, 0xb1, 0x6d, 0x48, - 0x82, 0xc7, 0xca, 0x29, 0xbc, 0x10, 0xf7, 0xc7, 0x91, 0x8a, 0x51, 0x15, 0xdd, 0xd8, 0xda, 0xd8, 0xc6, 0x66, 0x62, - 0x1e, 0xd7, 0x43, 0xf9, 0xab, 0x28, 0x93, 0x26, 0xb8, 0x1b, 0x0c, 0xea, 0xec, 0x79, 0xa2, 0x14, 0xb4, 0x99, 0xe9, - 0xb1, 0x15, 0x4e, 0x93, 0x5b, 0xee, 0x76, 0x91, 0x44, 0x97, 0x85, 0xa1, 0xd9, 0x1a, 0x4c, 0x1c, 0x23, 0xf5, 0x16, - 0x24, 0xb2, 0x2d, 0x85, 0xcb, 0x2e, 0x7e, 0xa3, 0x28, 0x61, 0xd0, 0xf9, 0x4c, 0x30, 0xde, 0x44, 0xc0, 0x94, 0x23, - 0x4f, 0x13, 0xda, 0x4a, 0x1e, 0x8d, 0x91, 0x57, 0x32, 0x4d, 0x65, 0x7b, 0x2c, 0x7f, 0x24, 0xc9, 0x94, 0x9b, 0xe9, - 0x62, 0xa1, 0x17, 0x13, 0x04, 0xaa, 0xb0, 0xea, 0xad, 0x58, 0x49, 0x04, 0x60, 0xb9, 0x82, 0xb2, 0xec, 0xd2, 0xfd, - 0xbc, 0x02, 0x47, 0x1e, 0xa6, 0x53, 0xc4, 0x86, 0x27, 0x8d, 0x8c, 0xc4, 0x89, 0xaf, 0x2f, 0xc9, 0x96, 0x53, 0x33, - 0x38, 0x8b, 0x78, 0x60, 0xaa, 0xdb, 0xdc, 0x78, 0x79, 0xa4, 0xd8, 0xba, 0x97, 0xde, 0x89, 0xb8, 0x74, 0x9d, 0x95, - 0xa2, 0x1c, 0x55, 0x52, 0xa8, 0xe7, 0x4c, 0xa3, 0xa9, 0xbc, 0xb5, 0x85, 0x12, 0x59, 0x05, 0xad, 0x92, 0xd3, 0xff, - 0xef, 0x88, 0x24, 0x24, 0x5c, 0x08, 0x2c, 0xfe, 0x32, 0x15, 0xd2, 0xec, 0xad, 0xb6, 0x63, 0x18, 0x44, 0xba, 0xce, - 0x0b, 0x6e, 0x19, 0xbf, 0xfa, 0x05, 0x00, 0x7a, 0x2b, 0xda, 0x06, 0xa6, 0x8b, 0x05, 0x9c, 0xd9, 0xd9, 0x8c, 0xde, - 0xe6, 0xc2, 0xac, 0x8e, 0x2b, 0xfa, 0x89, 0xd5, 0xbf, 0x86, 0x85, 0xdd, 0xb3, 0xfd, 0x78, 0xb0, 0x63, 0x46, 0x53, - 0x57, 0x09, 0x61, 0x98, 0x20, 0x8b, 0x5e, 0x06, 0x77, 0xc8, 0x22, 0x8c, 0xc0, 0xae, 0x1c, 0xda, 0xc8, 0x84, 0xf3, - 0x15, 0x84, 0x7f, 0x8e, 0xf9, 0x7a, 0x0a, 0x2c, 0xcb, 0xfd, 0xc9, 0x50, 0x0f, 0x03, 0xc2, 0x44, 0x46, 0x38, 0x82, - 0x24, 0x64, 0x53, 0x21, 0x98, 0x78, 0x0a, 0xea, 0x26, 0x38, 0xb0, 0xc5, 0xd1, 0x8d, 0x8d, 0x52, 0x98, 0x11, 0x7f, - 0xc5, 0x82, 0x91, 0xdb, 0xc7, 0xf8, 0xf6, 0x80, 0xc2, 0x2b, 0xd8, 0x29, 0x84, 0xea, 0xe5, 0xa5, 0x36, 0xbd, 0xd8, - 0x8f, 0x7c, 0x07, 0x7d, 0x3c, 0x9b, 0xe9, 0xc8, 0x0b, 0x32, 0x4c, 0xa7, 0x21, 0x0d, 0x40, 0x42, 0x78, 0xe1, 0xa6, - 0x6e, 0x7f, 0x72, 0x68, 0x9d, 0x4c, 0x15, 0x58, 0xde, 0xe5, 0x4d, 0x27, 0x23, 0x20, 0x2f, 0xec, 0xb2, 0x52, 0xcc, - 0xa7, 0xff, 0x54, 0x8d, 0xed, 0x30, 0x9d, 0x76, 0x38, 0xbb, 0x98, 0xbb, 0x42, 0x63, 0x26, 0x22, 0x2f, 0xca, 0x15, - 0xb6, 0x5e, 0x9c, 0xe6, 0x70, 0x80, 0xf7, 0xb8, 0x7c, 0x43, 0x42, 0xc8, 0x07, 0x2f, 0x48, 0x87, 0xe8, 0x59, 0x9a, - 0x8f, 0x19, 0xf5, 0xc2, 0x5b, 0x5f, 0x64, 0x0a, 0x02, 0xfe, 0x74, 0xeb, 0x23, 0x51, 0x8d, 0xf4, 0x14, 0x2d, 0x4e, - 0xa8, 0x2c, 0xd9, 0x16, 0xc8, 0xe9, 0xbf, 0x20, 0x3a, 0x18, 0x63, 0xf9, 0x36, 0xe1, 0xcd, 0xcb, 0x2d, 0x6b, 0xbc, - 0xfd, 0xc8, 0x76, 0x86, 0x52, 0xfe, 0xc6, 0x71, 0x88, 0xe9, 0x4c, 0x26, 0x76, 0x66, 0x02, 0x46, 0x0f, 0x0b, 0x68, - 0x1d, 0xb8, 0x19, 0x79, 0xfc, 0xe4, 0xd5, 0x9b, 0x90, 0x9b, 0xcf, 0xd5, 0xff, 0xfc, 0xb2, 0x75, 0x16, 0xf7, 0x6e, - 0x2f, 0x25, 0x0e, 0x9d, 0x99, 0xcd, 0x32, 0x18, 0xaf, 0x68, 0x80, 0xe0, 0xe4, 0x1a, 0x30, 0x0c, 0xca, 0xd2, 0x0f, - 0x04, 0x8c, 0x5d, 0x1e, 0xa9, 0xba, 0x19, 0x3f, 0x42, 0xcc, 0x76, 0x59, 0x3e, 0x44, 0x5a, 0x18, 0xed, 0x5b, 0xa0, - 0xb0, 0x03, 0x66, 0x2e, 0x8e, 0x40, 0xde, 0x73, 0x99, 0x79, 0x0d, 0x44, 0xeb, 0xf3, 0xcd, 0x79, 0x7c, 0x9d, 0x94, - 0xff, 0x28, 0x9a, 0x43, 0x5a, 0xd1, 0x8c, 0xfc, 0x3e, 0x1a, 0x3d, 0xd6, 0xdb, 0xbc, 0xd9, 0x8e, 0xab, 0x4c, 0xd9, - 0x12, 0x8c, 0x28, 0xb9, 0xb1, 0xc3, 0x7c, 0x50, 0x71, 0x15, 0xd8, 0x92, 0xaf, 0xd1, 0xad, 0x1d, 0xe2, 0x70, 0xee, - 0x37, 0x2d, 0xf2, 0xb6, 0xe5, 0xe8, 0xa2, 0xb0, 0x5b, 0x81, 0xf3, 0xab, 0x86, 0xb6, 0x12, 0xdf, 0xc8, 0x9f, 0x8c, - 0x89, 0x2a, 0x24, 0x88, 0x09, 0x7a, 0x34, 0x9c, 0x7f, 0x10, 0xa2, 0xa1, 0xcb, 0x64, 0xb7, 0x6c, 0xd2, 0x97, 0xda, - 0xc2, 0x55, 0x60, 0x16, 0xd8, 0x6d, 0xec, 0x77, 0x7d, 0x3c, 0x6f, 0xc7, 0x65, 0x66, 0xcd, 0x87, 0x5a, 0xf1, 0x15, - 0xce, 0x05, 0x41, 0xa5, 0x35, 0xdc, 0x92, 0xfc, 0xdf, 0xcf, 0xfb, 0x67, 0xdc, 0x7a, 0x5a, 0xf6, 0xea, 0x7b, 0xe8, - 0xf7, 0xf5, 0x5e, 0x2d, 0x17, 0xbd, 0x48, 0x2d, 0xfa, 0x6a, 0x34, 0x6d, 0x3c, 0xbf, 0x7f, 0x7d, 0x7d, 0x21, 0x9d, - 0xde, 0xf1, 0x2b, 0xbf, 0x85, 0xee, 0x1d, 0xb8, 0xa2, 0xdc, 0xe0, 0xe7, 0x2a, 0x1e, 0xce, 0xfe, 0x2b, 0x77, 0x58, - 0x1d, 0xd7, 0xaf, 0xaa, 0xcb, 0x36, 0xc7, 0x33, 0xd8, 0x1b, 0xfd, 0xb6, 0x3d, 0x03, 0xfe, 0xbf, 0x05, 0x48, 0x7c, - 0x91, 0x92, 0x49, 0x05, 0x0a, 0x40, 0xa0, 0xbb, 0x1e, 0xfc, 0x11, 0x84, 0x51, 0x4a, 0x3b, 0x7c, 0xfc, 0x98, 0x4c, - 0x54, 0x70, 0x78, 0x75, 0x6e, 0xa1, 0x59, 0x8f, 0xf4, 0xfb, 0x3c, 0xdd, 0xf5, 0xf8, 0x53, 0x1b, 0x55, 0x27, 0x02, - 0x99, 0xd9, 0x38, 0xd3, 0x4e, 0xb9, 0xfe, 0x6d, 0xa3, 0x3f, 0xab, 0xf0, 0xad, 0x42, 0x45, 0x77, 0x5f, 0xfc, 0xe3, - 0xaa, 0xd1, 0xbb, 0xee, 0x2a, 0xfc, 0x70, 0xd5, 0xab, 0xb7, 0xdd, 0xed, 0xbb, 0x15, 0x15, 0x6b, 0x58, 0x9e, 0x31, - 0xc3, 0xa0, 0x39, 0x22, 0x9a, 0x9d, 0xf2, 0xff, 0x7d, 0x64, 0xeb, 0x45, 0xc4, 0x92, 0xad, 0xb8, 0x00, 0x79, 0xb1, - 0x8d, 0xd3, 0x67, 0xf1, 0x46, 0x35, 0x17, 0xae, 0x3c, 0xea, 0xdd, 0x49, 0xba, 0x37, 0x18, 0xaa, 0xf9, 0xfd, 0x80, - 0xd7, 0x05, 0x5d, 0x39, 0xf1, 0xd1, 0xf1, 0x4e, 0xd9, 0xfa, 0x68, 0x6c, 0xff, 0x2b, 0x5f, 0x43, 0xc7, 0xe6, 0xc5, - 0xb6, 0x03, 0xbb, 0xe1, 0xc7, 0x6c, 0xe2, 0xcd, 0xa7, 0xf5, 0xf8, 0x8c, 0xcf, 0xd3, 0xb8, 0xc7, 0x18, 0xde, 0x19, - 0xb7, 0xe6, 0x01, 0x9f, 0x19, 0x65, 0x06, 0x72, 0x19, 0xb2, 0xf7, 0x1e, 0xd6, 0xe8, 0xa9, 0x03, 0xfa, 0x35, 0x15, - 0x0a, 0x80, 0x45, 0xb9, 0x98, 0x21, 0xad, 0x99, 0xd1, 0xbf, 0x81, 0x46, 0x94, 0x8c, 0xf2, 0xf9, 0xdc, 0x59, 0x74, - 0x43, 0xa7, 0x4f, 0x40, 0x06, 0xd6, 0xd6, 0x01, 0x6b, 0x89, 0x45, 0x85, 0x68, 0x13, 0x9a, 0x4c, 0x00, 0xee, 0x93, - 0x60, 0x43, 0xe1, 0xd7, 0x5a, 0x4e, 0x82, 0x9f, 0xbb, 0x57, 0x82, 0xa4, 0x97, 0xe2, 0x28, 0x9d, 0x4c, 0x18, 0xb4, - 0x7b, 0xcd, 0xcb, 0x97, 0xbd, 0xcf, 0xed, 0xfa, 0x90, 0xf9, 0xc8, 0x9e, 0xb5, 0xe6, 0x64, 0xe4, 0x6b, 0xcd, 0x51, - 0x77, 0xf2, 0x06, 0x52, 0x36, 0xfb, 0x85, 0x61, 0x81, 0xc5, 0x6f, 0x35, 0x4c, 0x6e, 0xbd, 0x39, 0xa5, 0xf6, 0x11, - 0x4f, 0x12, 0x38, 0x1b, 0x5e, 0x37, 0xd4, 0x5a, 0x68, 0xaf, 0x57, 0x38, 0xaa, 0xf4, 0xe9, 0x4e, 0x29, 0x37, 0xd7, - 0x63, 0xef, 0xbe, 0xf5, 0xad, 0xf4, 0x84, 0xbc, 0xf3, 0x02, 0x9c, 0x95, 0x3f, 0x5f, 0xfb, 0x8f, 0x05, 0xa4, 0xae, - 0x1a, 0x67, 0x73, 0x5b, 0xf6, 0xc6, 0x77, 0x4b, 0xde, 0xbe, 0x17, 0xd6, 0xb0, 0x6e, 0x5b, 0x27, 0x89, 0xd7, 0x6e, - 0x31, 0x2b, 0x2d, 0xe4, 0x33, 0x72, 0xc9, 0x4c, 0x22, 0xe4, 0x1a, 0xa1, 0xe1, 0x5a, 0xaf, 0xd0, 0x6d, 0xd7, 0x10, - 0xe6, 0x2a, 0x4c, 0x8f, 0x2d, 0x11, 0x1c, 0x54, 0xcd, 0xb7, 0xf5, 0xbf, 0x81, 0x1e, 0xfe, 0xd8, 0xec, 0x95, 0x05, - 0x53, 0x3c, 0xe9, 0xdc, 0xd7, 0xfa, 0xbb, 0x46, 0x3c, 0x4a, 0x4f, 0x1a, 0xa2, 0xe8, 0x11, 0x09, 0xf8, 0x5a, 0xc5, - 0xa0, 0x97, 0x15, 0xf7, 0x50, 0xa1, 0x4f, 0x5b, 0x98, 0xa3, 0xc2, 0x55, 0xaf, 0xc8, 0x93, 0x11, 0xfa, 0x4c, 0xad, - 0x0f, 0x84, 0x5c, 0x14, 0xef, 0x7d, 0xd2, 0x7a, 0xbb, 0x3e, 0x5f, 0xe4, 0x0e, 0xe9, 0xdd, 0xdb, 0x84, 0xe9, 0xa5, - 0x43, 0x37, 0xb6, 0xf1, 0x4f, 0xc4, 0xb3, 0x8d, 0xe1, 0x42, 0x95, 0xa5, 0x78, 0x5a, 0x8e, 0x52, 0xdd, 0xd1, 0x98, - 0x24, 0x15, 0xc8, 0xde, 0xd9, 0x76, 0x58, 0x73, 0xe1, 0xab, 0xec, 0xea, 0xd8, 0x03, 0x95, 0xb8, 0x87, 0xe4, 0x0e, - 0xfb, 0xb6, 0xbf, 0xcc, 0x54, 0xa6, 0x21, 0xfe, 0xc7, 0xf7, 0xdc, 0x81, 0x46, 0x7f, 0x3b, 0x8e, 0xe8, 0x58, 0x72, - 0x8b, 0x65, 0xca, 0x70, 0xe4, 0x04, 0x8b, 0xed, 0xde, 0x70, 0xca, 0xb9, 0xec, 0xb4, 0x45, 0x31, 0x4c, 0x72, 0x0f, - 0x8c, 0x6c, 0x45, 0xfb, 0x27, 0xf6, 0x44, 0xc3, 0x9c, 0x9e, 0x9a, 0x77, 0x96, 0xf8, 0x36, 0xed, 0x9f, 0xa8, 0x5d, - 0x42, 0x15, 0xa5, 0xc8, 0x4a, 0xdc, 0xe5, 0x97, 0x76, 0x9b, 0x08, 0xdb, 0x45, 0x98, 0xd6, 0x5e, 0x4f, 0x52, 0x39, - 0xd2, 0x28, 0x75, 0xec, 0xf0, 0xb6, 0x93, 0xa6, 0x02, 0x22, 0x54, 0x54, 0x4f, 0x4a, 0x5a, 0x4a, 0x5f, 0x88, 0x5a, - 0x77, 0x3e, 0xda, 0x8a, 0xf6, 0x04, 0x1c, 0xc0, 0xa6, 0xd5, 0x16, 0x95, 0xca, 0xc3, 0x0d, 0x3b, 0x04, 0xed, 0x2b, - 0x78, 0xf9, 0x00, 0x47, 0x55, 0x9e, 0xde, 0x17, 0xa4, 0xe2, 0xc7, 0x29, 0x36, 0x1e, 0x66, 0x93, 0xa1, 0x12, 0xb8, - 0x31, 0x4a, 0x87, 0xcf, 0xd7, 0xef, 0x74, 0x98, 0xbc, 0xfa, 0xb8, 0xa7, 0x17, 0xd3, 0x2b, 0x20, 0x5e, 0xb8, 0x79, - 0x7f, 0x1c, 0x26, 0xd7, 0x70, 0x82, 0xf4, 0x49, 0xaa, 0xb7, 0x6d, 0x19, 0x03, 0x0a, 0xcb, 0xbe, 0x9c, 0xc6, 0x5e, - 0x4c, 0x7c, 0x9e, 0xbf, 0x4b, 0x1b, 0xd3, 0xb2, 0xc2, 0x58, 0x7b, 0x75, 0xdb, 0x21, 0x5c, 0xe6, 0x0e, 0x7e, 0xf9, - 0x3f, 0x7c, 0xd4, 0x76, 0x73, 0xbf, 0x6e, 0xce, 0x8c, 0x00, 0xcf, 0x48, 0x88, 0xbe, 0x3c, 0x90, 0x2b, 0xd7, 0xaf, - 0xfe, 0x37, 0x50, 0xfc, 0xa4, 0x2b, 0xcd, 0xbf, 0xe6, 0xfa, 0xb0, 0x18, 0x9b, 0x82, 0x6c, 0x1f, 0x49, 0x61, 0x74, - 0x8d, 0x68, 0xbc, 0xdf, 0xb7, 0x61, 0x5d, 0x0d, 0x32, 0x72, 0x8b, 0x90, 0xd7, 0x87, 0x58, 0x60, 0xf4, 0xfd, 0x65, - 0xdb, 0xe2, 0x9b, 0x56, 0x24, 0xde, 0x30, 0xab, 0xb4, 0xfe, 0x17, 0x59, 0xb8, 0xbe, 0xfb, 0xd2, 0x80, 0x80, 0xd6, - 0xda, 0x57, 0xc2, 0x72, 0xe7, 0x08, 0x02, 0x18, 0x94, 0x30, 0x16, 0x4f, 0x22, 0xfa, 0x97, 0xcc, 0x88, 0xd4, 0x53, - 0xc5, 0x74, 0xe2, 0x84, 0xe1, 0xac, 0x04, 0x35, 0x56, 0x7a, 0x80, 0xcd, 0x5c, 0x94, 0xab, 0x61, 0x2b, 0xc6, 0x43, - 0x8a, 0xb8, 0x63, 0xd6, 0xc8, 0x7b, 0x42, 0x25, 0x0d, 0xaa, 0x88, 0x0a, 0x29, 0x8f, 0x42, 0x1c, 0x86, 0x67, 0x10, - 0x02, 0xa4, 0x52, 0xc4, 0x3a, 0x73, 0x49, 0x86, 0x71, 0xe0, 0xb5, 0x53, 0xc9, 0xab, 0xd1, 0xdd, 0x2a, 0x74, 0x0a, - 0x22, 0x3a, 0x30, 0xbb, 0x05, 0x5d, 0x6f, 0x16, 0xb0, 0x5b, 0x31, 0xb5, 0x52, 0xdc, 0xcd, 0x98, 0xad, 0x58, 0x6c, - 0x61, 0x40, 0x24, 0xb4, 0x65, 0xfe, 0x1a, 0x1d, 0xf0, 0xa2, 0x8b, 0xa2, 0x27, 0xa5, 0xf1, 0xdf, 0x94, 0x7a, 0x5f, - 0x50, 0xc3, 0xc8, 0x82, 0x82, 0xeb, 0x6c, 0xdc, 0x4a, 0xfc, 0xf0, 0x96, 0x3a, 0xdc, 0x42, 0xf0, 0x55, 0x48, 0x37, - 0xd5, 0xc2, 0x5c, 0x61, 0x0f, 0xb2, 0xe5, 0xda, 0x72, 0xa3, 0xe3, 0xbb, 0x5e, 0xbb, 0xf0, 0xfc, 0xa5, 0x36, 0xcf, - 0x95, 0x53, 0x3c, 0x96, 0x82, 0x5c, 0xe2, 0xa9, 0x95, 0x75, 0x27, 0xf5, 0x61, 0x58, 0xd3, 0x51, 0x8d, 0x3b, 0xe3, - 0xc9, 0x13, 0x32, 0xc9, 0x97, 0x56, 0xea, 0x9c, 0x50, 0x47, 0xa0, 0xb6, 0x1e, 0x94, 0xa9, 0x5f, 0x8a, 0x2d, 0x60, - 0x1e, 0x1e, 0xf8, 0x8f, 0x61, 0x91, 0x3c, 0x99, 0x44, 0x4e, 0x13, 0x4f, 0xe5, 0xf8, 0x15, 0x9f, 0x33, 0x9e, 0x0c, - 0x27, 0x7b, 0x2c, 0x49, 0x7a, 0xb6, 0x8c, 0xf9, 0x61, 0x00, 0x88, 0x13, 0x61, 0xcc, 0x45, 0x1e, 0x51, 0x28, 0x5a, - 0x9c, 0x5c, 0x57, 0x40, 0x6a, 0xaa, 0x6d, 0xbf, 0xa6, 0xe8, 0x08, 0xcc, 0xd2, 0x65, 0x1a, 0xd5, 0x2c, 0x55, 0x26, - 0x08, 0xe1, 0x73, 0x6e, 0xad, 0x1d, 0x17, 0x30, 0xd3, 0x8e, 0x9e, 0xdb, 0xe4, 0x75, 0xf6, 0x47, 0x46, 0x66, 0xea, - 0xce, 0xaa, 0xc6, 0x04, 0x63, 0x57, 0xed, 0xd2, 0x50, 0x79, 0xe3, 0x64, 0xf7, 0xd5, 0xa9, 0xdd, 0x86, 0x32, 0xb8, - 0x88, 0x89, 0x87, 0x6c, 0x04, 0x20, 0xba, 0x96, 0xab, 0x95, 0x27, 0xc7, 0xc6, 0x10, 0xe6, 0xa6, 0x38, 0xcf, 0x81, - 0xb6, 0x7f, 0xdc, 0xb5, 0x50, 0x2b, 0x44, 0x56, 0x36, 0xfb, 0x67, 0x13, 0x78, 0xbd, 0x58, 0xbc, 0x08, 0x2f, 0xe6, - 0x41, 0x2a, 0x2f, 0x16, 0xbf, 0xb2, 0x94, 0x86, 0x14, 0x61, 0x2d, 0xb0, 0xb9, 0xb4, 0x92, 0x67, 0xcb, 0xe9, 0x85, - 0xeb, 0x99, 0xcc, 0xbc, 0x10, 0x30, 0x66, 0xe9, 0x57, 0x5e, 0xa2, 0xb3, 0x03, 0xfb, 0x9f, 0xfd, 0x86, 0x3a, 0x22, - 0x53, 0xb0, 0xe9, 0x36, 0x46, 0x6a, 0x91, 0xac, 0x24, 0xea, 0x47, 0x56, 0x3e, 0x7b, 0xd7, 0xea, 0xb7, 0xda, 0xb9, - 0x21, 0x50, 0xf8, 0xde, 0x88, 0x09, 0x0d, 0x2a, 0xb1, 0xa4, 0x6e, 0xdc, 0x07, 0xe7, 0x41, 0x59, 0xd3, 0xaf, 0x04, - 0x82, 0xff, 0xc4, 0x6e, 0xda, 0x25, 0x57, 0x90, 0x2e, 0x06, 0x77, 0x2a, 0x54, 0x37, 0x44, 0x78, 0x7d, 0x76, 0x2f, - 0xd1, 0xc4, 0x61, 0xb6, 0x22, 0x0b, 0x3d, 0xbc, 0xf6, 0xe0, 0xf6, 0x79, 0x66, 0x2d, 0xee, 0x54, 0x82, 0xf6, 0xb5, - 0xd9, 0xab, 0x7e, 0xf2, 0x78, 0xf0, 0xab, 0xc1, 0x73, 0x41, 0x06, 0x37, 0xbb, 0x41, 0xd4, 0x0f, 0xa1, 0xf3, 0x2c, - 0xf8, 0x1e, 0xc1, 0x94, 0xfe, 0x95, 0x17, 0xe2, 0x57, 0x83, 0x8f, 0x32, 0x33, 0xa8, 0x1e, 0xab, 0x08, 0x52, 0x7e, - 0x92, 0x61, 0x84, 0x91, 0x61, 0xe8, 0xba, 0x0a, 0x51, 0xc2, 0x1b, 0x2c, 0x36, 0xb3, 0x7b, 0x53, 0xf3, 0x7f, 0x81, - 0xd4, 0x21, 0xfc, 0x90, 0xd8, 0x13, 0xf3, 0x10, 0xf6, 0x6a, 0xe6, 0x71, 0xb6, 0xaf, 0xa2, 0x8e, 0xf5, 0x66, 0x8b, - 0x27, 0x16, 0x54, 0x1f, 0xc2, 0xda, 0x54, 0x81, 0x4b, 0xc4, 0xdc, 0xae, 0xfd, 0x7f, 0xfc, 0x75, 0xda, 0xb1, 0x8d, - 0x98, 0x99, 0x1e, 0x8e, 0xfb, 0xc6, 0x15, 0x51, 0x17, 0xa0, 0x60, 0x0e, 0x5a, 0x57, 0xb0, 0x12, 0x8f, 0xda, 0xd3, - 0xdb, 0xae, 0xbf, 0x1f, 0x20, 0xc4, 0x0f, 0xcd, 0xf2, 0xbe, 0x42, 0x6c, 0x34, 0x69, 0xbb, 0xb1, 0x73, 0x6c, 0xab, - 0x0e, 0x2b, 0x0a, 0x25, 0x74, 0x43, 0x03, 0xe7, 0x6e, 0x20, 0xc0, 0xfa, 0x29, 0xce, 0xa2, 0x5d, 0xd8, 0x43, 0xd7, - 0x6e, 0x6b, 0x3c, 0x35, 0x7a, 0x62, 0xa4, 0x95, 0x80, 0x2d, 0x53, 0xdf, 0x79, 0x45, 0x77, 0x9b, 0x1b, 0x76, 0xae, - 0xcf, 0x6d, 0xa9, 0xf6, 0xe3, 0x78, 0x6c, 0x1b, 0x66, 0x99, 0xda, 0xbd, 0xbb, 0x66, 0xae, 0x7e, 0xb9, 0xce, 0x54, - 0x84, 0x6c, 0x38, 0x85, 0xe4, 0x84, 0xe4, 0xb6, 0xd7, 0x92, 0x18, 0xc5, 0x7a, 0xc7, 0x06, 0x8e, 0x90, 0x73, 0xb6, - 0x62, 0x06, 0x6b, 0xb3, 0xdd, 0xc7, 0xc2, 0x64, 0xc3, 0x69, 0xed, 0x1e, 0x5a, 0x68, 0x04, 0x97, 0x8c, 0xe7, 0x2a, - 0x93, 0xc5, 0xe3, 0x0e, 0xf3, 0xcb, 0xf6, 0x19, 0x8d, 0x17, 0x0d, 0xa7, 0x1a, 0x7b, 0x53, 0x52, 0x46, 0xb3, 0xef, - 0xdc, 0xd2, 0x5a, 0x24, 0xde, 0xbc, 0xa7, 0x77, 0x82, 0xa1, 0xb5, 0xf7, 0xaa, 0x2d, 0x80, 0xfa, 0x9f, 0xed, 0xac, - 0x58, 0xd0, 0x38, 0xec, 0x0c, 0x70, 0xe3, 0xe2, 0x79, 0x87, 0xe2, 0x31, 0x99, 0xe9, 0xbd, 0x15, 0x59, 0xef, 0xf2, - 0xbf, 0xda, 0xae, 0x13, 0x9f, 0x3d, 0xba, 0xdb, 0xea, 0xa0, 0xb5, 0xae, 0x8b, 0x94, 0xf8, 0x38, 0xad, 0x5d, 0x4c, - 0xdc, 0x92, 0x85, 0x97, 0x39, 0x9a, 0xff, 0x15, 0x8b, 0x1c, 0x36, 0x68, 0x9c, 0x9b, 0xf8, 0xd6, 0x52, 0x1a, 0x7d, - 0x6a, 0x50, 0x17, 0x26, 0x51, 0x89, 0x20, 0xb4, 0xd2, 0xbf, 0x62, 0xef, 0x6b, 0x6f, 0x33, 0x15, 0xd7, 0x29, 0xce, - 0x60, 0xf2, 0xa8, 0xe7, 0x1c, 0x49, 0xc7, 0x2c, 0x6b, 0x7c, 0x03, 0x4d, 0xdb, 0x4a, 0xd3, 0x64, 0x54, 0xc3, 0x46, - 0xac, 0x33, 0x1b, 0xf1, 0xc2, 0x48, 0xd3, 0xb6, 0x2b, 0xa1, 0xd3, 0xa9, 0xfa, 0xc5, 0x13, 0xe7, 0xd6, 0xc2, 0x7f, - 0xcb, 0x8b, 0x03, 0xc4, 0xb9, 0xae, 0x46, 0x1a, 0x19, 0x74, 0xe1, 0x2e, 0x3e, 0xe5, 0x8e, 0x5b, 0x39, 0x86, 0x60, - 0xd5, 0x6a, 0xe3, 0xe2, 0x50, 0xd6, 0xd7, 0x20, 0xf5, 0x3e, 0x18, 0x69, 0x32, 0x66, 0x57, 0xce, 0x9f, 0xe6, 0xe9, - 0xa1, 0x44, 0x99, 0x1a, 0x99, 0x36, 0x7c, 0xcf, 0xaf, 0xe6, 0x24, 0x76, 0x6d, 0x3c, 0x1f, 0x9c, 0x98, 0x7a, 0x2b, - 0x67, 0x25, 0x45, 0x01, 0xd0, 0x86, 0xb9, 0xb6, 0x64, 0x23, 0x65, 0xda, 0xb3, 0xce, 0xfb, 0x76, 0xe7, 0x8a, 0x93, - 0xd9, 0x69, 0x02, 0x5d, 0xa1, 0xa9, 0xea, 0xd4, 0x0c, 0x8d, 0x10, 0x98, 0xf1, 0x61, 0x0a, 0xfd, 0xa2, 0x48, 0x30, - 0x74, 0xd3, 0x0b, 0x8a, 0x15, 0x27, 0x9a, 0xe7, 0x4b, 0x5d, 0x25, 0xe1, 0xa6, 0xf6, 0x7e, 0xed, 0xfe, 0x97, 0x9e, - 0xdc, 0x45, 0x9d, 0x09, 0x41, 0x29, 0x60, 0xd2, 0x71, 0xf0, 0x61, 0x28, 0xc3, 0x1f, 0x57, 0x30, 0x7a, 0x91, 0x59, - 0x7f, 0x20, 0x92, 0x43, 0xc5, 0x77, 0x96, 0x5f, 0x5a, 0xa1, 0xf8, 0x89, 0xc8, 0x0e, 0x8a, 0xaf, 0x41, 0xc0, 0x23, - 0xa8, 0xd9, 0x4e, 0x57, 0x82, 0x27, 0x78, 0xc7, 0x8b, 0x7c, 0xc5, 0xc8, 0xeb, 0x69, 0xb5, 0xa4, 0x61, 0x68, 0x8e, - 0x25, 0x41, 0x63, 0x53, 0xc7, 0x12, 0x82, 0x79, 0x5f, 0x1f, 0xeb, 0xb9, 0xd5, 0x8e, 0x02, 0x27, 0x58, 0xfb, 0x81, - 0xb4, 0x8e, 0x74, 0x3c, 0xb5, 0x68, 0xd6, 0x36, 0x32, 0xd1, 0xd9, 0xc4, 0x40, 0x3a, 0x0b, 0x0e, 0x36, 0xe6, 0xd3, - 0x68, 0xae, 0xbc, 0x61, 0x04, 0xff, 0xbd, 0x0a, 0xcb, 0x59, 0x7a, 0xb5, 0xe5, 0x62, 0x1c, 0x55, 0xf8, 0x3f, 0x0d, - 0x13, 0xbe, 0xc9, 0xf9, 0xb8, 0x5c, 0x24, 0x44, 0xa8, 0x80, 0x07, 0x3a, 0x26, 0x7c, 0x1d, 0xad, 0x86, 0x11, 0x5a, - 0x75, 0x2b, 0xc8, 0x11, 0xd2, 0x7e, 0xdf, 0x54, 0x5b, 0xdf, 0x34, 0x67, 0x6f, 0xcf, 0x0d, 0x9b, 0x06, 0xf3, 0xe3, - 0x73, 0x8f, 0x4d, 0x37, 0x12, 0x55, 0x2c, 0xbf, 0x83, 0x8f, 0xda, 0x98, 0xe1, 0x83, 0xfe, 0xf0, 0xa6, 0x71, 0xcc, - 0x78, 0x95, 0x4d, 0x9a, 0xf4, 0xc3, 0x99, 0x6b, 0x81, 0xda, 0xa7, 0xa6, 0xee, 0x48, 0xd1, 0x81, 0xa3, 0xab, 0xf9, - 0x16, 0x5f, 0x89, 0xf0, 0xf0, 0x6b, 0x12, 0x95, 0x35, 0xcd, 0xa0, 0x4e, 0xa5, 0x34, 0x51, 0x75, 0xdb, 0x54, 0x00, - 0x7b, 0xcf, 0xb0, 0x32, 0x50, 0xa3, 0x27, 0xba, 0x13, 0x34, 0x42, 0x1a, 0xc7, 0x9f, 0x42, 0xfb, 0x91, 0xc6, 0x6f, - 0xc5, 0x94, 0x63, 0x3b, 0x86, 0x79, 0xd5, 0x00, 0x55, 0x0b, 0x7d, 0xfc, 0xeb, 0x9b, 0xad, 0xdb, 0xb5, 0xed, 0x76, - 0x87, 0xb0, 0x54, 0x2f, 0x8f, 0x5a, 0x34, 0x93, 0x98, 0xa6, 0x14, 0x16, 0x5d, 0xb4, 0x8e, 0x97, 0xd3, 0xc6, 0x41, - 0xad, 0x30, 0xd8, 0x16, 0xaa, 0x74, 0x19, 0x31, 0xdc, 0x4e, 0x61, 0x84, 0x4c, 0xa1, 0x42, 0x1f, 0xb1, 0x66, 0xba, - 0x75, 0xf7, 0x50, 0x5a, 0xcb, 0xf2, 0xad, 0x17, 0x6b, 0xd4, 0xb7, 0xde, 0x66, 0x35, 0x8a, 0x5a, 0x4c, 0xbc, 0x12, - 0x8c, 0xae, 0x2f, 0x13, 0x5a, 0xb9, 0x45, 0x5b, 0xa5, 0x20, 0x48, 0xec, 0xd6, 0xe2, 0x2b, 0xd1, 0x8e, 0xcd, 0x1c, - 0x89, 0xc9, 0xfc, 0xf4, 0xda, 0x54, 0x86, 0xca, 0x87, 0x0f, 0x3e, 0x67, 0x68, 0x8a, 0x27, 0xef, 0xc0, 0x4f, 0xba, - 0xfc, 0x49, 0xea, 0x03, 0xef, 0xb6, 0x0c, 0x4e, 0x51, 0x3b, 0xb7, 0x74, 0x18, 0xc0, 0x75, 0x52, 0xf0, 0x82, 0x2b, - 0x4c, 0x92, 0x46, 0x3e, 0x3a, 0x41, 0x4c, 0x8a, 0xce, 0x94, 0x35, 0x18, 0x94, 0xb5, 0x0c, 0x80, 0x35, 0xda, 0x84, - 0xe1, 0x23, 0x90, 0x19, 0x63, 0x06, 0x69, 0x1b, 0xe6, 0x94, 0xcf, 0xba, 0x3f, 0xbe, 0x10, 0xba, 0x3d, 0xd8, 0x13, - 0x51, 0x96, 0x0f, 0xc8, 0x07, 0x1d, 0xd2, 0xbf, 0x22, 0x31, 0xca, 0xe1, 0xb9, 0xdc, 0x7f, 0x12, 0x58, 0x38, 0x80, - 0x9b, 0xb5, 0x77, 0xec, 0x80, 0x64, 0xde, 0x2a, 0x2c, 0xbf, 0x1f, 0x02, 0x0c, 0x5b, 0x3b, 0xb1, 0x9c, 0x15, 0xa3, - 0x65, 0x39, 0x59, 0x41, 0xc3, 0xf2, 0x37, 0x80, 0xaf, 0x03, 0x56, 0xbd, 0x5f, 0xe2, 0x32, 0x53, 0x14, 0xf8, 0x67, - 0xe3, 0xb4, 0x4a, 0x5b, 0x10, 0x1f, 0x04, 0x22, 0x0f, 0xb0, 0x07, 0x57, 0x8f, 0x85, 0xb7, 0x53, 0xbe, 0x8b, 0xca, - 0xd2, 0x35, 0x1a, 0x39, 0xa5, 0x7a, 0xbf, 0xc5, 0x76, 0x83, 0x3d, 0x08, 0xa9, 0x2d, 0x94, 0x7f, 0x85, 0xaa, 0x4a, - 0x51, 0xeb, 0xcd, 0x08, 0x83, 0x16, 0x9c, 0x9b, 0x23, 0x50, 0x43, 0x60, 0xd4, 0xda, 0x5c, 0x4b, 0xa0, 0x35, 0x3f, - 0x80, 0x5d, 0xe7, 0xe3, 0x97, 0x51, 0x4c, 0x78, 0xbc, 0x6f, 0x1a, 0x93, 0x93, 0x1f, 0x3d, 0xee, 0xfa, 0x66, 0xdd, - 0x64, 0x88, 0x59, 0x24, 0xf5, 0x3c, 0xc2, 0x6c, 0xe7, 0xb5, 0x70, 0xb1, 0x3a, 0x41, 0xcf, 0xe5, 0x8a, 0x14, 0xf7, - 0xa8, 0xbb, 0x65, 0xf7, 0x7c, 0xaa, 0x9e, 0xc4, 0x58, 0x4b, 0x11, 0x3f, 0xc5, 0xb5, 0x99, 0x50, 0xa5, 0xc8, 0xcd, - 0x26, 0xb0, 0x95, 0x23, 0xed, 0xf1, 0x48, 0x96, 0x13, 0x75, 0xac, 0x41, 0xd4, 0x3c, 0xbe, 0xb3, 0x72, 0xe8, 0x46, - 0x77, 0xd8, 0x37, 0xff, 0x1f, 0xbb, 0xe9, 0xe9, 0x38, 0x93, 0x65, 0xf0, 0x32, 0x06, 0x67, 0xbc, 0xf3, 0xc2, 0xb4, - 0x4a, 0x45, 0x8c, 0x46, 0x3f, 0x16, 0x7d, 0x7f, 0xaa, 0x77, 0x5d, 0x82, 0x20, 0xd5, 0xe5, 0xbf, 0x81, 0xa3, 0xba, - 0x3a, 0x5c, 0x7a, 0x7a, 0xe6, 0x96, 0x46, 0x97, 0xef, 0x98, 0xc1, 0x5d, 0x05, 0x13, 0x60, 0x0d, 0xbc, 0x45, 0xef, - 0xdc, 0x12, 0xc2, 0x65, 0xd4, 0xbb, 0xee, 0x95, 0x53, 0x28, 0x3a, 0x47, 0x77, 0x83, 0x84, 0x1a, 0xae, 0xf3, 0xdc, - 0x3e, 0x5a, 0x29, 0x2a, 0x1f, 0xe7, 0xc3, 0x85, 0xb3, 0x44, 0x12, 0x05, 0xc7, 0x4b, 0x08, 0xd7, 0x7d, 0x3b, 0x66, - 0x84, 0x91, 0x6d, 0x4b, 0xa5, 0xba, 0xe1, 0x5d, 0xe8, 0x51, 0xcc, 0x5a, 0x36, 0xe0, 0xfc, 0x7f, 0xe9, 0xf5, 0x48, - 0xba, 0xb7, 0x29, 0xf1, 0xb8, 0xf0, 0xef, 0xe2, 0xc8, 0x29, 0x28, 0x89, 0x4a, 0xb4, 0x7d, 0x57, 0x76, 0xe0, 0x78, - 0x68, 0x0f, 0xe9, 0xb4, 0x29, 0xcb, 0x2a, 0x00, 0xad, 0x7d, 0xe6, 0x65, 0xe4, 0x64, 0xf4, 0xa4, 0xbd, 0x43, 0xd1, - 0x1b, 0x54, 0x26, 0x21, 0x87, 0x41, 0x22, 0xe6, 0x3a, 0xe0, 0xee, 0xaa, 0xdb, 0x5d, 0x73, 0x15, 0xba, 0x6b, 0x76, - 0xe5, 0x80, 0x8e, 0xe4, 0x90, 0x64, 0xe6, 0xac, 0xf6, 0x41, 0x11, 0x45, 0xde, 0x23, 0xf6, 0xc5, 0x9d, 0x4a, 0xba, - 0x99, 0x77, 0x51, 0x48, 0x14, 0x10, 0xc6, 0x29, 0x88, 0xf7, 0x04, 0x08, 0xa5, 0x75, 0x77, 0xd4, 0x26, 0x5c, 0xf5, - 0x4c, 0x5b, 0x19, 0xc3, 0x9d, 0xce, 0x9d, 0x91, 0x5d, 0xe0, 0x52, 0xf7, 0x62, 0x08, 0xa2, 0x40, 0x4e, 0x41, 0x0c, - 0x27, 0x41, 0xf1, 0xa1, 0x38, 0x90, 0x80, 0x43, 0xe4, 0x41, 0xa9, 0x71, 0xc9, 0xdc, 0x78, 0xa3, 0x10, 0x62, 0x31, - 0x12, 0x31, 0x21, 0xd9, 0x30, 0x70, 0x4c, 0x05, 0xda, 0xfd, 0x72, 0xdf, 0x7b, 0xe1, 0xf7, 0x43, 0x4d, 0x2d, 0xe6, - 0x42, 0x16, 0x46, 0xab, 0x93, 0x7b, 0x81, 0x63, 0xbe, 0x57, 0x2f, 0xb7, 0x91, 0xbd, 0xf0, 0x8d, 0x4b, 0x72, 0x95, - 0x12, 0x10, 0xf6, 0x1f, 0x8c, 0x03, 0x01, 0x30, 0x97, 0x56, 0xb5, 0x96, 0xc8, 0xc3, 0x1b, 0x69, 0xd6, 0xb4, 0x14, - 0xeb, 0x66, 0x1e, 0x2a, 0xc0, 0x92, 0x5a, 0xdc, 0x30, 0x97, 0x15, 0xce, 0x68, 0x0e, 0x4a, 0x78, 0xd3, 0x42, 0xd7, - 0xe6, 0x73, 0x78, 0x92, 0xe6, 0xe8, 0xf7, 0xf0, 0x56, 0x75, 0xcb, 0x92, 0xea, 0x4c, 0x32, 0x98, 0xc8, 0x54, 0xea, - 0x69, 0x38, 0xee, 0xa4, 0xef, 0x04, 0x63, 0xb2, 0xd0, 0x78, 0x27, 0xeb, 0x6c, 0xec, 0x0c, 0x7d, 0x60, 0x7f, 0xc0, - 0x05, 0xc5, 0x77, 0x49, 0xc7, 0xb7, 0x49, 0x84, 0x45, 0x56, 0x76, 0xed, 0xf2, 0xd2, 0xf7, 0x5d, 0x6f, 0xe6, 0xa5, - 0xfb, 0xec, 0xbb, 0xdf, 0xbd, 0x25, 0x6b, 0x45, 0xc9, 0x49, 0xf2, 0x84, 0xe5, 0x6d, 0xda, 0x1e, 0xf2, 0x74, 0x60, - 0xc8, 0xdc, 0x38, 0xae, 0x7f, 0x51, 0x8c, 0x34, 0x75, 0xd8, 0x51, 0x7a, 0x53, 0x81, 0xa7, 0xf6, 0x39, 0x8b, 0x0e, - 0x14, 0xcf, 0x30, 0x5d, 0x13, 0xe1, 0xcd, 0xfe, 0xc5, 0xfc, 0xdf, 0x03, 0xa2, 0xe3, 0xc3, 0x98, 0x36, 0xe4, 0xc3, - 0x2a, 0xbc, 0x14, 0xc7, 0xe2, 0x07, 0x8b, 0x49, 0xe4, 0x49, 0x1c, 0xe0, 0x7d, 0x60, 0x91, 0x0a, 0x23, 0x83, 0x3a, - 0x56, 0x76, 0xc7, 0xf1, 0x02, 0x30, 0xe2, 0x21, 0xe3, 0xfc, 0xe2, 0x33, 0x10, 0x38, 0x5e, 0xa8, 0x66, 0x3b, 0x87, - 0x15, 0x08, 0x80, 0x8c, 0x59, 0xa9, 0xb8, 0x18, 0xcd, 0xa2, 0x14, 0x83, 0x67, 0x7c, 0x68, 0x57, 0x0d, 0xb1, 0xcc, - 0xfc, 0x60, 0x50, 0xce, 0xad, 0x85, 0x14, 0xdc, 0xae, 0x2f, 0x8c, 0x09, 0x6e, 0xdb, 0x48, 0xb0, 0x45, 0xfd, 0x18, - 0x10, 0x8b, 0x0b, 0xea, 0x1a, 0xbf, 0xd7, 0x99, 0x3b, 0x69, 0x9f, 0xb8, 0x8e, 0xd2, 0xb2, 0x94, 0xc4, 0x75, 0x1e, - 0x46, 0x02, 0xc1, 0xf4, 0x9a, 0x10, 0x95, 0x18, 0x62, 0x1f, 0xcb, 0xbd, 0x01, 0xf0, 0x18, 0xa2, 0x23, 0xc7, 0xec, - 0xbc, 0x43, 0x78, 0xba, 0x81, 0x5f, 0x16, 0xbf, 0x95, 0xf1, 0xeb, 0xe3, 0x51, 0x76, 0x44, 0x3e, 0xbc, 0x91, 0xb8, - 0x53, 0x31, 0x07, 0xd2, 0xc8, 0x15, 0xb0, 0xb4, 0x05, 0x72, 0x91, 0x71, 0x0c, 0x5b, 0x3f, 0xb5, 0x3e, 0x06, 0x3f, - 0xf6, 0xb1, 0xe8, 0xf8, 0x75, 0xa0, 0xaf, 0x52, 0x22, 0x7f, 0x2b, 0xa5, 0x38, 0x7b, 0x6f, 0x46, 0xbb, 0x3b, 0x71, - 0x53, 0xaf, 0xec, 0x6d, 0x43, 0x7d, 0x93, 0xb8, 0x7d, 0x6b, 0x1e, 0x03, 0xee, 0xeb, 0xc4, 0x8d, 0xa1, 0xd0, 0x27, - 0xcb, 0xe3, 0x46, 0x53, 0x13, 0x43, 0x77, 0x1e, 0xe1, 0x57, 0xa7, 0x3d, 0x9c, 0xdd, 0x97, 0x26, 0xdd, 0x08, 0xb3, - 0xb8, 0xd8, 0x25, 0x19, 0x1c, 0x06, 0x2c, 0x0e, 0x45, 0x8a, 0x16, 0xb9, 0x6c, 0x0c, 0x91, 0xc3, 0x0e, 0xee, 0x26, - 0x8d, 0x53, 0xde, 0x31, 0x78, 0x69, 0x52, 0x9f, 0xb7, 0xd5, 0x62, 0x42, 0x4d, 0x98, 0x6a, 0xf0, 0xd6, 0xb6, 0x7c, - 0x2c, 0x94, 0x72, 0x12, 0x48, 0xa7, 0x2c, 0x54, 0x0a, 0x7e, 0xe2, 0x0f, 0xf7, 0x7f, 0x50, 0x94, 0x3b, 0x02, 0x6e, - 0x05, 0x1d, 0xfe, 0x7c, 0x10, 0x2f, 0x63, 0x88, 0x47, 0x46, 0xc6, 0xf4, 0x2f, 0x29, 0xab, 0x7e, 0x05, 0x99, 0x98, - 0xaf, 0xb3, 0x07, 0xb9, 0x1a, 0xdf, 0xa9, 0xb5, 0x30, 0xae, 0x23, 0x0d, 0x4d, 0xcc, 0x4f, 0xa1, 0xb0, 0xe9, 0x2a, - 0x03, 0x0b, 0xa5, 0x0c, 0xf9, 0xbe, 0xd4, 0xed, 0xa3, 0xe1, 0x27, 0xa1, 0xe7, 0xd3, 0x0c, 0x93, 0x90, 0x16, 0x40, - 0xf5, 0xe1, 0x68, 0xd2, 0x0d, 0x76, 0xf3, 0x51, 0x07, 0x2a, 0x9d, 0x1d, 0x73, 0x4a, 0x90, 0xf3, 0xfc, 0x64, 0x1b, - 0x7b, 0xc7, 0x5f, 0x1b, 0x7f, 0x83, 0xc0, 0x67, 0xfe, 0xa3, 0x37, 0x55, 0x1b, 0x88, 0xf5, 0x72, 0x46, 0xd0, 0xb6, - 0x0c, 0xb8, 0xa5, 0xca, 0xa1, 0xd9, 0x52, 0x31, 0x2c, 0xcc, 0xd4, 0xc2, 0x14, 0x2f, 0x3a, 0x41, 0xee, 0x0f, 0x21, - 0x16, 0x28, 0x37, 0x20, 0x65, 0xc9, 0x31, 0x1d, 0x44, 0x8a, 0xde, 0x06, 0x0a, 0x22, 0x94, 0x5f, 0xbf, 0xd4, 0xff, - 0x45, 0x04, 0x58, 0x8e, 0xb4, 0xca, 0x40, 0x32, 0xb5, 0xb1, 0x9c, 0xd4, 0xe2, 0x54, 0x9c, 0x55, 0xca, 0x30, 0xf9, - 0xdd, 0x78, 0xd9, 0x9a, 0xa0, 0x66, 0x08, 0x4f, 0xc9, 0xc1, 0x1a, 0x4d, 0x4c, 0x4f, 0x99, 0xfd, 0x05, 0x17, 0xa2, - 0x41, 0x7e, 0x23, 0xb8, 0x75, 0x2c, 0x6d, 0x14, 0x78, 0xd4, 0xbe, 0x89, 0x15, 0x95, 0x56, 0xe1, 0x9c, 0xa8, 0x99, - 0x6c, 0xcb, 0x5e, 0xee, 0xca, 0x3d, 0x06, 0x2e, 0x33, 0x23, 0xd0, 0x4b, 0xeb, 0x7b, 0xef, 0x00, 0xff, 0xd1, 0xa2, - 0xc8, 0x0d, 0xdb, 0x22, 0x85, 0x8c, 0x6d, 0xbd, 0xf1, 0x5b, 0x7d, 0x8a, 0x83, 0x3c, 0xf6, 0x42, 0x2b, 0x3b, 0xe1, - 0x9d, 0xef, 0x4e, 0x19, 0xe6, 0x45, 0x1c, 0xe7, 0x59, 0x54, 0xe8, 0xc3, 0xa2, 0xaa, 0x44, 0xff, 0x09, 0x00, 0x46, - 0xee, 0x72, 0x2a, 0xfc, 0x5b, 0xc2, 0x6d, 0x7c, 0xd0, 0x4e, 0x0d, 0xe7, 0x73, 0xaa, 0xcf, 0xbb, 0xee, 0x3b, 0xfc, - 0x30, 0x7c, 0xad, 0x71, 0x44, 0x05, 0xa6, 0x69, 0x9e, 0x98, 0xad, 0xe1, 0x77, 0x0a, 0xf8, 0xfe, 0xa1, 0x14, 0xdb, - 0xb0, 0x99, 0x56, 0xed, 0xcd, 0xbc, 0xde, 0xc1, 0x67, 0xce, 0x6a, 0x96, 0xaf, 0x3f, 0xf8, 0x3e, 0xa1, 0x2c, 0xc2, - 0x6f, 0xcb, 0x44, 0x3d, 0xe2, 0x2c, 0x1d, 0x5c, 0xc0, 0xe3, 0x1e, 0xc9, 0xd0, 0xf3, 0x75, 0x36, 0x22, 0x7f, 0xb4, - 0x71, 0x01, 0x69, 0xab, 0x09, 0x25, 0xea, 0x44, 0x8f, 0x48, 0xca, 0x58, 0x58, 0x68, 0x5b, 0x1d, 0x90, 0x45, 0xc1, - 0x72, 0x1b, 0x38, 0x4f, 0x4c, 0x11, 0x0e, 0xdf, 0xb5, 0xa7, 0x8b, 0xa8, 0xff, 0x31, 0x03, 0xf8, 0x0f, 0x98, 0x18, - 0x15, 0xca, 0xff, 0x0e, 0xc3, 0x1f, 0x84, 0x11, 0x71, 0x3a, 0x31, 0x3b, 0x30, 0x60, 0xe4, 0x45, 0x65, 0x46, 0x52, - 0x62, 0xad, 0x95, 0x3c, 0xf8, 0x3e, 0x14, 0x8d, 0xeb, 0x1a, 0x84, 0x60, 0x83, 0x69, 0x05, 0xf1, 0x70, 0x1a, 0x51, - 0xd6, 0x78, 0x34, 0x7e, 0x4f, 0xa5, 0x26, 0xf4, 0xf8, 0x36, 0x4a, 0x16, 0x8f, 0xaa, 0x27, 0xca, 0x47, 0x12, 0x43, - 0xda, 0xc8, 0x49, 0xf1, 0x26, 0xe3, 0xfd, 0xb4, 0x31, 0x22, 0x39, 0x39, 0x9d, 0x1d, 0x91, 0xf2, 0x0b, 0x19, 0x66, - 0xd7, 0x7f, 0xf1, 0xf2, 0x8b, 0x2f, 0xbe, 0x96, 0x4a, 0x54, 0xd7, 0x22, 0x86, 0x6e, 0xd7, 0xd1, 0xfb, 0xae, 0x84, - 0x21, 0x1d, 0x52, 0x1e, 0x14, 0x12, 0x53, 0x59, 0x20, 0x0d, 0xf9, 0x49, 0x54, 0xfe, 0x1e, 0xe6, 0xb3, 0x77, 0xaf, - 0x52, 0x97, 0xa4, 0xac, 0x24, 0x2e, 0x0f, 0x58, 0x9a, 0x4c, 0xbc, 0x39, 0x0f, 0xbb, 0x3f, 0x27, 0x6f, 0xfe, 0xaf, - 0x28, 0x63, 0xaa, 0x29, 0x47, 0x16, 0xea, 0xa0, 0x94, 0xd5, 0x70, 0xda, 0xe2, 0x8b, 0x20, 0xda, 0x2a, 0x74, 0xa9, - 0x79, 0xe0, 0xb2, 0xb0, 0x26, 0x82, 0x2d, 0xe8, 0xe9, 0x30, 0xb2, 0x25, 0xb5, 0x89, 0x4d, 0xaf, 0x23, 0xcf, 0xf2, - 0xa9, 0xda, 0x5d, 0xea, 0x63, 0xef, 0xa0, 0x1e, 0x8b, 0xab, 0xfd, 0xd4, 0x64, 0x1a, 0x70, 0x81, 0xa0, 0x7e, 0x05, - 0xb9, 0x55, 0x8c, 0xb8, 0xd1, 0xcd, 0xfd, 0x63, 0xb5, 0x75, 0x2b, 0xff, 0xb4, 0x0b, 0x22, 0x23, 0x81, 0x81, 0x66, - 0xd1, 0x6a, 0x42, 0x3f, 0x36, 0x2c, 0x85, 0x21, 0x67, 0x4b, 0x66, 0x39, 0xaf, 0x0a, 0xda, 0x95, 0xb6, 0x82, 0x03, - 0x12, 0x46, 0xeb, 0x18, 0x33, 0x83, 0xcf, 0xa1, 0x20, 0x5f, 0xb5, 0xc9, 0x05, 0xfb, 0xe2, 0x9e, 0x26, 0x98, 0x0a, - 0xc2, 0xbc, 0x52, 0x30, 0x9d, 0xf5, 0xcd, 0xc2, 0x1c, 0x0b, 0x85, 0xfc, 0xf8, 0x0b, 0x8a, 0x83, 0xa9, 0x40, 0x17, - 0xf9, 0x2b, 0x0d, 0xdb, 0xce, 0x2c, 0xfa, 0xee, 0x83, 0x02, 0xbc, 0x51, 0x47, 0xe6, 0x25, 0x8b, 0xbf, 0x7a, 0xe7, - 0xe3, 0xe4, 0x1b, 0x2d, 0xb2, 0x8b, 0x89, 0xfe, 0x52, 0x49, 0x33, 0xbf, 0x2e, 0xf5, 0x50, 0xb6, 0xa7, 0x3c, 0xae, - 0x98, 0xe6, 0x3d, 0x4a, 0x7f, 0x1a, 0xf3, 0x84, 0x4c, 0x68, 0x2f, 0xa7, 0xbf, 0x25, 0x6a, 0x76, 0x9f, 0x59, 0xaa, - 0xfe, 0x0d, 0x2f, 0x95, 0x26, 0xe5, 0x58, 0xc6, 0xb4, 0x9e, 0x12, 0xeb, 0x96, 0x05, 0x0c, 0xb2, 0x28, 0x4e, 0x6c, - 0xb4, 0xd9, 0x3b, 0xa2, 0xf9, 0x4e, 0xed, 0x65, 0x72, 0xc2, 0xc2, 0x5c, 0x5d, 0xc9, 0x76, 0x1a, 0x61, 0xb7, 0xde, - 0x13, 0xa9, 0x21, 0x68, 0x46, 0xc9, 0xae, 0x76, 0x7b, 0x41, 0xc3, 0xc4, 0x9a, 0x49, 0x91, 0x2d, 0x9a, 0xe5, 0x4e, - 0xd0, 0x43, 0x3e, 0x95, 0xfc, 0xea, 0x3f, 0x5b, 0x88, 0x9b, 0xcd, 0xf9, 0x3d, 0x23, 0x32, 0x08, 0x83, 0xdc, 0xad, - 0x22, 0x5e, 0xce, 0x04, 0x0a, 0x63, 0x67, 0x82, 0xcd, 0xbb, 0x58, 0x47, 0x58, 0x24, 0xaa, 0x23, 0x69, 0x48, 0x57, - 0x79, 0x08, 0x54, 0xb1, 0xef, 0xc9, 0xd3, 0xca, 0x28, 0x5a, 0xbf, 0x3a, 0xf6, 0x19, 0x10, 0x52, 0x25, 0xcb, 0x8a, - 0xb4, 0x72, 0x85, 0x99, 0x81, 0x91, 0x84, 0x83, 0x23, 0xd0, 0x4d, 0x13, 0xc2, 0xcb, 0x43, 0x7a, 0x69, 0x2d, 0x35, - 0xaa, 0xc5, 0x35, 0x78, 0x25, 0x80, 0xd8, 0x64, 0x8c, 0x5f, 0xef, 0xf6, 0xf4, 0xb0, 0xbe, 0x68, 0xb1, 0xfe, 0x88, - 0x80, 0x63, 0xa4, 0xfb, 0xa2, 0x1c, 0x7a, 0x03, 0x96, 0xb5, 0xc4, 0xb7, 0x8f, 0x61, 0xa8, 0x74, 0xa0, 0x5e, 0x8e, - 0xdc, 0x22, 0xaa, 0x37, 0xc0, 0xb5, 0xdb, 0x15, 0x11, 0xbe, 0x9d, 0x1f, 0xd3, 0xa4, 0x96, 0x10, 0xc4, 0xba, 0x8f, - 0x68, 0x96, 0x89, 0xb0, 0xd9, 0xb8, 0xeb, 0x70, 0x71, 0x0c, 0x45, 0x1f, 0x9e, 0xe2, 0x22, 0x96, 0x9c, 0x2d, 0xbd, - 0xb4, 0x31, 0x4f, 0x87, 0xf4, 0x53, 0xdb, 0x51, 0xe1, 0xd1, 0x0b, 0xcb, 0x85, 0xc6, 0x9d, 0xa4, 0xe0, 0xea, 0x3d, - 0x10, 0x26, 0xe9, 0x73, 0xf7, 0x98, 0xc7, 0xd5, 0xe8, 0x2d, 0x38, 0x7d, 0x0b, 0x68, 0x6f, 0x8a, 0xe0, 0x72, 0xd5, - 0x5e, 0x9a, 0x30, 0xa3, 0x3d, 0xcf, 0x74, 0xb6, 0x24, 0x55, 0x23, 0xde, 0x8b, 0x16, 0xbc, 0x86, 0x72, 0x4f, 0x2c, - 0x61, 0xcc, 0xe0, 0xb6, 0x4b, 0x48, 0xb2, 0xaf, 0xa5, 0x82, 0x95, 0xa0, 0x07, 0xf2, 0xa8, 0x48, 0x46, 0x49, 0xa6, - 0xdb, 0xfe, 0x6c, 0xe6, 0xb6, 0x37, 0x95, 0xdf, 0xb6, 0xce, 0x44, 0x95, 0xa4, 0xaf, 0x57, 0x7d, 0xda, 0x3d, 0xa3, - 0x2b, 0x0f, 0x02, 0xfa, 0x96, 0xd1, 0x5b, 0x2e, 0xb0, 0x6e, 0xc9, 0x0d, 0xa9, 0x20, 0xf6, 0x2e, 0x2b, 0x70, 0xe1, - 0xad, 0x3d, 0x98, 0xb0, 0x06, 0xef, 0x33, 0x3d, 0x69, 0xad, 0xbe, 0x7d, 0xa9, 0xeb, 0xf8, 0xec, 0xbb, 0xed, 0x86, - 0x68, 0xf0, 0x5b, 0x2e, 0xbe, 0x17, 0x9f, 0x99, 0x69, 0x15, 0x0e, 0x66, 0x51, 0xfa, 0x2a, 0xfd, 0x8b, 0x93, 0xd6, - 0x91, 0x0b, 0x70, 0x00, 0xf2, 0x6e, 0xb8, 0x2e, 0xc6, 0x61, 0xbc, 0xe6, 0x84, 0xf3, 0xd4, 0x7b, 0xb0, 0x6b, 0xa7, - 0x14, 0xfc, 0x73, 0x86, 0x8d, 0x1c, 0x32, 0x3b, 0x5e, 0x84, 0x6f, 0x6a, 0x1b, 0x7e, 0x4e, 0xfc, 0x80, 0xbf, 0xce, - 0x0c, 0xef, 0x67, 0x71, 0xf6, 0xb6, 0xc0, 0x1f, 0xa6, 0x78, 0xe1, 0xcf, 0x95, 0x30, 0xe3, 0x2b, 0xfe, 0x95, 0xf8, - 0x6f, 0x04, 0x6f, 0x98, 0x70, 0x99, 0xad, 0x35, 0x5a, 0x64, 0xf3, 0x9b, 0x7c, 0x7a, 0x77, 0xf7, 0x70, 0x76, 0xb3, - 0x5a, 0x56, 0xb4, 0x61, 0x25, 0x7b, 0x8e, 0xea, 0x3a, 0xae, 0xca, 0xfe, 0x99, 0xc2, 0x6a, 0x69, 0xdf, 0x51, 0x24, - 0xf7, 0x26, 0xe9, 0xb3, 0xb7, 0x9b, 0x53, 0x93, 0x87, 0xa2, 0x09, 0x1d, 0xe9, 0xcb, 0xa3, 0xb5, 0x04, 0x9e, 0x96, - 0x5d, 0xa9, 0x8b, 0x60, 0xf2, 0xc3, 0xcc, 0xcb, 0x5e, 0xa4, 0x34, 0x55, 0x87, 0xdd, 0xb5, 0x8a, 0x24, 0x54, 0x69, - 0x47, 0xee, 0x94, 0x62, 0xd2, 0xaa, 0x03, 0x67, 0xa0, 0x20, 0xfb, 0x4a, 0x24, 0x4e, 0xf8, 0x21, 0x7a, 0xf0, 0x81, - 0xf1, 0xa4, 0x88, 0xe6, 0xc1, 0x14, 0xe1, 0xff, 0x9f, 0xae, 0x67, 0xd5, 0x33, 0x1b, 0xa0, 0xd6, 0xff, 0x05, 0x62, - 0x0e, 0x4d, 0x55, 0x42, 0xf2, 0xc0, 0x84, 0x3b, 0x7f, 0x7a, 0xd6, 0x0c, 0x16, 0x96, 0x1f, 0xd5, 0x61, 0x90, 0xa7, - 0xd9, 0x39, 0x99, 0xc8, 0x38, 0x4e, 0xce, 0x94, 0x42, 0x3d, 0xe3, 0xea, 0xcb, 0x35, 0x88, 0xde, 0x6b, 0xaa, 0xd5, - 0xa1, 0x93, 0x74, 0x92, 0x77, 0xc6, 0x52, 0x2c, 0xa2, 0x65, 0xbb, 0x6a, 0xe3, 0x62, 0x3b, 0x82, 0x33, 0x28, 0x38, - 0xcb, 0x1c, 0x7a, 0x0f, 0x16, 0xda, 0xee, 0xdc, 0xd8, 0x61, 0xba, 0x37, 0x37, 0x0e, 0x47, 0x04, 0x8d, 0xdd, 0x36, - 0xdd, 0xb6, 0x22, 0x2a, 0xb1, 0xd9, 0xa2, 0x8b, 0x78, 0x63, 0x40, 0x40, 0x2f, 0x3e, 0x4e, 0xf5, 0xa9, 0xcf, 0xdb, - 0x4e, 0xbe, 0xd2, 0x09, 0xcb, 0x5a, 0xce, 0xbd, 0xc3, 0x78, 0xd5, 0x8d, 0x82, 0xd0, 0x2c, 0x84, 0x54, 0xf6, 0x42, - 0xe7, 0x09, 0xd8, 0xc4, 0x88, 0x3f, 0x62, 0x2b, 0xa1, 0x4c, 0x0e, 0xac, 0x0a, 0x4a, 0xc7, 0x87, 0x9a, 0x1d, 0x08, - 0x42, 0x57, 0xfb, 0xc8, 0x06, 0x72, 0x2c, 0xb4, 0x13, 0x19, 0x88, 0x26, 0x0e, 0x81, 0x6b, 0xac, 0x11, 0xd6, 0x47, - 0x32, 0x5e, 0x0e, 0x6d, 0xbd, 0x59, 0x03, 0x9b, 0xa8, 0xcd, 0x41, 0xef, 0xfe, 0x53, 0xde, 0xa1, 0x8b, 0x22, 0x6b, - 0x3d, 0x67, 0x4c, 0xcf, 0x22, 0xe6, 0x41, 0xb1, 0x2c, 0x81, 0x46, 0x11, 0x8a, 0xd0, 0xbf, 0x27, 0xf6, 0x50, 0x4f, - 0x2a, 0xa3, 0x3c, 0x61, 0x3e, 0xac, 0x50, 0x4d, 0xab, 0xa5, 0xa4, 0x53, 0x16, 0x1e, 0xc3, 0xdd, 0xc1, 0x8f, 0xaf, - 0xfd, 0xd1, 0xb8, 0xfe, 0x6a, 0xf4, 0xb1, 0xed, 0xf9, 0x9a, 0x96, 0xa9, 0x1f, 0x67, 0x4d, 0x7e, 0x1d, 0x9c, 0x37, - 0x16, 0x9b, 0xed, 0x95, 0x1e, 0xb8, 0x64, 0x22, 0x50, 0xaa, 0x5f, 0x66, 0xfb, 0x01, 0x9d, 0x2d, 0x14, 0x9f, 0x1a, - 0x15, 0xe5, 0xde, 0x5a, 0x8d, 0x65, 0x80, 0x70, 0x0c, 0x69, 0xa4, 0x5d, 0x62, 0x0a, 0x22, 0xad, 0xcf, 0xd2, 0x53, - 0xc0, 0x6b, 0x6b, 0x34, 0x8f, 0xe0, 0x90, 0x21, 0xd3, 0x24, 0xb1, 0x22, 0xfd, 0x0c, 0x10, 0xb7, 0x11, 0xd2, 0x8b, - 0xf4, 0x0f, 0x28, 0x01, 0x78, 0x15, 0xd1, 0xde, 0xa8, 0x8c, 0x45, 0xb2, 0x2a, 0xab, 0x95, 0xc2, 0x72, 0x7c, 0xc0, - 0xbf, 0xf4, 0x0f, 0x0b, 0x16, 0xa8, 0x1a, 0xe9, 0xd8, 0xc2, 0x4d, 0x04, 0x6a, 0x85, 0xed, 0x46, 0x88, 0xe2, 0xfb, - 0x75, 0x7d, 0xa4, 0x6c, 0x2e, 0x16, 0xc7, 0x18, 0x5b, 0xed, 0xcd, 0xd7, 0x5c, 0x6e, 0x3b, 0x43, 0xb7, 0x6d, 0xee, - 0xc0, 0xde, 0xa4, 0x7b, 0x1a, 0xbf, 0x7d, 0xab, 0xe1, 0x29, 0x7e, 0xf3, 0x6a, 0xa4, 0xf4, 0xf2, 0x78, 0x25, 0x74, - 0xef, 0xc9, 0x82, 0xe6, 0xc6, 0x65, 0x5c, 0xfa, 0xdd, 0x7b, 0x8a, 0xf0, 0x57, 0xfd, 0x57, 0x6a, 0x3c, 0xa9, 0xca, - 0xca, 0xdf, 0xac, 0x14, 0xf6, 0x07, 0x86, 0xaa, 0xca, 0x90, 0x21, 0x90, 0xa7, 0x4a, 0x0f, 0xb6, 0x27, 0x51, 0x6e, - 0xbf, 0x29, 0x69, 0x6c, 0x01, 0x17, 0x8a, 0x4e, 0x8d, 0xac, 0x72, 0xc2, 0xb3, 0x9e, 0xad, 0xf7, 0x90, 0x44, 0x5c, - 0xb9, 0xce, 0xc4, 0x11, 0x77, 0x3f, 0xe7, 0xf3, 0x8f, 0x2a, 0x02, 0x3a, 0x64, 0xf1, 0x51, 0x77, 0x19, 0x05, 0x41, - 0xc3, 0x0b, 0x69, 0x98, 0x20, 0x33, 0xa1, 0xac, 0xa9, 0x76, 0x5f, 0xa6, 0x69, 0xbd, 0x3e, 0x7f, 0x2e, 0x8e, 0xbd, - 0x1d, 0x90, 0xcc, 0xc6, 0x9c, 0x69, 0x56, 0x12, 0x37, 0xf2, 0xe0, 0x54, 0xd1, 0xe6, 0x2c, 0xc8, 0xd6, 0xea, 0xad, - 0x9e, 0x93, 0x39, 0xe0, 0x24, 0xd2, 0x32, 0xcc, 0x8f, 0x3c, 0xe7, 0xcf, 0x15, 0x27, 0xd3, 0xe8, 0xbe, 0x57, 0x63, - 0xdb, 0x66, 0x98, 0xf4, 0x24, 0x03, 0x40, 0x9d, 0x08, 0xe0, 0x9b, 0x12, 0xd4, 0x01, 0x8a, 0xaf, 0x2d, 0x8b, 0xc9, - 0x4c, 0x0c, 0x08, 0x26, 0x93, 0xfd, 0xda, 0x93, 0x03, 0xd3, 0x99, 0x08, 0x6c, 0x18, 0xf2, 0xcf, 0x40, 0x54, 0xe3, - 0xdb, 0x14, 0x24, 0xa1, 0x68, 0x4d, 0xa6, 0xb8, 0xf9, 0x04, 0x05, 0x9e, 0x7d, 0x11, 0xb2, 0xa5, 0x7e, 0x53, 0xc6, - 0x29, 0x84, 0xcd, 0x69, 0x3d, 0x98, 0xb2, 0x32, 0x9e, 0x49, 0x78, 0x8d, 0xe3, 0x9f, 0x2d, 0x82, 0xc7, 0xa8, 0xbc, - 0x8c, 0xc1, 0x1a, 0x8d, 0x5f, 0xc0, 0xe0, 0xb2, 0xb7, 0xa2, 0xc3, 0x28, 0xae, 0x3f, 0x6c, 0x8d, 0x71, 0x92, 0xd5, - 0x7e, 0x71, 0xf6, 0x37, 0xdb, 0x6f, 0x3d, 0x72, 0xf3, 0xd5, 0xcd, 0xce, 0x0e, 0x4d, 0x6b, 0x05, 0x83, 0x1e, 0xc6, - 0x60, 0x03, 0x70, 0xc5, 0x38, 0xb3, 0x91, 0x62, 0x47, 0xcd, 0x33, 0xe0, 0xa8, 0x57, 0x37, 0x3f, 0xd2, 0xee, 0xf8, - 0x79, 0x86, 0xf8, 0x44, 0x22, 0x4c, 0xde, 0x89, 0x60, 0x83, 0x5a, 0xba, 0xa3, 0x3f, 0xf2, 0x54, 0x86, 0x16, 0x15, - 0x6f, 0x26, 0x79, 0x4e, 0x31, 0xd1, 0xb2, 0xdc, 0x1e, 0x3d, 0xf1, 0x16, 0xd3, 0x52, 0x87, 0xda, 0x65, 0xed, 0x34, - 0x8d, 0x1d, 0x53, 0xa8, 0x27, 0xec, 0xf8, 0x3b, 0x8c, 0xf2, 0xaf, 0x85, 0x97, 0x7f, 0x3e, 0xfe, 0xd7, 0x1c, 0xff, - 0x22, 0xdc, 0xd5, 0xc9, 0xea, 0xf0, 0xe7, 0xe8, 0xff, 0x1e, 0x1f, 0x50, 0x9d, 0xbc, 0xd9, 0xda, 0x7c, 0xa3, 0x5a, - 0x6f, 0x92, 0x47, 0x6b, 0x3d, 0x4e, 0xd0, 0x57, 0x1f, 0x77, 0x4e, 0x27, 0x18, 0xe7, 0x9c, 0x3a, 0x3f, 0x8a, 0xfd, - 0xd1, 0x12, 0x17, 0x7e, 0x31, 0xfe, 0xb0, 0xb5, 0x99, 0xdc, 0xa3, 0xfd, 0x37, 0xa4, 0x72, 0x9f, 0x9f, 0x50, 0x6d, - 0x2b, 0x1a, 0x24, 0x7f, 0x7f, 0xe8, 0xdc, 0x11, 0x81, 0x0d, 0xe7, 0xfe, 0xeb, 0x35, 0x8d, 0x3f, 0x19, 0x5c, 0x44, - 0x8a, 0xd6, 0x0a, 0x8b, 0xcf, 0xf4, 0x99, 0x56, 0x56, 0xdf, 0xb8, 0x55, 0x65, 0x1b, 0x3a, 0xa1, 0x36, 0xdd, 0x00, - 0xc4, 0xa4, 0x82, 0x06, 0x65, 0xed, 0x7e, 0xf9, 0xd3, 0x44, 0x1b, 0x12, 0x8a, 0x7e, 0xf6, 0x83, 0x91, 0x76, 0x37, - 0xa7, 0x0a, 0x20, 0xb1, 0x61, 0x7a, 0xfc, 0x52, 0x30, 0x19, 0xd0, 0xf0, 0x50, 0x47, 0x17, 0xad, 0x55, 0x9f, 0x45, - 0x7a, 0x63, 0xbd, 0x26, 0xc5, 0xf5, 0x15, 0x90, 0x20, 0xa4, 0x69, 0xb8, 0xfc, 0x3f, 0xfe, 0x44, 0x24, 0x4d, 0xaf, - 0xd1, 0x50, 0x39, 0x0d, 0xfd, 0xf5, 0x3b, 0xb4, 0xec, 0x85, 0x96, 0x33, 0x7b, 0x19, 0x15, 0x03, 0xcf, 0x82, 0xa0, - 0xba, 0x22, 0xc7, 0x26, 0x57, 0xe3, 0x39, 0x29, 0xc7, 0xfc, 0x1f, 0x67, 0x79, 0xbd, 0x86, 0x39, 0xc7, 0x88, 0xef, - 0xec, 0x02, 0x61, 0x49, 0x56, 0xc3, 0xc6, 0xec, 0x41, 0x7f, 0xf8, 0xe8, 0x0d, 0x34, 0xe8, 0x87, 0x8f, 0xbf, 0x20, - 0x01, 0x5f, 0xf8, 0x61, 0x74, 0x35, 0x2a, 0x1e, 0x9b, 0xd3, 0xda, 0xf5, 0x71, 0x63, 0x60, 0xe8, 0x23, 0x11, 0x1c, - 0x72, 0x0a, 0x10, 0x5f, 0x24, 0x9d, 0x1d, 0x4d, 0x1c, 0x73, 0x39, 0x24, 0x07, 0xed, 0x38, 0x97, 0x2a, 0x53, 0x0e, - 0x35, 0xa7, 0x8e, 0x72, 0x40, 0x8e, 0xf3, 0xe8, 0x40, 0xb3, 0x6e, 0x2f, 0x27, 0xe3, 0xcb, 0x9c, 0xb4, 0xcb, 0x66, - 0xb3, 0xd7, 0xd4, 0x30, 0x93, 0x88, 0x91, 0x0a, 0xde, 0xe4, 0xac, 0x8a, 0xa0, 0x5f, 0x74, 0x8a, 0xa9, 0x8d, 0x78, - 0xb8, 0xb7, 0x9e, 0x9d, 0x3a, 0x0f, 0x34, 0xb8, 0x32, 0x20, 0xaf, 0x78, 0x0d, 0xb8, 0x51, 0xc8, 0x84, 0x59, 0xc2, - 0x02, 0x2e, 0xcc, 0xdf, 0x7d, 0xe2, 0x3e, 0xd8, 0x2f, 0xa2, 0xe0, 0x3c, 0x7b, 0x6f, 0x06, 0xcb, 0x12, 0x76, 0x41, - 0xf5, 0xc6, 0x7d, 0xee, 0x3d, 0xfe, 0x71, 0xc3, 0x14, 0x14, 0x58, 0x06, 0xf9, 0x74, 0xe7, 0x0b, 0x22, 0xf0, 0x03, - 0xfb, 0xc3, 0x3c, 0xe6, 0xec, 0x1f, 0x9a, 0x53, 0x73, 0x4b, 0x28, 0x1b, 0x48, 0x75, 0x69, 0xcb, 0x82, 0xb3, 0xd3, - 0x61, 0x8b, 0xf3, 0x9e, 0xa3, 0x46, 0xa9, 0xee, 0xa9, 0x83, 0x32, 0x21, 0x5a, 0xe6, 0x14, 0xd8, 0x22, 0x80, 0x96, - 0xad, 0x08, 0xaf, 0x03, 0xe5, 0xa5, 0x66, 0x46, 0x43, 0x7f, 0x88, 0xb3, 0x49, 0xf8, 0x06, 0x74, 0x72, 0xd1, 0xe1, - 0xa2, 0xcb, 0xa5, 0x53, 0x7a, 0x7c, 0x3c, 0x40, 0x34, 0x76, 0xce, 0xc2, 0x60, 0x5e, 0x4f, 0x52, 0xbe, 0xf4, 0xec, - 0xd7, 0xe3, 0xa2, 0xbd, 0x36, 0xfa, 0x70, 0x32, 0x4d, 0x98, 0xd8, 0x80, 0x9a, 0x56, 0xc7, 0x21, 0x1e, 0x3c, 0xa4, - 0x80, 0x1e, 0x94, 0x66, 0x79, 0xdf, 0x04, 0x52, 0x48, 0x45, 0xc8, 0x44, 0x5e, 0x16, 0x7a, 0xb6, 0x0e, 0x06, 0x82, - 0x9a, 0xed, 0x8c, 0x4f, 0x75, 0xd2, 0x68, 0xa9, 0x78, 0x81, 0x98, 0x12, 0x46, 0x48, 0xd3, 0xfa, 0x27, 0xa0, 0x1b, - 0xbe, 0x06, 0x28, 0x7f, 0x52, 0x2e, 0x3b, 0x9e, 0x59, 0xc6, 0x0e, 0xe1, 0x80, 0x9f, 0xaa, 0x02, 0x77, 0x17, 0x15, - 0xfa, 0xc7, 0xf3, 0xd1, 0x90, 0x1c, 0x22, 0x34, 0x0c, 0x95, 0x70, 0x01, 0x91, 0x51, 0xea, 0x63, 0x87, 0xd0, 0xeb, - 0x7e, 0x40, 0xbe, 0xf8, 0x23, 0x9a, 0xf0, 0x88, 0x3b, 0xe5, 0xad, 0xae, 0x5a, 0x68, 0xe2, 0x23, 0xee, 0x82, 0x06, - 0xdf, 0x7c, 0x70, 0x9a, 0xee, 0x1e, 0x55, 0x96, 0x56, 0xe8, 0x13, 0x0d, 0x64, 0x4a, 0xf5, 0xf4, 0x7a, 0xa6, 0x9a, - 0xde, 0x2c, 0xa1, 0x95, 0x40, 0xd9, 0xc6, 0x74, 0x9e, 0xc6, 0x96, 0xed, 0xb5, 0x8b, 0x14, 0xf9, 0xf3, 0x34, 0x62, - 0x0d, 0x5b, 0x02, 0x76, 0xe3, 0x8e, 0xbe, 0xed, 0x64, 0xc7, 0xd0, 0x10, 0x25, 0xbd, 0xa8, 0x38, 0x1d, 0x63, 0xe4, - 0xe6, 0x75, 0x0f, 0xd8, 0x2e, 0xa3, 0xb7, 0xd5, 0xc0, 0x70, 0xee, 0x9b, 0xd4, 0x9c, 0x14, 0x9c, 0xf3, 0xd6, 0xfd, - 0x75, 0x82, 0x34, 0x9e, 0xe7, 0xad, 0x8b, 0xf7, 0x22, 0x9e, 0x69, 0xf3, 0xaf, 0x17, 0xe5, 0xf9, 0xaa, 0xc6, 0x65, - 0xeb, 0xaf, 0x49, 0xb0, 0x85, 0xec, 0x67, 0x15, 0x52, 0xfd, 0x47, 0xc5, 0x8e, 0x78, 0x7b, 0x3e, 0xa7, 0x02, 0x67, - 0xae, 0x3a, 0x3e, 0x2a, 0xbe, 0x41, 0x2f, 0x0e, 0x07, 0x38, 0x07, 0x01, 0xf2, 0xc0, 0x49, 0xa8, 0xc9, 0x3c, 0x60, - 0xcc, 0xa9, 0x56, 0xf3, 0x15, 0xeb, 0x31, 0xeb, 0x0d, 0x33, 0x3c, 0x57, 0xff, 0x03, 0xd4, 0x80, 0x0b, 0xe8, 0x0f, - 0x3b, 0xbc, 0xaf, 0x31, 0x84, 0x46, 0xdc, 0x8d, 0x7c, 0x62, 0xf0, 0xbb, 0xfc, 0x37, 0x83, 0x99, 0x6c, 0x24, 0xc8, - 0xcc, 0x3a, 0xd5, 0x3e, 0x31, 0x59, 0x19, 0x82, 0x7a, 0x2d, 0xed, 0xa6, 0xf4, 0x10, 0x19, 0x8a, 0x70, 0x02, 0x0c, - 0x14, 0xb4, 0x31, 0x81, 0x57, 0x57, 0x68, 0xa6, 0x1b, 0xcc, 0xd5, 0x47, 0x4d, 0x9d, 0x43, 0xdc, 0x2b, 0x2d, 0x95, - 0xc1, 0xa0, 0x36, 0x08, 0xbc, 0x6b, 0xbf, 0xfc, 0xc3, 0x32, 0x9e, 0x27, 0x87, 0xaa, 0x9f, 0x0e, 0x1b, 0xc3, 0x35, - 0x75, 0xac, 0x7a, 0xfd, 0xcf, 0xd4, 0x24, 0xc6, 0xa7, 0x46, 0x82, 0xc1, 0xba, 0x8a, 0x13, 0x2d, 0x88, 0xd3, 0x46, - 0x69, 0x17, 0x8a, 0x3a, 0xd4, 0x02, 0x2e, 0x0d, 0xa9, 0x71, 0xc0, 0x2a, 0x37, 0x2f, 0xcf, 0x0d, 0x74, 0xe2, 0x39, - 0x7f, 0x9d, 0x99, 0xf0, 0xa1, 0x9e, 0xe6, 0x50, 0xd7, 0x26, 0xcf, 0xe5, 0xfd, 0xf8, 0xc5, 0xca, 0x43, 0x22, 0x27, - 0xb1, 0xd0, 0x26, 0x9b, 0xeb, 0x7c, 0xbe, 0xc0, 0x62, 0x23, 0x88, 0xfa, 0x7c, 0x85, 0x0a, 0xa2, 0xc3, 0x61, 0x53, - 0x4c, 0x75, 0xc4, 0x33, 0xc6, 0x44, 0xa5, 0xed, 0x62, 0x33, 0x1c, 0xc0, 0x00, 0x9c, 0x8b, 0xb2, 0x96, 0x8f, 0xdf, - 0xa6, 0xd1, 0x9f, 0xe4, 0xec, 0x4c, 0x4a, 0x19, 0xbf, 0x21, 0xfb, 0x33, 0xbe, 0x3f, 0x62, 0x74, 0xef, 0xdf, 0xc9, - 0x3e, 0xed, 0x5f, 0x33, 0xb6, 0x31, 0xb6, 0x24, 0x6f, 0xcc, 0xec, 0xab, 0xcd, 0xcb, 0xb8, 0x24, 0x0a, 0xc8, 0xfe, - 0x46, 0xe3, 0x61, 0x9a, 0x87, 0x38, 0x3c, 0xac, 0x1a, 0x45, 0x7e, 0x47, 0x41, 0x96, 0x18, 0xe0, 0x6d, 0xa6, 0x45, - 0xba, 0x99, 0xc0, 0xdb, 0xa0, 0x94, 0x74, 0x68, 0x77, 0xa6, 0x2c, 0x31, 0xa8, 0xc2, 0xc0, 0x20, 0x22, 0x77, 0xba, - 0x04, 0xa2, 0xdd, 0x4a, 0x66, 0x4f, 0xf0, 0x3e, 0xa6, 0xa1, 0x13, 0xb7, 0x6c, 0x79, 0x8b, 0x6d, 0x4d, 0xcd, 0xec, - 0xe8, 0x85, 0x9a, 0xa1, 0x30, 0x32, 0x3a, 0x7d, 0xa1, 0xd6, 0x8f, 0x26, 0x64, 0xa9, 0x10, 0xbf, 0x2a, 0xf1, 0x55, - 0xeb, 0x6b, 0xa9, 0x10, 0x57, 0x67, 0x17, 0x39, 0x86, 0x9f, 0x65, 0x88, 0xc7, 0xd8, 0x8e, 0x7b, 0xeb, 0x6b, 0x0f, - 0x27, 0x80, 0x8a, 0xa4, 0x65, 0x48, 0x6e, 0xe5, 0xd8, 0x90, 0x86, 0x96, 0xfe, 0xf0, 0x74, 0x86, 0x99, 0x22, 0x40, - 0x67, 0xcd, 0x13, 0x4f, 0x5d, 0x4c, 0xd5, 0x7f, 0xa7, 0xa0, 0x62, 0xfb, 0x83, 0xca, 0x00, 0x38, 0x49, 0x1d, 0x44, - 0x23, 0xb3, 0xcf, 0x3a, 0x8d, 0x3e, 0xe4, 0xe2, 0x29, 0x38, 0x02, 0x96, 0x53, 0xe4, 0x9a, 0x33, 0x5a, 0xd7, 0x32, - 0xa4, 0x49, 0xb6, 0x6f, 0x97, 0xe3, 0xde, 0x05, 0x77, 0x68, 0xd2, 0x48, 0x68, 0xa9, 0xba, 0x42, 0xae, 0x94, 0xa5, - 0xa3, 0xee, 0xb4, 0x1b, 0x53, 0x6e, 0xac, 0x70, 0x2b, 0x73, 0xd1, 0xb1, 0x8c, 0x55, 0x39, 0xc2, 0x22, 0x5d, 0x1c, - 0x05, 0x96, 0x05, 0xf8, 0x1e, 0x18, 0x44, 0xa5, 0x2a, 0xcb, 0x44, 0x11, 0x92, 0xea, 0x84, 0x05, 0xc6, 0xb2, 0xf9, - 0x7e, 0x13, 0x09, 0x1e, 0x7c, 0xfd, 0x37, 0x8c, 0x24, 0xb1, 0x11, 0x10, 0x40, 0x83, 0x86, 0x16, 0x50, 0xcd, 0xfc, - 0x5e, 0xd9, 0x2d, 0x84, 0xce, 0x93, 0xf8, 0xa0, 0x92, 0x64, 0xd0, 0x9f, 0xff, 0xc7, 0x04, 0x31, 0x68, 0x1d, 0x52, - 0xce, 0x82, 0x03, 0x6e, 0x98, 0x9b, 0x4e, 0xa2, 0xba, 0x6c, 0x51, 0x2c, 0xb6, 0xd8, 0xf3, 0xb9, 0x0d, 0x6a, 0x05, - 0x2b, 0x2f, 0x21, 0xa5, 0x1d, 0xcd, 0x57, 0x5e, 0x87, 0x2a, 0x6f, 0x79, 0x8d, 0x3b, 0x4c, 0xf4, 0x0b, 0x27, 0xba, - 0x26, 0xab, 0xd1, 0xad, 0x23, 0x00, 0x99, 0x8d, 0x03, 0xd5, 0x1b, 0x84, 0x4b, 0x48, 0xd9, 0xe8, 0x2d, 0x73, 0x6e, - 0xf0, 0xdb, 0xf9, 0x9c, 0x90, 0xc4, 0xc8, 0x85, 0x26, 0x80, 0x93, 0x38, 0x25, 0xb4, 0xa9, 0x8b, 0x9c, 0xa9, 0xd3, - 0x13, 0xde, 0x3a, 0x68, 0x6e, 0x6d, 0x36, 0x42, 0xb1, 0x97, 0xf5, 0x49, 0x11, 0x25, 0x55, 0x97, 0x83, 0x72, 0x53, - 0x82, 0x5d, 0xfb, 0x31, 0xde, 0xca, 0x30, 0x64, 0x37, 0x2b, 0x60, 0x24, 0x66, 0x42, 0x72, 0x26, 0x48, 0x92, 0x65, - 0xd2, 0x65, 0x2d, 0xcd, 0xea, 0xda, 0x7f, 0xb4, 0x10, 0x1e, 0x91, 0x8c, 0xf3, 0xb3, 0x3c, 0x94, 0x1d, 0x57, 0xd6, - 0x29, 0xb2, 0x3c, 0x3d, 0x11, 0xae, 0xbb, 0x55, 0x35, 0x35, 0xbc, 0x07, 0x44, 0x64, 0x72, 0xcb, 0x56, 0xf5, 0xb1, - 0x33, 0xc1, 0xcf, 0x5c, 0x1e, 0x88, 0x8b, 0x07, 0x15, 0x49, 0xe8, 0xe7, 0xdb, 0x3c, 0x4f, 0x14, 0x1a, 0xbd, 0x43, - 0xce, 0xad, 0xe4, 0xe2, 0x5c, 0x0b, 0x94, 0x58, 0xf0, 0xe5, 0xf6, 0xa4, 0x3a, 0x47, 0x1e, 0xf8, 0x4e, 0x9c, 0x09, - 0x5d, 0x64, 0x5e, 0xe9, 0x1a, 0x79, 0x2b, 0xbd, 0x57, 0xd5, 0xc8, 0x1f, 0xfc, 0xea, 0x7f, 0x59, 0xe9, 0x35, 0x7a, - 0x11, 0x89, 0x33, 0x5f, 0xe2, 0x12, 0xed, 0x0c, 0xec, 0x30, 0x4e, 0xea, 0x9a, 0xbb, 0x2f, 0x80, 0x56, 0x17, 0xde, - 0x74, 0xb4, 0x16, 0x09, 0x3c, 0xd7, 0xdd, 0x25, 0xae, 0x84, 0x1d, 0x6e, 0xa0, 0xd8, 0xc3, 0x0c, 0x06, 0x42, 0xa3, - 0xc8, 0x86, 0x03, 0xc0, 0xcf, 0x21, 0xfe, 0x1a, 0xf3, 0xa3, 0x6e, 0xd9, 0x46, 0x0b, 0x9c, 0x53, 0x64, 0x06, 0xd9, - 0x8b, 0xc8, 0x80, 0x1c, 0xea, 0x84, 0x2c, 0xc8, 0x35, 0x6a, 0xec, 0x80, 0xb5, 0xc2, 0x0a, 0x65, 0x35, 0xc0, 0xb1, - 0xc1, 0x66, 0xed, 0xa5, 0xb9, 0xa9, 0xc0, 0xa7, 0x4b, 0x44, 0xae, 0xe9, 0x91, 0x50, 0xbe, 0x82, 0x14, 0x54, 0xa4, - 0x9f, 0x57, 0xff, 0x0a, 0x4c, 0x7a, 0x3b, 0x27, 0x68, 0x17, 0x91, 0x71, 0xbf, 0xd0, 0x11, 0x28, 0x2d, 0x62, 0xfb, - 0x87, 0xc9, 0xf1, 0x75, 0x30, 0xa6, 0x6b, 0xe4, 0x73, 0x6b, 0xcd, 0x3f, 0x41, 0xf5, 0x3c, 0x19, 0x0f, 0x14, 0xa9, - 0x30, 0x00, 0xfc, 0xde, 0x08, 0x1a, 0xef, 0xfd, 0xdf, 0x33, 0x1c, 0x67, 0x74, 0x4b, 0x28, 0x3c, 0x02, 0xf2, 0x4d, - 0xfe, 0x17, 0xc3, 0x78, 0x54, 0x00, 0x3b, 0x2b, 0xf2, 0xde, 0xd0, 0xde, 0xad, 0x43, 0xc0, 0xd0, 0x37, 0x60, 0xcc, - 0xfc, 0x0d, 0x47, 0xd9, 0x40, 0x6e, 0xdb, 0x19, 0xae, 0xab, 0x92, 0x66, 0x26, 0x19, 0x1e, 0x49, 0x0c, 0x52, 0x69, - 0xe4, 0x47, 0x5d, 0x59, 0x9c, 0x66, 0xee, 0x2a, 0x38, 0xf2, 0xb3, 0xc7, 0x33, 0x6c, 0xde, 0xd8, 0x88, 0x3b, 0x5e, - 0x80, 0x34, 0x37, 0x34, 0x00, 0xe0, 0x85, 0x4b, 0x45, 0x87, 0x3b, 0xe6, 0x2a, 0x5b, 0x81, 0xfa, 0x69, 0xa2, 0x39, - 0x38, 0xce, 0x46, 0x15, 0xf2, 0x09, 0xb7, 0x1b, 0xf1, 0x79, 0x0e, 0x10, 0x8f, 0x63, 0xa5, 0x32, 0x18, 0x12, 0x05, - 0x3f, 0x11, 0x61, 0x47, 0xd3, 0x89, 0xb3, 0xe4, 0xae, 0x52, 0x7b, 0x0c, 0x50, 0x0d, 0x09, 0x58, 0x65, 0x6c, 0xc3, - 0xfa, 0x45, 0x90, 0xb8, 0xac, 0xef, 0x18, 0x2d, 0xeb, 0xb0, 0x50, 0x0b, 0x1f, 0x39, 0xa7, 0x1f, 0xe2, 0xa0, 0x10, - 0x67, 0x23, 0x9c, 0x67, 0x20, 0x79, 0xda, 0x40, 0x66, 0xe4, 0xc5, 0xf8, 0xbd, 0x74, 0x67, 0xbb, 0x61, 0x65, 0x48, - 0xba, 0xc5, 0x5b, 0x6d, 0x3d, 0x93, 0xfc, 0x88, 0x1c, 0x38, 0x29, 0x02, 0xc9, 0x24, 0x52, 0x41, 0x95, 0xd2, 0x60, - 0xe5, 0xaf, 0x00, 0x28, 0x98, 0x6b, 0x5e, 0xd3, 0x54, 0x4f, 0xcb, 0x84, 0xdd, 0xe6, 0x68, 0xb0, 0x4e, 0x1c, 0xaa, - 0x1f, 0x0c, 0x3a, 0x85, 0x38, 0x43, 0xbb, 0xc0, 0x03, 0x8d, 0x4c, 0xec, 0xf1, 0xe7, 0xf9, 0x49, 0xc1, 0x3b, 0xab, - 0x34, 0x4b, 0xc1, 0x33, 0x95, 0x32, 0x78, 0x0c, 0x56, 0xe7, 0xdf, 0xee, 0x6b, 0xa2, 0xd2, 0x80, 0x00, 0xd0, 0x51, - 0xcc, 0xe1, 0xbc, 0x9b, 0xa2, 0x49, 0x77, 0x6a, 0xb2, 0xff, 0xd6, 0xab, 0xdb, 0x9b, 0x71, 0x94, 0x17, 0xdd, 0x61, - 0x35, 0xf1, 0x71, 0xd2, 0x84, 0xed, 0x8c, 0xad, 0xd4, 0xf5, 0x0b, 0xb0, 0x00, 0x76, 0x99, 0xf1, 0x6c, 0x0c, 0xaf, - 0xeb, 0xc8, 0x4e, 0x17, 0xe4, 0xea, 0xe1, 0xa3, 0x9a, 0xc3, 0x47, 0xdc, 0x72, 0x72, 0xca, 0x11, 0x9c, 0x59, 0x04, - 0xcd, 0x0c, 0xa0, 0x02, 0xf2, 0x12, 0x9a, 0x92, 0x2e, 0x08, 0x7e, 0x6d, 0x90, 0x34, 0x1f, 0x30, 0x06, 0xe0, 0xa3, - 0xbe, 0xd3, 0x9c, 0xbf, 0x19, 0x9c, 0xee, 0x44, 0xbc, 0xb7, 0xa8, 0xe2, 0x97, 0x56, 0xca, 0x90, 0x29, 0x4f, 0x2e, - 0xd9, 0x2a, 0xac, 0x42, 0xd5, 0xda, 0xae, 0x43, 0x09, 0xf1, 0x19, 0xed, 0x0f, 0x2e, 0x28, 0xde, 0xc1, 0x40, 0x7d, - 0xe1, 0x47, 0xde, 0x69, 0xbd, 0x8a, 0x66, 0x2d, 0x6c, 0xbd, 0xf8, 0xbe, 0x6a, 0x5a, 0x03, 0x47, 0x76, 0xb6, 0x57, - 0xfa, 0x67, 0x75, 0x18, 0xad, 0x43, 0x54, 0xfe, 0xac, 0xfe, 0x4a, 0x37, 0x75, 0xcb, 0x9a, 0xc6, 0xaf, 0x23, 0xf1, - 0x9b, 0x24, 0x4c, 0xea, 0xb5, 0x5b, 0xd3, 0xe3, 0xf4, 0x38, 0xd1, 0x38, 0x75, 0x72, 0xf7, 0xfc, 0xd7, 0x68, 0x75, - 0xd4, 0xa0, 0xed, 0x64, 0xda, 0xa6, 0xdf, 0x35, 0x96, 0x28, 0x4d, 0xaa, 0xa7, 0xb1, 0x73, 0x6d, 0x17, 0x2f, 0x16, - 0x1d, 0x12, 0xdd, 0x9f, 0x75, 0x5f, 0x91, 0xb9, 0x16, 0x26, 0x7e, 0x66, 0x52, 0x43, 0x5c, 0x6b, 0x35, 0xf1, 0xce, - 0x5e, 0x6c, 0x4b, 0x8e, 0xdd, 0x74, 0x95, 0x64, 0x30, 0xa8, 0x8e, 0x4c, 0x0d, 0x89, 0x64, 0x88, 0xa8, 0x5f, 0x3e, - 0x08, 0x98, 0x75, 0x8d, 0x77, 0xcf, 0xd7, 0xa4, 0x71, 0xfa, 0xd6, 0x63, 0xae, 0x3f, 0x2f, 0xc3, 0xed, 0x7b, 0x04, - 0xce, 0xb6, 0x29, 0xfd, 0xe8, 0x8d, 0x52, 0xa7, 0x8d, 0x92, 0x58, 0x4e, 0xd3, 0x13, 0x28, 0xff, 0x80, 0x48, 0x22, - 0xfc, 0xa4, 0x29, 0x3b, 0x49, 0x25, 0xd3, 0x6f, 0xd4, 0xdd, 0x7e, 0xaf, 0x84, 0x40, 0x7a, 0xfb, 0x47, 0x1d, 0x55, - 0xd3, 0xcb, 0x44, 0x12, 0xab, 0x0e, 0xc4, 0x6b, 0x0a, 0x43, 0xee, 0xf3, 0x2f, 0xb6, 0x77, 0xca, 0x28, 0x14, 0x51, - 0xd6, 0x92, 0xde, 0x01, 0x4c, 0x43, 0x0d, 0x23, 0xa3, 0x68, 0xd8, 0x26, 0xe5, 0xef, 0xf1, 0xc7, 0xd9, 0x30, 0xa0, - 0x4d, 0x47, 0xa5, 0x0d, 0x5d, 0xb0, 0xaa, 0xde, 0xc2, 0xef, 0xd3, 0x53, 0x5f, 0xb0, 0xe6, 0x15, 0xf6, 0x4e, 0xdf, - 0xde, 0xe6, 0xcf, 0xe7, 0xfc, 0xfc, 0xf9, 0xac, 0x37, 0xbc, 0x61, 0x66, 0x65, 0xdc, 0xab, 0xe0, 0xe5, 0x82, 0xae, - 0x71, 0x28, 0xc1, 0x53, 0x5b, 0xfe, 0xa3, 0x13, 0x30, 0xe5, 0x01, 0xce, 0x68, 0x03, 0x7d, 0x2a, 0x03, 0xa7, 0x9b, - 0x1b, 0x66, 0x34, 0x5d, 0x99, 0x19, 0x69, 0x66, 0x3c, 0x29, 0xa2, 0xcf, 0x49, 0xcc, 0xc1, 0x1e, 0xc9, 0x59, 0xfa, - 0x58, 0xcc, 0xf8, 0x51, 0x69, 0x0b, 0xda, 0x0e, 0x85, 0x9f, 0x82, 0x4c, 0x05, 0xe8, 0x45, 0xe7, 0xdb, 0x38, 0x8d, - 0xb3, 0xf4, 0x77, 0x0e, 0xe9, 0x48, 0x4f, 0x4f, 0x44, 0xf6, 0xa0, 0xbb, 0xee, 0xbd, 0x17, 0xf0, 0x4b, 0x42, 0x53, - 0x32, 0x7e, 0x27, 0x06, 0xed, 0x8b, 0xf4, 0x51, 0x8d, 0xc0, 0xa9, 0x00, 0x79, 0x35, 0xc2, 0x38, 0x90, 0x37, 0xb4, - 0xd7, 0xc8, 0x0f, 0x4a, 0x95, 0xee, 0xb9, 0xa7, 0x25, 0xad, 0xc8, 0x42, 0xa6, 0x9f, 0x8c, 0x31, 0x66, 0x55, 0xe4, - 0xd8, 0xd2, 0xbc, 0x6f, 0x90, 0x49, 0xbe, 0x70, 0x91, 0xd1, 0x62, 0x4e, 0x8d, 0x05, 0xba, 0x55, 0xa8, 0xb5, 0x0b, - 0xaf, 0x7f, 0xa1, 0x72, 0xa0, 0xa9, 0x28, 0xfb, 0x7e, 0x88, 0x2d, 0xe2, 0x03, 0xfd, 0x8a, 0x8f, 0x90, 0x71, 0xdb, - 0x73, 0x9c, 0x10, 0x52, 0xf5, 0xae, 0x28, 0xee, 0x6d, 0x93, 0x0a, 0xc9, 0x0d, 0x55, 0x0c, 0x65, 0xd4, 0xc2, 0xf9, - 0x19, 0x9c, 0x2f, 0x9c, 0x9f, 0xe6, 0xdc, 0xa0, 0x2d, 0x99, 0xaa, 0x67, 0x24, 0x96, 0xae, 0xb0, 0xa3, 0x96, 0xdf, - 0xe4, 0x27, 0xec, 0x42, 0x06, 0x68, 0x6a, 0xa5, 0x57, 0x45, 0x82, 0x2e, 0x83, 0x0d, 0xa8, 0x51, 0x1d, 0x88, 0xbc, - 0xc4, 0x37, 0x13, 0x10, 0x80, 0xd1, 0x83, 0x4f, 0xaa, 0x29, 0x9d, 0x36, 0x7c, 0xb7, 0xcb, 0x31, 0x81, 0xa2, 0x6b, - 0x36, 0x98, 0x84, 0xbc, 0x29, 0xb8, 0xa6, 0x9a, 0x3d, 0x15, 0xc2, 0x18, 0xbc, 0x3c, 0x35, 0xb6, 0x58, 0xbd, 0x7f, - 0x2b, 0xd6, 0x57, 0x86, 0x90, 0xd8, 0x72, 0xc8, 0xbe, 0xd0, 0xbc, 0xd2, 0x83, 0x68, 0x9a, 0xe6, 0xe4, 0xd2, 0x43, - 0x5f, 0xc8, 0xeb, 0xd1, 0xd9, 0x27, 0xc8, 0xeb, 0xdb, 0x6c, 0x5b, 0x73, 0x13, 0x36, 0xf1, 0x25, 0x7d, 0xa6, 0xfb, - 0xe7, 0x6a, 0x21, 0x7b, 0x56, 0xea, 0xbc, 0x73, 0x25, 0x76, 0x4d, 0xa7, 0x88, 0x1a, 0x83, 0x4e, 0xc1, 0xdb, 0x0e, - 0x11, 0xb4, 0x05, 0x27, 0x49, 0x86, 0x48, 0x54, 0x06, 0xea, 0xb3, 0xa9, 0x48, 0x82, 0xd9, 0x00, 0x4b, 0x25, 0xaf, - 0xb9, 0xd8, 0x35, 0xbf, 0x64, 0x4d, 0x32, 0xab, 0x80, 0x8b, 0xe4, 0x99, 0x4e, 0x4e, 0xd7, 0x91, 0xd5, 0x1e, 0xa6, - 0xc6, 0x5d, 0x2c, 0x5e, 0x25, 0x5c, 0xce, 0xca, 0x4d, 0xac, 0xc4, 0x9b, 0x40, 0xcd, 0x78, 0x4f, 0x2a, 0x7f, 0x6c, - 0xb2, 0xa3, 0x36, 0x52, 0x02, 0x6d, 0x0f, 0xa9, 0xb6, 0x36, 0x8d, 0x70, 0x1b, 0xd2, 0x6f, 0x57, 0xb7, 0x2d, 0x50, - 0xe9, 0xb7, 0xb4, 0x30, 0xa4, 0xff, 0x1b, 0x15, 0xaa, 0x46, 0x85, 0x11, 0xc2, 0xfd, 0x24, 0x40, 0xb8, 0x2f, 0x9c, - 0xbc, 0x20, 0x16, 0xd5, 0x79, 0x14, 0xf6, 0x5e, 0x67, 0xcd, 0xd5, 0xb8, 0xf8, 0xfb, 0xa0, 0xfe, 0x3e, 0x0a, 0x8d, - 0x63, 0xbd, 0xc6, 0xef, 0x8c, 0x1f, 0x7f, 0x64, 0xdf, 0xd0, 0xc0, 0x08, 0x37, 0x11, 0xb4, 0x12, 0x34, 0xdb, 0x12, - 0xd6, 0xb6, 0x2a, 0xa0, 0x08, 0x61, 0x36, 0x52, 0xd5, 0x82, 0x09, 0x6d, 0xa5, 0x27, 0x58, 0xbc, 0xeb, 0x38, 0xfd, - 0x6f, 0x68, 0xbd, 0x4e, 0x08, 0x29, 0x58, 0x93, 0x23, 0x4f, 0x9e, 0x44, 0xab, 0x7d, 0xe6, 0xdf, 0x18, 0xb7, 0xbe, - 0xfa, 0x8c, 0x57, 0x23, 0x75, 0xa4, 0x98, 0x41, 0xe1, 0xb5, 0x9b, 0xd3, 0x9b, 0xf1, 0x39, 0xc9, 0x7b, 0xd1, 0x3c, - 0xda, 0xa9, 0xa0, 0x54, 0x53, 0xd7, 0xac, 0xce, 0xb5, 0x79, 0x9d, 0xd1, 0xb9, 0xc6, 0xde, 0x58, 0xd6, 0xd3, 0x35, - 0xce, 0xf8, 0x8d, 0xb6, 0x62, 0xa0, 0xd4, 0xf1, 0xb0, 0xd1, 0x73, 0xac, 0x40, 0x06, 0xe8, 0x85, 0xe3, 0x26, 0x82, - 0xf4, 0x97, 0xc0, 0xa1, 0x53, 0x1b, 0x2e, 0xb0, 0xd6, 0x72, 0xc4, 0x90, 0x67, 0x58, 0x62, 0x4a, 0xbf, 0x71, 0x1d, - 0x48, 0xbb, 0xf5, 0x9b, 0x05, 0x8f, 0x82, 0xaf, 0xec, 0xe9, 0x30, 0x8f, 0x68, 0x9c, 0x5b, 0x04, 0x2f, 0x12, 0xe5, - 0x61, 0xbb, 0xf0, 0x9c, 0x5f, 0x89, 0x74, 0x50, 0x90, 0x65, 0x3c, 0x9f, 0x79, 0x01, 0x42, 0x48, 0x77, 0x2d, 0xa1, - 0xed, 0x73, 0xc1, 0x9e, 0x18, 0xd7, 0x8e, 0x49, 0x52, 0x53, 0x82, 0xfd, 0xdf, 0x36, 0x5d, 0x96, 0x56, 0xe7, 0x2f, - 0xef, 0x2b, 0x66, 0x62, 0x3b, 0xae, 0xce, 0x52, 0x21, 0x7b, 0xef, 0x57, 0x91, 0x78, 0x8c, 0xcc, 0x1f, 0xdb, 0x20, - 0x7e, 0xef, 0x9c, 0x72, 0xfc, 0x5f, 0xd8, 0x6f, 0x7a, 0xf4, 0xca, 0xc9, 0x6c, 0x23, 0x01, 0x93, 0x23, 0xf7, 0xaa, - 0xbe, 0x1f, 0x01, 0x7b, 0xc3, 0x03, 0x81, 0xb2, 0x8a, 0xfe, 0x83, 0x7a, 0xd3, 0x00, 0x60, 0x0a, 0xc3, 0x6d, 0xb8, - 0xe7, 0x8f, 0xc6, 0x6f, 0x75, 0xc0, 0xe5, 0x8a, 0xe5, 0xbf, 0x81, 0xc1, 0xf5, 0x3a, 0x22, 0xd8, 0x6f, 0x9d, 0xf5, - 0x40, 0xd0, 0x9d, 0xc7, 0x9c, 0x62, 0x10, 0xd7, 0x92, 0x2f, 0x58, 0xaf, 0x22, 0xf3, 0x18, 0xc5, 0xe6, 0x17, 0x6b, - 0x2b, 0xf8, 0x2a, 0x93, 0xfa, 0x45, 0x1e, 0xfc, 0x17, 0xa4, 0x76, 0x08, 0x87, 0xe7, 0x89, 0x45, 0xfe, 0x4d, 0xe2, - 0x70, 0x84, 0x05, 0xb6, 0x62, 0xa5, 0xa1, 0x39, 0x33, 0x7e, 0x4c, 0xc9, 0xa1, 0x4d, 0x30, 0x0e, 0x45, 0xce, 0xd6, - 0x1c, 0x2c, 0x47, 0xa9, 0x66, 0x9e, 0x7f, 0x6f, 0xf0, 0x41, 0x98, 0xb4, 0xb4, 0xf2, 0x7c, 0x80, 0xf6, 0x31, 0xfa, - 0xf3, 0x7f, 0x16, 0x87, 0x0d, 0xc3, 0xb2, 0xf7, 0x6e, 0xe2, 0x27, 0x1b, 0x38, 0xaa, 0x79, 0x52, 0xc2, 0xd5, 0x5b, - 0xab, 0xaf, 0xda, 0x96, 0x1e, 0x3f, 0x09, 0x85, 0xc6, 0x30, 0x46, 0x0b, 0x83, 0x81, 0x3b, 0x17, 0xfb, 0x39, 0x98, - 0xb9, 0x61, 0x1b, 0x7d, 0x23, 0xe1, 0x4b, 0x3e, 0x7f, 0x07, 0xea, 0x10, 0xa3, 0xa6, 0x4b, 0x23, 0x2a, 0xfd, 0x0e, - 0x45, 0xb7, 0x06, 0x14, 0x68, 0x9e, 0xf9, 0x1c, 0x0a, 0xa7, 0xa3, 0x48, 0x24, 0x39, 0xc0, 0xda, 0x99, 0x7e, 0xd6, - 0xb2, 0xc7, 0xef, 0xb3, 0xa5, 0xc3, 0xf0, 0xba, 0xb6, 0x3d, 0x1e, 0x73, 0xe5, 0x56, 0x56, 0x1d, 0x17, 0x50, 0x5f, - 0x96, 0x6d, 0x36, 0xf6, 0x8e, 0x50, 0x67, 0xab, 0x87, 0x22, 0x72, 0x86, 0x78, 0x90, 0x58, 0xdd, 0xa0, 0x8f, 0x54, - 0xb0, 0xce, 0x67, 0x1b, 0x34, 0xf9, 0x56, 0xd1, 0x8b, 0xab, 0x85, 0xcd, 0x69, 0x48, 0x88, 0x69, 0xc4, 0x70, 0xf0, - 0x49, 0x84, 0xce, 0xa4, 0x7d, 0xdc, 0x50, 0x9d, 0x38, 0x43, 0xd2, 0x70, 0x1d, 0x71, 0x5a, 0x55, 0xc2, 0xac, 0xb2, - 0x85, 0xc5, 0x53, 0xda, 0xe1, 0xea, 0xae, 0x70, 0x3b, 0x67, 0xc2, 0x51, 0xcb, 0x35, 0xb4, 0x4d, 0x44, 0x0a, 0xd9, - 0x61, 0xcb, 0x35, 0xfa, 0xea, 0xb0, 0x62, 0x85, 0x8c, 0xb7, 0xf3, 0xe2, 0x55, 0xcc, 0x38, 0x6c, 0x09, 0x4b, 0x71, - 0x80, 0x81, 0x0f, 0x6d, 0xe5, 0x7d, 0xd5, 0xc9, 0xa9, 0x70, 0x4e, 0x79, 0x97, 0x52, 0x82, 0x2d, 0x63, 0xff, 0xdc, - 0xd5, 0xab, 0xf3, 0xcb, 0xb9, 0xab, 0xce, 0x78, 0x73, 0x61, 0xea, 0xb4, 0xbe, 0x84, 0xae, 0xed, 0x10, 0x51, 0xe5, - 0x3e, 0x57, 0xd3, 0x71, 0x6f, 0xb1, 0x86, 0x9e, 0x74, 0x8e, 0x89, 0xfe, 0xbf, 0x42, 0x94, 0x8f, 0x08, 0x9d, 0xdc, - 0xdd, 0x29, 0x5f, 0x95, 0x3c, 0x55, 0x49, 0xec, 0x63, 0xb5, 0x0d, 0x23, 0x83, 0x56, 0xda, 0x89, 0x6a, 0xdf, 0x5e, - 0xee, 0x09, 0x62, 0xc8, 0x5b, 0x62, 0x59, 0xb8, 0x5d, 0x5e, 0x96, 0xdc, 0x21, 0xce, 0xed, 0x64, 0x68, 0xa7, 0x63, - 0x34, 0x42, 0x3f, 0xb4, 0xa5, 0x98, 0x04, 0x44, 0x52, 0xfb, 0x09, 0xe9, 0x1c, 0xfe, 0x2e, 0x7b, 0x7f, 0x16, 0xef, - 0x09, 0x61, 0x3e, 0x7a, 0xd1, 0x31, 0xa8, 0x4b, 0xa8, 0x73, 0xbc, 0xce, 0xab, 0x06, 0x4c, 0x12, 0x4d, 0xaf, 0xad, - 0x38, 0xd5, 0x39, 0xf5, 0xb6, 0x08, 0xc5, 0x2e, 0xfd, 0xa2, 0x25, 0xb9, 0xd9, 0x2c, 0x33, 0x66, 0x0c, 0x02, 0x75, - 0xa8, 0xe8, 0x66, 0x80, 0x62, 0x4c, 0x89, 0xb0, 0xd3, 0xf9, 0x87, 0x4c, 0xaa, 0x29, 0x2d, 0xaa, 0x76, 0xf4, 0xfb, - 0xc6, 0x60, 0x87, 0x47, 0xd3, 0x97, 0x3f, 0xbf, 0x3d, 0xd2, 0x83, 0x2a, 0xe8, 0x10, 0x3e, 0xee, 0xee, 0x8e, 0xa1, - 0x50, 0x80, 0xac, 0x6c, 0x5f, 0xcc, 0x00, 0x6a, 0x4c, 0x45, 0x48, 0x77, 0x6d, 0xdd, 0x5f, 0x4a, 0x72, 0x5b, 0x53, - 0xe5, 0xfb, 0x40, 0x83, 0xef, 0x0d, 0xb5, 0xd3, 0x1d, 0x3e, 0x87, 0xd9, 0x88, 0xa7, 0x40, 0xc7, 0xc2, 0xe0, 0x6f, - 0x48, 0x71, 0x13, 0x06, 0x19, 0xaa, 0x64, 0x9a, 0x3d, 0xa5, 0x2d, 0xab, 0xe6, 0x5a, 0x4a, 0x3a, 0xc7, 0x84, 0xbd, - 0x2a, 0xfc, 0x91, 0xf7, 0x24, 0xb5, 0xa5, 0x1a, 0x0c, 0x70, 0x82, 0xd2, 0x86, 0xe5, 0x58, 0xc5, 0x8d, 0x7c, 0xa7, - 0xf0, 0x22, 0x02, 0x3d, 0x1d, 0xdc, 0xdb, 0xf9, 0xfd, 0xde, 0x18, 0x21, 0x48, 0x05, 0xdf, 0x4a, 0xa9, 0xc9, 0x1a, - 0x9e, 0xfb, 0x47, 0xaf, 0x6c, 0x87, 0x47, 0xba, 0x9b, 0x24, 0x6a, 0x8b, 0x4e, 0x54, 0x80, 0x15, 0x88, 0xa6, 0x80, - 0x0b, 0xd5, 0x31, 0xa6, 0x71, 0xe7, 0x77, 0x3f, 0xb1, 0xd6, 0xdd, 0xea, 0xf5, 0xac, 0x97, 0x4e, 0x1e, 0x93, 0x05, - 0x6a, 0x3c, 0x8a, 0x7d, 0x79, 0x15, 0xbe, 0x5b, 0xf6, 0x9b, 0x95, 0x2d, 0xc8, 0x0c, 0x02, 0xf4, 0x9b, 0xb5, 0x39, - 0x13, 0xbd, 0x46, 0xb8, 0x93, 0x4a, 0xf3, 0xbc, 0x92, 0x33, 0x95, 0x5f, 0x5f, 0x39, 0x8b, 0x21, 0x59, 0xed, 0xac, - 0xdd, 0xa8, 0x48, 0x8f, 0xad, 0x41, 0xd6, 0xaf, 0x99, 0x64, 0xa9, 0xff, 0x35, 0x7c, 0xd4, 0x37, 0xaf, 0xd7, 0x60, - 0xda, 0x76, 0xb5, 0xd3, 0xcb, 0x53, 0x8e, 0x8a, 0x39, 0x2f, 0x7e, 0x61, 0x8d, 0x2d, 0x3c, 0x1e, 0x6c, 0xf4, 0x84, - 0xc9, 0x54, 0xb2, 0x7a, 0x56, 0xc9, 0xca, 0x59, 0xe2, 0x72, 0xb3, 0x17, 0x5d, 0x40, 0xc7, 0x1f, 0x0e, 0x5a, 0x95, - 0x3f, 0x6c, 0xcc, 0xaa, 0x7c, 0xd8, 0x49, 0xd5, 0xfa, 0x24, 0x91, 0xd9, 0x33, 0x6b, 0xe4, 0x61, 0x61, 0xad, 0x98, - 0x4c, 0xf2, 0x7d, 0x42, 0xae, 0xd0, 0x0c, 0xab, 0x6a, 0xd5, 0xe1, 0xc9, 0x0d, 0x37, 0xb8, 0x58, 0xf8, 0xb9, 0x19, - 0xd7, 0x7f, 0x46, 0xdc, 0x59, 0x0e, 0x3a, 0x0b, 0xad, 0xbf, 0xbd, 0x0e, 0x75, 0x3f, 0x82, 0x2f, 0x4d, 0x70, 0x65, - 0xfa, 0x16, 0x5c, 0xfd, 0x4a, 0x92, 0xd9, 0x16, 0x78, 0xad, 0x00, 0xb9, 0xd8, 0x1b, 0x1b, 0xb1, 0xd6, 0x92, 0x44, - 0x63, 0x43, 0x90, 0x3a, 0x8b, 0xb4, 0x1b, 0x52, 0x3b, 0x9a, 0xed, 0xb4, 0x8e, 0xe6, 0x27, 0xfc, 0x8d, 0x3f, 0x55, - 0x43, 0x15, 0xe6, 0x5b, 0x85, 0xea, 0x15, 0x0f, 0x4e, 0x5b, 0x6f, 0x35, 0x8b, 0xf3, 0x4d, 0xb0, 0xd2, 0x8a, 0xa8, - 0x08, 0x8d, 0xc1, 0x17, 0x19, 0x1c, 0xc4, 0xfd, 0x8a, 0xb5, 0x82, 0x74, 0x53, 0xd6, 0xed, 0x7f, 0x0d, 0xb5, 0xd2, - 0xee, 0x40, 0xec, 0x1b, 0x74, 0x81, 0x95, 0xb5, 0x02, 0xb9, 0x87, 0xf5, 0xfe, 0x82, 0xd2, 0x0a, 0x71, 0xe1, 0xcc, - 0x11, 0x35, 0x61, 0xad, 0xf7, 0x88, 0xb7, 0xc8, 0xfa, 0xcb, 0x3f, 0xd3, 0x8b, 0x26, 0xce, 0xe2, 0x61, 0x19, 0xe7, - 0x0e, 0xd9, 0x91, 0xcb, 0x2c, 0x9f, 0xae, 0xbc, 0xd5, 0x22, 0x82, 0x86, 0x3c, 0x99, 0xf6, 0xf8, 0x14, 0x4e, 0x9b, - 0x35, 0x9c, 0x9e, 0xc8, 0xa7, 0xd6, 0x5a, 0xd3, 0xc9, 0xaa, 0xe1, 0x1f, 0x70, 0xc1, 0x05, 0x86, 0x1d, 0x0c, 0x4e, - 0xaf, 0x9c, 0xaf, 0xba, 0xa0, 0x49, 0x4f, 0x58, 0x70, 0x06, 0xcd, 0x6d, 0xc0, 0x93, 0x0f, 0xe9, 0x29, 0x75, 0x77, - 0x76, 0x9b, 0xd7, 0x40, 0x6e, 0x13, 0x7d, 0x6a, 0x31, 0xcf, 0x0a, 0x5b, 0x70, 0xa6, 0xce, 0x6e, 0x63, 0x7a, 0xae, - 0xae, 0xdb, 0x56, 0x82, 0xa4, 0x4d, 0x9e, 0xcf, 0x06, 0xd7, 0x8c, 0x14, 0x86, 0xc1, 0xff, 0x97, 0x90, 0x92, 0xb7, - 0xa2, 0x20, 0x98, 0x3a, 0x27, 0x7d, 0xad, 0x17, 0x57, 0xb8, 0x11, 0xb1, 0xcc, 0xaa, 0x23, 0xa8, 0x52, 0xf6, 0x04, - 0x5d, 0xfa, 0xdc, 0xc1, 0x25, 0x27, 0x62, 0xbb, 0x67, 0xa5, 0x33, 0x29, 0xa1, 0xfd, 0x79, 0xc1, 0xbb, 0x6b, 0xbc, - 0x72, 0x47, 0xf6, 0xc7, 0xca, 0x3d, 0xe3, 0x1d, 0xb8, 0x7a, 0xf6, 0xe7, 0x38, 0x6b, 0xe1, 0xa0, 0xcb, 0x30, 0x8f, - 0x27, 0x3d, 0x3c, 0xcb, 0x3f, 0xe1, 0x59, 0x39, 0xcf, 0x18, 0x82, 0xd6, 0x61, 0x85, 0x6f, 0xbe, 0x06, 0x28, 0xef, - 0x64, 0xf8, 0xf8, 0x58, 0xfc, 0xd6, 0xd8, 0x8b, 0x4e, 0xca, 0x21, 0x9a, 0xa9, 0x1d, 0x34, 0xcf, 0x5b, 0x30, 0xe4, - 0xa9, 0xdd, 0x20, 0x90, 0x46, 0xeb, 0x3c, 0x57, 0x3f, 0xc5, 0x41, 0x35, 0x7f, 0x9b, 0x79, 0x09, 0x73, 0x5b, 0xa1, - 0x88, 0xfc, 0x33, 0x21, 0x9a, 0xfd, 0x48, 0xa5, 0x81, 0x3a, 0xf9, 0x55, 0x4b, 0xf2, 0x95, 0xb7, 0x23, 0x06, 0x9d, - 0xb9, 0x09, 0xbb, 0xd8, 0x08, 0xf3, 0xd3, 0x98, 0x7c, 0xa6, 0x3a, 0x9b, 0xc9, 0x32, 0xcb, 0x6a, 0x1f, 0x13, 0x0f, - 0x8f, 0xd6, 0x4b, 0xaa, 0x5b, 0x14, 0x6a, 0xb3, 0x3c, 0x5f, 0x94, 0x59, 0xa9, 0x7d, 0x4e, 0xbd, 0x10, 0x47, 0x93, - 0xf5, 0xc2, 0xe3, 0x5e, 0x62, 0x46, 0x26, 0xd5, 0xbc, 0xcc, 0x1c, 0x22, 0x0f, 0xcf, 0x1f, 0x7c, 0xcb, 0x2e, 0x79, - 0xa2, 0xa0, 0xb4, 0x1d, 0x32, 0x0f, 0xdc, 0x37, 0x98, 0xae, 0x9c, 0x7a, 0xcc, 0xd3, 0x15, 0x70, 0x6b, 0xc0, 0x6c, - 0x69, 0x14, 0x47, 0x56, 0x59, 0x85, 0xac, 0xeb, 0xf5, 0xba, 0xf2, 0xb9, 0x65, 0x9a, 0x09, 0x37, 0xf6, 0x14, 0x64, - 0x9a, 0xae, 0x4a, 0xd7, 0xd2, 0x67, 0xfe, 0xcd, 0x9c, 0x67, 0x1f, 0xf0, 0xd3, 0x4f, 0xc1, 0x2d, 0xfa, 0xcb, 0xa9, - 0x6b, 0x5c, 0xf9, 0x36, 0xa3, 0x51, 0xe3, 0x14, 0x8d, 0x37, 0x48, 0x4c, 0x54, 0x54, 0x85, 0xd5, 0x98, 0xf2, 0x73, - 0xec, 0xdd, 0x48, 0x4e, 0xa6, 0x43, 0x3e, 0xd7, 0x76, 0x3f, 0xb3, 0x66, 0xf5, 0x19, 0x75, 0x68, 0x95, 0xd5, 0x71, - 0xc4, 0x97, 0xce, 0x6e, 0x57, 0x06, 0xa1, 0x00, 0x04, 0xd8, 0xc3, 0xe4, 0x73, 0xca, 0x5a, 0x4d, 0xfe, 0xfc, 0xfb, - 0xfb, 0x47, 0x15, 0x9c, 0x62, 0x95, 0xf7, 0xdd, 0xd8, 0x04, 0x8b, 0x64, 0x46, 0x18, 0x59, 0x23, 0xbb, 0x39, 0x46, - 0x92, 0x22, 0x44, 0xe3, 0x1e, 0x4b, 0x11, 0x7a, 0xab, 0xfb, 0x01, 0xe0, 0x1c, 0x79, 0x52, 0x9c, 0x26, 0x47, 0xa7, - 0xc8, 0xa6, 0xd9, 0x56, 0x6c, 0x91, 0x85, 0x03, 0x7c, 0x2d, 0x6a, 0x25, 0xdb, 0xc6, 0x58, 0x41, 0x83, 0x62, 0x0e, - 0x64, 0x3a, 0xf3, 0x01, 0x5f, 0x31, 0xe2, 0x9c, 0x3f, 0x4c, 0x1b, 0x93, 0x27, 0xd3, 0x5e, 0x5f, 0x25, 0xcc, 0x6c, - 0xb7, 0x5e, 0x30, 0x9c, 0xd3, 0x0c, 0x0c, 0xc8, 0xc7, 0x15, 0xaa, 0xf9, 0x13, 0x2c, 0x51, 0xf0, 0xb7, 0x36, 0xb2, - 0xf3, 0xe7, 0xa4, 0x36, 0x62, 0xc8, 0x98, 0x68, 0x6c, 0x2f, 0x8c, 0x94, 0x82, 0x17, 0x35, 0x74, 0x46, 0x58, 0x04, - 0x1f, 0xec, 0x9e, 0xc2, 0xf5, 0x59, 0xd9, 0xeb, 0x74, 0x12, 0x3d, 0x30, 0x4f, 0x94, 0xe0, 0xd2, 0x7c, 0x5f, 0xdb, - 0x20, 0xa0, 0x3e, 0x6f, 0x79, 0x26, 0x07, 0x24, 0x25, 0x26, 0xb0, 0xf0, 0xb8, 0x29, 0x5f, 0xe3, 0xd4, 0x5b, 0xef, - 0xb2, 0x1a, 0x75, 0xc5, 0x25, 0x8d, 0x36, 0xce, 0x18, 0x34, 0x18, 0x1d, 0x11, 0x89, 0xe7, 0x42, 0x30, 0x46, 0xc3, - 0xdf, 0x7a, 0x24, 0x69, 0x08, 0xce, 0x63, 0x4f, 0x10, 0x37, 0x39, 0x99, 0xde, 0x40, 0x88, 0xb2, 0x6d, 0xb9, 0xf9, - 0x79, 0x5f, 0xa0, 0xd1, 0x9c, 0x8f, 0x4d, 0xcc, 0x9c, 0xf7, 0x00, 0x65, 0x26, 0x5a, 0x04, 0xe4, 0xd0, 0xe3, 0x1e, - 0xe2, 0x2a, 0x3d, 0x58, 0xec, 0x25, 0x2e, 0xd3, 0x31, 0x10, 0x5f, 0xaf, 0x95, 0x82, 0x34, 0x3b, 0x8b, 0x14, 0x78, - 0x31, 0xdf, 0xfc, 0xc9, 0x95, 0x62, 0x95, 0x7c, 0xd3, 0x60, 0x72, 0xfe, 0xe4, 0xc7, 0xe6, 0x97, 0xe0, 0xe5, 0x5b, - 0x2d, 0xb5, 0xc8, 0x7d, 0xe0, 0x9d, 0xaf, 0x49, 0x41, 0xbb, 0xff, 0xd9, 0x92, 0x91, 0xf7, 0x31, 0xad, 0x96, 0xc5, - 0x5b, 0xed, 0xa2, 0x5b, 0x14, 0xf2, 0x26, 0x0f, 0xf7, 0xb0, 0x08, 0xa9, 0xb5, 0x96, 0x61, 0x56, 0xdb, 0xa3, 0xdc, - 0xd8, 0x7b, 0xbd, 0x16, 0xa4, 0x45, 0xcc, 0x2e, 0x51, 0xe5, 0xc6, 0x0b, 0x4c, 0xd6, 0x9f, 0x5c, 0x08, 0x96, 0xf9, - 0x05, 0x55, 0x69, 0xef, 0xb2, 0x8e, 0xa7, 0x6c, 0x66, 0xad, 0x8b, 0x9a, 0x4d, 0x01, 0xa7, 0x28, 0x2b, 0x55, 0xdc, - 0xc8, 0xe0, 0xbb, 0x46, 0xa0, 0x35, 0xf0, 0x13, 0x18, 0xa5, 0xc8, 0x6a, 0xaa, 0x8d, 0xa4, 0xff, 0xce, 0xe4, 0xdf, - 0x39, 0xe6, 0xbf, 0x41, 0xe6, 0xdf, 0x87, 0x56, 0x7e, 0xdf, 0x18, 0x6b, 0x02, 0x5c, 0xe1, 0xa4, 0x10, 0x5f, 0xa9, - 0x9c, 0x25, 0x80, 0x1a, 0x4d, 0x99, 0xec, 0xc6, 0x0b, 0x81, 0x15, 0x91, 0xe7, 0x36, 0x4e, 0xb3, 0xb4, 0x47, 0xb6, - 0xe8, 0xfe, 0xce, 0x0b, 0x70, 0x42, 0x2e, 0x0a, 0xee, 0x88, 0xed, 0xab, 0x31, 0xe7, 0x50, 0xc4, 0xd9, 0xe4, 0xa2, - 0x00, 0x31, 0x82, 0x01, 0x21, 0x1b, 0x49, 0xa0, 0xa3, 0xa4, 0x99, 0x68, 0xc4, 0x14, 0x80, 0x06, 0xd8, 0xdd, 0x03, - 0x04, 0x16, 0xc1, 0x0c, 0x13, 0x04, 0x23, 0x79, 0x25, 0xc0, 0x72, 0x4c, 0xf6, 0x8e, 0x55, 0xb0, 0xb0, 0x52, 0x07, - 0x3b, 0xd0, 0x20, 0x4e, 0x60, 0x8a, 0x66, 0x79, 0x24, 0x28, 0xaa, 0x60, 0x11, 0x25, 0xcb, 0x36, 0x17, 0x2f, 0x32, - 0xb7, 0xf5, 0x2a, 0x49, 0xa1, 0x8b, 0xa7, 0x4f, 0x33, 0x4b, 0x28, 0xfd, 0x03, 0xf0, 0xaf, 0x41, 0x1d, 0xd8, 0xb3, - 0x0e, 0xa0, 0x63, 0x2b, 0x4e, 0x4e, 0xa5, 0xca, 0x9f, 0x5d, 0x03, 0x40, 0x49, 0x4f, 0x1b, 0xc4, 0x5c, 0xa0, 0x75, - 0x0d, 0x71, 0x0d, 0x2a, 0x80, 0x61, 0x93, 0xf1, 0x52, 0x53, 0xdb, 0x7a, 0x66, 0xf1, 0x52, 0xef, 0x91, 0x99, 0xa3, - 0x43, 0x12, 0x2f, 0xa2, 0xc4, 0x5d, 0x14, 0x96, 0x23, 0xa5, 0xd6, 0xdc, 0x28, 0xd6, 0x98, 0xf2, 0xd2, 0x6e, 0x0e, - 0xf1, 0x1d, 0xa2, 0xd3, 0x45, 0x50, 0xf5, 0x79, 0x8b, 0xa7, 0xb5, 0x11, 0xf8, 0x91, 0xd3, 0xa2, 0x40, 0x79, 0xbb, - 0xe2, 0xa4, 0xa6, 0x27, 0x3b, 0x56, 0xd8, 0x34, 0x2d, 0xbd, 0x83, 0x5b, 0x4f, 0xdf, 0x96, 0x64, 0x90, 0x71, 0x20, - 0xb0, 0x23, 0x20, 0x6c, 0x8a, 0x3b, 0x33, 0xd1, 0x16, 0x47, 0x70, 0x82, 0x50, 0x46, 0x66, 0x87, 0x6f, 0x05, 0xcf, - 0x2a, 0x02, 0x9f, 0xf7, 0xa3, 0xf7, 0x9c, 0xeb, 0x6a, 0x28, 0xad, 0x8e, 0x3d, 0x6a, 0x24, 0x38, 0xca, 0xb3, 0xa6, - 0x6f, 0x38, 0xa7, 0x16, 0x21, 0x55, 0x71, 0xbf, 0x00, 0x2b, 0xb7, 0xf7, 0x49, 0x83, 0x15, 0x9f, 0xb1, 0x6c, 0x0f, - 0xb2, 0x95, 0x32, 0xa2, 0x91, 0xf2, 0xba, 0xc7, 0xcc, 0x68, 0x7b, 0xc1, 0xc8, 0x8d, 0xb9, 0xe1, 0xfd, 0xec, 0x31, - 0x8a, 0xea, 0x15, 0x46, 0xac, 0x16, 0xdb, 0x09, 0x30, 0xf7, 0xc6, 0xbd, 0x55, 0x33, 0x67, 0x3e, 0xe5, 0x42, 0x4a, - 0xa9, 0x60, 0xbe, 0x53, 0x79, 0x06, 0x27, 0x9f, 0x42, 0x30, 0xe4, 0x87, 0xef, 0x33, 0xbf, 0x5e, 0x73, 0x6b, 0x96, - 0xf1, 0xa2, 0xbe, 0xa7, 0x7d, 0x36, 0x43, 0x6d, 0x78, 0xb5, 0x94, 0x10, 0x57, 0x67, 0xd9, 0xb9, 0x78, 0x0d, 0xac, - 0xa9, 0x0c, 0xf0, 0x15, 0xab, 0xa2, 0x2e, 0xc1, 0x57, 0xc4, 0xbc, 0x91, 0x30, 0x7f, 0xc3, 0x2a, 0x06, 0xf3, 0xa6, - 0x4a, 0xca, 0x27, 0xee, 0x8f, 0xd8, 0x94, 0x71, 0x89, 0xb2, 0xa5, 0x0f, 0xe9, 0x77, 0xb0, 0x37, 0xaa, 0x78, 0xb3, - 0x12, 0xbe, 0x96, 0xec, 0xb7, 0x7d, 0x6c, 0x4d, 0xc2, 0x14, 0x00, 0x2d, 0x32, 0x16, 0x01, 0xdd, 0x7a, 0xf5, 0xb6, - 0x90, 0xad, 0x09, 0x8d, 0x34, 0x34, 0x84, 0xa2, 0xee, 0xbd, 0x60, 0x62, 0x52, 0xdc, 0x1d, 0x28, 0x31, 0x31, 0x9e, - 0x35, 0x96, 0x5f, 0x90, 0x9f, 0x57, 0x75, 0xda, 0x1a, 0x73, 0xa1, 0x63, 0x46, 0x30, 0xa9, 0x41, 0x33, 0x01, 0x92, - 0x00, 0x5e, 0x2e, 0xa3, 0xc1, 0x38, 0x4f, 0x38, 0x36, 0xf7, 0x3a, 0x4b, 0xc8, 0x00, 0x81, 0x4e, 0x31, 0xa5, 0x52, - 0xbc, 0x5a, 0x1f, 0xa4, 0x94, 0x17, 0x80, 0xb2, 0x63, 0x36, 0x58, 0x52, 0x50, 0x1f, 0x6d, 0xda, 0x4c, 0xae, 0x6d, - 0x0d, 0x7b, 0xca, 0x64, 0xd6, 0x42, 0x99, 0xe6, 0x0f, 0x97, 0xf9, 0x45, 0xc4, 0xb8, 0xa8, 0xf9, 0x84, 0x7d, 0xd5, - 0x61, 0x04, 0x5a, 0x8f, 0x41, 0x5e, 0x0f, 0x27, 0xbc, 0x9f, 0xd7, 0xfb, 0xe6, 0xd6, 0xc4, 0x93, 0x17, 0x05, 0x4e, - 0x7d, 0xa9, 0xfc, 0x4b, 0xfb, 0x13, 0xd8, 0xc4, 0x03, 0x99, 0xf8, 0x54, 0xb2, 0x95, 0x89, 0xa2, 0x04, 0xa2, 0x5a, - 0x84, 0x67, 0x92, 0x0b, 0x82, 0x94, 0x8c, 0x97, 0x81, 0x50, 0xdb, 0x8c, 0x06, 0x24, 0xef, 0x6b, 0x4b, 0x78, 0x2d, - 0xf9, 0x74, 0x11, 0xf2, 0x66, 0x33, 0xac, 0xed, 0xf9, 0xb4, 0xdb, 0xde, 0x4a, 0xa1, 0x6a, 0x80, 0x92, 0xc9, 0x70, - 0x19, 0xf4, 0x0d, 0xcd, 0x0e, 0xe5, 0x09, 0xed, 0xf6, 0x6d, 0x56, 0xca, 0x24, 0xcc, 0x4e, 0xd7, 0xe4, 0xa8, 0xf8, - 0x85, 0xd2, 0xee, 0x6c, 0x74, 0x05, 0xaf, 0x75, 0x07, 0xe3, 0xa2, 0x50, 0x0e, 0x30, 0xa6, 0x46, 0xe6, 0x0f, 0xdc, - 0xc8, 0x91, 0xa5, 0x0f, 0xcb, 0xe4, 0xa2, 0x56, 0x54, 0x26, 0x43, 0xda, 0xb4, 0xb6, 0xea, 0x36, 0x1b, 0x25, 0xe9, - 0xb2, 0x44, 0xce, 0xb7, 0x56, 0xf1, 0xb2, 0xea, 0xe1, 0x5d, 0x28, 0xa5, 0xef, 0x4b, 0x5c, 0xbc, 0x74, 0xa0, 0xee, - 0x6d, 0x25, 0x96, 0xf0, 0xa9, 0x69, 0xe2, 0x14, 0xdc, 0x01, 0x63, 0x95, 0xad, 0x88, 0x5a, 0x20, 0xa9, 0xff, 0xc2, - 0x8b, 0xfb, 0x42, 0x84, 0x78, 0xe7, 0xaa, 0x57, 0x33, 0x24, 0x66, 0x92, 0xc7, 0x68, 0xf5, 0x3b, 0x88, 0x82, 0x6e, - 0x39, 0x8d, 0x03, 0x02, 0x4f, 0x4d, 0x7a, 0xf9, 0xed, 0x48, 0xe2, 0xec, 0x36, 0x2b, 0x34, 0xd0, 0xe3, 0x59, 0x76, - 0xb0, 0xc6, 0xb6, 0x6a, 0x8f, 0x67, 0xa6, 0x2f, 0x2e, 0xb4, 0x4c, 0xc2, 0x98, 0xdf, 0x36, 0xf4, 0x03, 0xd8, 0xa5, - 0xe9, 0xc6, 0x41, 0x63, 0x76, 0x57, 0xab, 0x2f, 0xf1, 0xbc, 0xa8, 0x82, 0x24, 0x2e, 0xb1, 0x31, 0x0a, 0xeb, 0xb7, - 0x2a, 0x1f, 0x15, 0x05, 0xcb, 0xb9, 0xe5, 0xaa, 0xca, 0x6b, 0xd7, 0x91, 0x17, 0xaf, 0x45, 0x4e, 0x82, 0xca, 0x3d, - 0x32, 0xe3, 0x18, 0x5c, 0x44, 0x0b, 0xfd, 0x9c, 0x5e, 0x54, 0x15, 0x1d, 0xaf, 0x2c, 0x6b, 0x88, 0x20, 0x70, 0xab, - 0xea, 0x15, 0x52, 0x62, 0x91, 0x98, 0x67, 0x11, 0xb2, 0xbd, 0x0e, 0x72, 0x9b, 0xb3, 0x81, 0x70, 0x93, 0x4e, 0x09, - 0x9c, 0x92, 0xf0, 0x0f, 0xe5, 0xd9, 0x86, 0x11, 0xf5, 0x4c, 0x6b, 0xa4, 0x8b, 0xaa, 0x35, 0xe7, 0xb5, 0x28, 0xd4, - 0x0e, 0x94, 0xb8, 0x5a, 0xaf, 0x6e, 0x84, 0x42, 0x80, 0x70, 0x61, 0xfe, 0x1c, 0xc0, 0xfd, 0x6d, 0xcd, 0x8a, 0x07, - 0x9b, 0xca, 0xa1, 0x5a, 0x35, 0x6d, 0x1c, 0x80, 0x03, 0xf2, 0x16, 0x2b, 0x83, 0x0b, 0x24, 0xc3, 0x0c, 0xf5, 0x32, - 0xd1, 0x06, 0x43, 0xc5, 0x38, 0xb5, 0xf8, 0x5c, 0xea, 0x5c, 0xa7, 0x4f, 0xc3, 0x8a, 0x99, 0xc5, 0x1d, 0xfa, 0x6c, - 0x95, 0x39, 0xf8, 0xda, 0x11, 0xec, 0xf2, 0x93, 0x69, 0xdb, 0x07, 0x25, 0xbf, 0x0d, 0x65, 0x1a, 0xde, 0xc4, 0xb9, - 0x4d, 0xd9, 0xe9, 0x63, 0x65, 0xe1, 0xab, 0xf7, 0x9d, 0x5b, 0xf2, 0xc1, 0xcc, 0x16, 0x91, 0x7e, 0x05, 0x18, 0xf2, - 0xc7, 0xf8, 0x79, 0x32, 0x88, 0xb6, 0x9d, 0xae, 0x73, 0xcd, 0x3b, 0x54, 0x49, 0x45, 0x45, 0xae, 0x84, 0x21, 0x72, - 0x28, 0xe4, 0x32, 0x52, 0xfa, 0x5a, 0x22, 0x6b, 0x33, 0x72, 0x27, 0xd3, 0x8f, 0x96, 0xd3, 0x29, 0x0e, 0x79, 0x69, - 0xad, 0x0b, 0xeb, 0xf2, 0x37, 0xba, 0xb2, 0x4d, 0xfa, 0x4b, 0x3d, 0x91, 0x8b, 0x86, 0xf0, 0xf3, 0xb5, 0xcd, 0x01, - 0x4a, 0xfd, 0xaf, 0xd6, 0x2f, 0xe2, 0xa8, 0xa0, 0x0b, 0x5d, 0x19, 0x88, 0x0f, 0x8a, 0x52, 0x82, 0xed, 0x73, 0x96, - 0x50, 0xd7, 0x3d, 0x30, 0x4e, 0xba, 0xe2, 0xa4, 0xe8, 0x17, 0xef, 0x45, 0x78, 0x6f, 0x9f, 0x1c, 0x56, 0xee, 0x10, - 0xa7, 0xa7, 0x5a, 0xf5, 0x31, 0x32, 0x59, 0x49, 0x4c, 0x34, 0x61, 0x95, 0x37, 0x34, 0x87, 0xad, 0x32, 0x9a, 0xd5, - 0x74, 0x9d, 0x7c, 0x7f, 0xa0, 0x30, 0x12, 0x19, 0xfe, 0x6e, 0x6e, 0x22, 0x03, 0x0d, 0x1c, 0xd5, 0x19, 0xa8, 0xe4, - 0xb8, 0x9f, 0x6b, 0xd6, 0x87, 0xca, 0x4b, 0x00, 0x64, 0xf6, 0x78, 0xa3, 0xac, 0x5b, 0x7e, 0x37, 0xaf, 0x41, 0x40, - 0xaf, 0xff, 0x15, 0x6d, 0xb2, 0x80, 0x68, 0x33, 0xb8, 0x56, 0x53, 0x50, 0x3e, 0x65, 0xa2, 0x3f, 0xda, 0xa0, 0x67, - 0xbf, 0xdb, 0xe6, 0x0c, 0xd5, 0x85, 0xa5, 0xc4, 0xee, 0x5b, 0x94, 0x15, 0x0b, 0xd8, 0xcf, 0x6a, 0x84, 0xee, 0x94, - 0xf1, 0xf3, 0x47, 0xdd, 0xcc, 0x66, 0x61, 0xab, 0x08, 0xe8, 0xd1, 0x57, 0x57, 0x1c, 0x00, 0x0b, 0xe8, 0x12, 0x16, - 0x46, 0xec, 0x58, 0xca, 0x33, 0xcb, 0x54, 0xf6, 0x99, 0x47, 0x74, 0x7d, 0x33, 0xe4, 0x1e, 0x3e, 0xdd, 0x7e, 0x8b, - 0x55, 0x31, 0x8e, 0x27, 0xd6, 0xd5, 0x45, 0x67, 0x50, 0x34, 0x21, 0xe9, 0xf4, 0xcb, 0x19, 0x90, 0xaa, 0x95, 0x9d, - 0x98, 0xab, 0x36, 0x01, 0xf4, 0xf6, 0x5d, 0x49, 0xe0, 0x31, 0x39, 0xbc, 0x1b, 0xcc, 0x2c, 0x30, 0x45, 0xcb, 0x52, - 0x08, 0x7d, 0xb7, 0x14, 0xe5, 0xbc, 0x15, 0x0a, 0x06, 0xb4, 0x0b, 0xc2, 0xdf, 0x38, 0x2e, 0xb1, 0x05, 0x2d, 0xa3, - 0xf5, 0x22, 0x88, 0x8e, 0x40, 0x24, 0x37, 0x46, 0x8e, 0x0f, 0x67, 0xeb, 0x1a, 0x14, 0x43, 0x96, 0xba, 0xc0, 0xa1, - 0x9b, 0x17, 0x6c, 0x97, 0x0a, 0xc9, 0x44, 0xbe, 0x43, 0x43, 0x60, 0x79, 0xee, 0xc4, 0xe9, 0x80, 0xe8, 0xde, 0xdf, - 0x27, 0x4b, 0x56, 0x54, 0xfc, 0x50, 0x86, 0xdb, 0x17, 0x66, 0x70, 0xa8, 0x27, 0xde, 0x0c, 0x3a, 0xe0, 0x4a, 0xef, - 0x53, 0x25, 0x46, 0x32, 0xeb, 0x1d, 0x20, 0x8a, 0x88, 0x32, 0xf3, 0x4c, 0x76, 0x8b, 0xdb, 0xc3, 0x29, 0x60, 0x20, - 0x63, 0xda, 0xa4, 0x27, 0xc3, 0x44, 0x60, 0x88, 0xf9, 0x6a, 0x7c, 0xde, 0x83, 0x1f, 0xdb, 0x7d, 0x44, 0xce, 0x45, - 0xb9, 0x86, 0xc2, 0x36, 0x66, 0x33, 0x5b, 0xf4, 0x04, 0xdf, 0x48, 0xa4, 0xa3, 0x97, 0x31, 0x94, 0x0b, 0x84, 0x83, - 0x95, 0xce, 0x89, 0xe9, 0xc1, 0x8a, 0x2a, 0x40, 0x5c, 0xb9, 0x71, 0xca, 0xa8, 0x01, 0xb3, 0xe4, 0x06, 0x57, 0xd0, - 0x64, 0xd4, 0xe1, 0x57, 0x77, 0xf4, 0xec, 0x63, 0x16, 0xdc, 0x93, 0x97, 0xc1, 0xa1, 0x6e, 0xad, 0xa7, 0x75, 0xf7, - 0x06, 0x12, 0x62, 0x41, 0x59, 0x60, 0xce, 0x4e, 0x87, 0x85, 0x15, 0x6c, 0x6b, 0x6a, 0x85, 0x57, 0xeb, 0x87, 0x16, - 0x56, 0x92, 0xe1, 0x34, 0x88, 0x24, 0xce, 0xc0, 0x34, 0x0a, 0xf1, 0x87, 0xfa, 0x8b, 0x45, 0x5f, 0x9e, 0xf8, 0xad, - 0xfb, 0x6b, 0xa9, 0xb4, 0xfa, 0xfc, 0xb3, 0x58, 0xb8, 0x20, 0x13, 0xfb, 0x8d, 0x5e, 0x58, 0x98, 0x14, 0x56, 0xe0, - 0xaa, 0x7a, 0xc1, 0xb3, 0x64, 0xa5, 0xf0, 0xe4, 0xbb, 0x11, 0x5a, 0x7a, 0xc2, 0xcf, 0xa3, 0xac, 0x1a, 0x7b, 0x33, - 0xa2, 0x51, 0x2d, 0x9f, 0x82, 0xda, 0x1d, 0x1d, 0x08, 0x97, 0xc9, 0xc0, 0xaa, 0xb2, 0x00, 0xf5, 0xe7, 0x97, 0xb9, - 0x47, 0xc2, 0xba, 0x54, 0x4c, 0xd9, 0x07, 0xcf, 0x89, 0xa0, 0xb7, 0x10, 0x85, 0x18, 0x1e, 0x49, 0xdf, 0xa0, 0xfc, - 0xea, 0x8f, 0xfc, 0xbe, 0xd7, 0x93, 0xbf, 0x33, 0x76, 0xbe, 0x69, 0x96, 0x3b, 0xb3, 0xd7, 0xe8, 0xf5, 0xcf, 0x21, - 0x6b, 0x11, 0x06, 0x39, 0x4d, 0x17, 0x82, 0x26, 0x28, 0x5e, 0x18, 0x0d, 0xac, 0xe7, 0x74, 0xad, 0x37, 0x41, 0xee, - 0x85, 0xc4, 0xf8, 0x7f, 0x91, 0xf0, 0x32, 0xa0, 0x72, 0x32, 0x8a, 0x5a, 0xf0, 0x00, 0x5c, 0x55, 0x43, 0x2d, 0x50, - 0x26, 0x0f, 0x4f, 0xa0, 0x25, 0x63, 0x11, 0x9e, 0x65, 0x1f, 0xeb, 0xd4, 0xc1, 0x78, 0x24, 0xf3, 0xb0, 0xa6, 0xc2, - 0xd5, 0x72, 0x36, 0x39, 0x66, 0x76, 0xcc, 0xea, 0x6a, 0x1f, 0xbb, 0x13, 0x26, 0xf1, 0xcc, 0x79, 0xc8, 0x67, 0xdb, - 0xe3, 0x40, 0x53, 0x6f, 0x1e, 0x38, 0xac, 0x69, 0x36, 0x11, 0xe4, 0x9a, 0x06, 0xb6, 0x00, 0x83, 0x9d, 0xac, 0x55, - 0xa3, 0x84, 0x64, 0xcd, 0x0d, 0x80, 0x38, 0x92, 0x51, 0x08, 0xa9, 0x6c, 0xf8, 0x81, 0xb5, 0x54, 0x5f, 0x81, 0x1e, - 0xab, 0x2f, 0x35, 0x0c, 0x84, 0xa8, 0x6d, 0x84, 0x2a, 0x60, 0x0c, 0x5c, 0x99, 0x7f, 0x29, 0x10, 0x5c, 0xd0, 0x5f, - 0xf6, 0x1a, 0xbe, 0xdc, 0xac, 0xdb, 0x8e, 0x21, 0xea, 0x3a, 0x58, 0x8b, 0xc8, 0x78, 0xd5, 0x15, 0xfe, 0x1b, 0x6e, - 0x22, 0x45, 0x0a, 0xc5, 0x12, 0x91, 0xfc, 0x88, 0xf2, 0x1e, 0xe3, 0x1e, 0xea, 0xbd, 0x1d, 0xbc, 0x8e, 0x84, 0x41, - 0x73, 0xa8, 0xd1, 0x4a, 0x52, 0xbc, 0xc7, 0x56, 0x3d, 0xf6, 0x28, 0xb8, 0x9f, 0x2c, 0x35, 0x7c, 0x87, 0x28, 0x5d, - 0xfd, 0x14, 0x50, 0x4f, 0xfe, 0xa3, 0x67, 0x9b, 0xa7, 0x66, 0x1f, 0x11, 0x7d, 0x93, 0xd1, 0x38, 0xb2, 0x50, 0x51, - 0x14, 0x5e, 0x08, 0x81, 0xe7, 0x1c, 0xf1, 0x54, 0x1f, 0x20, 0xe6, 0x21, 0xd3, 0x64, 0xe4, 0x7a, 0x40, 0x0f, 0x34, - 0x39, 0x7a, 0x76, 0x39, 0xa6, 0x8b, 0xf6, 0x61, 0x74, 0x6c, 0x47, 0x88, 0x4b, 0xb5, 0x89, 0x68, 0x4e, 0xab, 0x2e, - 0x5b, 0x48, 0x62, 0x9d, 0xa7, 0x7c, 0xa4, 0x20, 0x07, 0x6e, 0xc2, 0xea, 0x77, 0x8e, 0x43, 0xbb, 0x28, 0xb8, 0x7d, - 0x4d, 0x25, 0x9c, 0x8d, 0x2a, 0xba, 0x2f, 0x83, 0x4f, 0xa2, 0x59, 0x34, 0x80, 0x6c, 0xc0, 0xd7, 0xfb, 0xdb, 0x09, - 0x96, 0x25, 0xd8, 0x45, 0x6d, 0xa6, 0x6c, 0x5e, 0x9e, 0xc3, 0x6c, 0x6b, 0xb8, 0x2f, 0xd0, 0xfa, 0x12, 0xea, 0x5d, - 0xea, 0x33, 0xc2, 0xb7, 0xf2, 0x60, 0x88, 0xc9, 0xca, 0xcd, 0x46, 0x16, 0x83, 0x75, 0x98, 0x75, 0x8f, 0x91, 0x39, - 0x89, 0x7f, 0xa1, 0xce, 0x5c, 0x10, 0x9e, 0x59, 0xc9, 0x82, 0x4f, 0xe8, 0x66, 0xb0, 0x61, 0x3c, 0xc6, 0xcf, 0x51, - 0xf6, 0xe0, 0xfd, 0x4e, 0x92, 0x56, 0x30, 0x1b, 0x92, 0xda, 0x71, 0xb5, 0xd6, 0xf1, 0x8b, 0x0b, 0xf4, 0x20, 0x35, - 0xf1, 0x54, 0x54, 0x76, 0xc4, 0x2c, 0x90, 0xea, 0x25, 0xf6, 0xbe, 0xf9, 0x49, 0x7c, 0xa4, 0x0d, 0x9e, 0xcb, 0x10, - 0x06, 0xf4, 0x46, 0x62, 0x7d, 0xaf, 0x94, 0xa6, 0x47, 0x65, 0x63, 0xd0, 0xda, 0x98, 0xc9, 0x1c, 0x26, 0xd6, 0x5d, - 0xa2, 0x5e, 0x2c, 0x4f, 0xf2, 0x6b, 0x5b, 0xd3, 0x8a, 0xe3, 0x91, 0xf4, 0x55, 0x95, 0x62, 0xfe, 0x18, 0xd0, 0xf8, - 0xd7, 0x14, 0xc9, 0x23, 0x03, 0x0d, 0x06, 0xa9, 0xb1, 0x62, 0x19, 0x80, 0x43, 0x0c, 0x4d, 0x44, 0x6d, 0xa0, 0x1d, - 0xc3, 0x1d, 0x8d, 0x0c, 0xa9, 0x8f, 0x68, 0x86, 0x24, 0xc0, 0x23, 0x9b, 0x98, 0xac, 0x8c, 0x5d, 0x80, 0x2b, 0x70, - 0xfb, 0x78, 0x06, 0x8d, 0xdf, 0x6e, 0xdd, 0x20, 0xa5, 0xa6, 0x9c, 0x2e, 0x02, 0xd6, 0x98, 0x00, 0x9e, 0x52, 0x4d, - 0xb4, 0x6c, 0x48, 0xf5, 0x53, 0x27, 0x60, 0xbf, 0x38, 0xa8, 0x8f, 0xad, 0x69, 0x4a, 0x59, 0x36, 0x0d, 0xbc, 0x94, - 0x34, 0x42, 0x8c, 0xd0, 0x57, 0x38, 0xe5, 0x08, 0xc4, 0x3b, 0xfc, 0xfa, 0xf4, 0x7a, 0x92, 0xde, 0x26, 0xda, 0xd8, - 0x64, 0x80, 0x61, 0xf8, 0x18, 0xe1, 0x17, 0x3d, 0xec, 0x6c, 0xcd, 0xf8, 0x6b, 0x82, 0x64, 0x3c, 0x29, 0x7c, 0x56, - 0x78, 0x36, 0xb5, 0x45, 0x93, 0x10, 0xff, 0x40, 0x74, 0x28, 0x30, 0x3a, 0x15, 0x94, 0xd9, 0x97, 0x8b, 0xea, 0x45, - 0x4e, 0x41, 0xa3, 0x7d, 0x66, 0xb9, 0xb2, 0x2c, 0x5f, 0x5f, 0xfe, 0xe3, 0x5c, 0x77, 0x5c, 0x62, 0xcf, 0x9d, 0x94, - 0xb8, 0x68, 0x65, 0xcd, 0x1f, 0x5a, 0x5b, 0x6f, 0xc9, 0x61, 0x23, 0x17, 0x9d, 0x42, 0x09, 0xff, 0xc4, 0x5f, 0x0a, - 0x82, 0x95, 0x7b, 0xb0, 0x64, 0x2a, 0xe5, 0x82, 0x8b, 0x19, 0xdd, 0x76, 0xfa, 0x5e, 0xb0, 0xd0, 0xd9, 0xd9, 0xc5, - 0x71, 0x82, 0x24, 0xe5, 0x87, 0xfc, 0x33, 0xef, 0xe2, 0x6c, 0x3b, 0xab, 0xe9, 0x68, 0x45, 0xef, 0xd8, 0xbb, 0x1c, - 0x4e, 0x6c, 0x11, 0xa5, 0xd3, 0x07, 0xe7, 0x67, 0x33, 0xf8, 0xe0, 0x28, 0x6a, 0xe9, 0x4c, 0xcd, 0x58, 0xc0, 0xb9, - 0xb9, 0x7b, 0x88, 0xa0, 0xa7, 0x90, 0x88, 0xd1, 0xf7, 0x2e, 0xa8, 0xf7, 0x8a, 0x6d, 0xce, 0x37, 0x89, 0xa0, 0xcd, - 0x0a, 0x9a, 0x45, 0xf4, 0x62, 0x78, 0x2a, 0xbc, 0x76, 0xe7, 0x5a, 0xae, 0x78, 0x5e, 0x42, 0xa3, 0x21, 0x6b, 0x90, - 0x6c, 0xbf, 0xd3, 0xc4, 0x0f, 0xfa, 0xb9, 0xd5, 0x42, 0x6d, 0x65, 0x4a, 0xfd, 0x98, 0x31, 0x4b, 0x9d, 0xb3, 0x92, - 0xfe, 0x9c, 0xfa, 0x0c, 0x6a, 0x9e, 0x6c, 0x75, 0xfa, 0x35, 0x9f, 0x5f, 0x0e, 0xd5, 0xb3, 0x99, 0xf2, 0x0e, 0x61, - 0x09, 0xf3, 0x7d, 0xa2, 0x54, 0x8f, 0xac, 0xbb, 0x25, 0xce, 0x52, 0x54, 0xc7, 0x22, 0x89, 0x22, 0x63, 0x3b, 0xc3, - 0x11, 0x7a, 0x21, 0xf1, 0x6c, 0x56, 0x67, 0xc2, 0xe4, 0x6a, 0x16, 0x6f, 0x07, 0x73, 0x25, 0x9c, 0xc4, 0x22, 0x89, - 0x50, 0xa4, 0x7d, 0x23, 0x5d, 0x4c, 0xf9, 0xa9, 0xce, 0xed, 0x48, 0xa8, 0xf4, 0x16, 0xff, 0x34, 0xb8, 0xc4, 0x44, - 0x2a, 0x50, 0x89, 0xcf, 0xef, 0x96, 0x58, 0x22, 0x49, 0x15, 0x39, 0x14, 0xd4, 0xca, 0xe4, 0x0f, 0x9b, 0xe7, 0x52, - 0x5a, 0x77, 0x47, 0xe0, 0xfa, 0x32, 0x56, 0x12, 0x77, 0xff, 0x32, 0x99, 0x47, 0x01, 0xd8, 0x2f, 0xcb, 0x75, 0x3e, - 0xc4, 0x80, 0xcb, 0xa3, 0x53, 0x8d, 0x20, 0xd8, 0xf1, 0x06, 0xde, 0x0c, 0x24, 0x08, 0x4e, 0x33, 0x12, 0x11, 0x0b, - 0xce, 0x90, 0xc5, 0x93, 0x37, 0x00, 0x24, 0xe7, 0x0f, 0xf1, 0xf3, 0x82, 0x94, 0x1d, 0xa0, 0x0a, 0x47, 0x05, 0x20, - 0x76, 0x48, 0xd0, 0xe8, 0xc2, 0xbb, 0xd9, 0x67, 0xad, 0xd9, 0xf2, 0x7a, 0x55, 0x3c, 0x07, 0x55, 0x43, 0x72, 0x52, - 0x12, 0x46, 0x9c, 0x61, 0xf6, 0x83, 0xa0, 0x44, 0xf9, 0xf6, 0x30, 0x21, 0x8c, 0xcc, 0x96, 0x78, 0xa1, 0xd1, 0x20, - 0xc0, 0xed, 0x23, 0xc4, 0x4c, 0xb6, 0x4d, 0x39, 0x26, 0x5f, 0x73, 0xc6, 0x39, 0x63, 0xce, 0x10, 0x8a, 0x06, 0x66, - 0x6b, 0x09, 0xc4, 0x3a, 0x8b, 0x32, 0x1a, 0x4a, 0x53, 0xfc, 0x4e, 0x8e, 0xa0, 0xd6, 0x91, 0xb7, 0x26, 0x43, 0xbb, - 0x0d, 0xee, 0x44, 0x80, 0x43, 0x0a, 0xf7, 0x4b, 0x60, 0x41, 0x79, 0xe5, 0xb6, 0x64, 0x96, 0xda, 0x7e, 0x48, 0xb6, - 0x92, 0xde, 0x9b, 0x81, 0xc1, 0xbb, 0x58, 0xc3, 0xc5, 0x2c, 0x1d, 0x25, 0x64, 0x15, 0x6c, 0x16, 0xeb, 0xfe, 0xe5, - 0xd7, 0x5d, 0x37, 0x19, 0xb9, 0xad, 0x92, 0xb1, 0xa2, 0x1c, 0x8f, 0xab, 0x39, 0x1b, 0x70, 0x7d, 0x19, 0xa4, 0xe1, - 0x52, 0x21, 0x74, 0xa6, 0x7d, 0xb7, 0xbf, 0x8b, 0x6b, 0xb7, 0x5c, 0x1e, 0x2d, 0xc0, 0xa0, 0x8d, 0x3d, 0x70, 0x8a, - 0x0a, 0x2c, 0x89, 0x0a, 0x49, 0xd8, 0x7c, 0x00, 0x4c, 0xb5, 0x7e, 0x10, 0xe5, 0xf8, 0x77, 0x49, 0x5f, 0x0b, 0x32, - 0x3d, 0xd7, 0x79, 0x7e, 0x96, 0xfa, 0x83, 0x69, 0xf7, 0x71, 0x8c, 0xe1, 0x8c, 0xc3, 0x1c, 0x21, 0x2a, 0x73, 0xf4, - 0xeb, 0xcf, 0xf0, 0xd8, 0xdb, 0x4a, 0xf5, 0x9f, 0x50, 0x9c, 0xdf, 0x2b, 0xa3, 0x79, 0xb6, 0x4c, 0xfa, 0x6c, 0x41, - 0xbf, 0xcf, 0x24, 0x2d, 0xdd, 0x76, 0xf9, 0xc4, 0xff, 0xa6, 0x3a, 0x3c, 0xdd, 0xed, 0x11, 0xe3, 0x22, 0x92, 0x04, - 0x9f, 0x98, 0x13, 0x9e, 0xee, 0x9a, 0x89, 0xba, 0x3c, 0x43, 0x6a, 0xf7, 0xc6, 0x68, 0x9b, 0x4a, 0xf5, 0xb6, 0xac, - 0xd8, 0xf4, 0xa2, 0x22, 0xd8, 0xd5, 0x85, 0x75, 0x79, 0xf7, 0xbb, 0x4f, 0xa9, 0x77, 0x73, 0x10, 0x6e, 0x5c, 0x6d, - 0x57, 0x35, 0x5a, 0xcc, 0x69, 0x01, 0xa5, 0x24, 0x52, 0x12, 0xcd, 0xa6, 0x71, 0xa4, 0x54, 0xf8, 0x79, 0x8e, 0x92, - 0x5b, 0x49, 0x9b, 0x5f, 0x5b, 0xc3, 0x89, 0x2a, 0xa9, 0x8e, 0xd4, 0xd4, 0x61, 0x4d, 0x7a, 0x0a, 0xcc, 0xff, 0xd9, - 0x31, 0x12, 0x82, 0xc2, 0x85, 0x33, 0x0f, 0x28, 0xf5, 0x57, 0x43, 0xb5, 0x93, 0x3e, 0x1e, 0x79, 0x7d, 0x6f, 0x1d, - 0xe7, 0x3a, 0x17, 0xce, 0x38, 0x74, 0xd3, 0xcd, 0x03, 0x3d, 0xfd, 0xae, 0xc7, 0x57, 0xf1, 0xd7, 0x86, 0x64, 0x49, - 0x22, 0x35, 0x73, 0x67, 0x7b, 0x65, 0x4b, 0xfb, 0xea, 0xa1, 0x42, 0x8b, 0xe3, 0xd2, 0x58, 0xed, 0x2b, 0xcc, 0xd3, - 0x1b, 0x35, 0x58, 0x44, 0x94, 0xa6, 0x7e, 0x38, 0x1e, 0xd2, 0x79, 0x0e, 0xd4, 0xd4, 0xe2, 0xe6, 0x29, 0xa7, 0xf5, - 0x13, 0xc6, 0xa9, 0x00, 0x3b, 0x13, 0x45, 0x2e, 0x5e, 0xab, 0xbf, 0x29, 0xfd, 0x0a, 0xf6, 0xd7, 0x2b, 0xa9, 0xfa, - 0x99, 0xc5, 0x2a, 0x9d, 0x19, 0x56, 0xe5, 0xcc, 0x9a, 0xe9, 0x0a, 0xfb, 0x39, 0x17, 0xbb, 0x1c, 0x58, 0x94, 0x24, - 0x79, 0x3a, 0xae, 0xcc, 0x22, 0x9c, 0xdb, 0x4b, 0xe7, 0x91, 0x4e, 0x9d, 0x6c, 0x30, 0x29, 0x13, 0x5a, 0x3d, 0x32, - 0x2d, 0x31, 0x32, 0x4d, 0x20, 0xd8, 0xa5, 0xb7, 0xc8, 0xd2, 0xf6, 0x8b, 0x3b, 0x16, 0x85, 0xda, 0x5c, 0x6d, 0x7a, - 0x1c, 0x85, 0x8c, 0xf9, 0xa5, 0xb5, 0xa7, 0xc4, 0xa5, 0xf3, 0x63, 0x11, 0xed, 0xa7, 0x4b, 0x75, 0xac, 0xd9, 0x89, - 0x40, 0x95, 0x6b, 0x03, 0xf9, 0x79, 0x9b, 0x1e, 0xd2, 0xe7, 0x2d, 0x9c, 0x95, 0x3f, 0x94, 0x61, 0x7d, 0x40, 0x08, - 0x13, 0x81, 0x91, 0xb1, 0x50, 0x5a, 0x49, 0x60, 0x15, 0x78, 0xc5, 0xa8, 0xd9, 0x6c, 0x57, 0x7c, 0x1f, 0x40, 0x3a, - 0xc7, 0x4d, 0x08, 0x07, 0x80, 0xbc, 0x9e, 0x42, 0x75, 0x16, 0xa2, 0x40, 0x33, 0x05, 0x48, 0xf8, 0x21, 0x3d, 0x7f, - 0x01, 0xf3, 0xc7, 0x74, 0xf4, 0x56, 0xad, 0xdc, 0x46, 0x3b, 0x1c, 0xcb, 0x53, 0xe5, 0xa6, 0x1a, 0x87, 0x8b, 0x92, - 0xa8, 0x24, 0x16, 0x35, 0xbc, 0x72, 0x45, 0x9b, 0x33, 0x1f, 0xf9, 0x0d, 0xdb, 0xc4, 0xe3, 0x5f, 0x57, 0x63, 0x5c, - 0x81, 0xaa, 0x51, 0x05, 0x5b, 0xf2, 0x05, 0x98, 0xea, 0x2e, 0x12, 0xd8, 0x62, 0xd3, 0xd8, 0x9c, 0x81, 0x0e, 0xed, - 0xa3, 0xec, 0x49, 0xa9, 0x4a, 0x16, 0xa8, 0xe4, 0x6a, 0x29, 0xac, 0xb6, 0xa6, 0x51, 0x9b, 0x90, 0xf7, 0xbf, 0xa1, - 0x79, 0xeb, 0x4b, 0x3e, 0x61, 0x7b, 0x88, 0xe8, 0x33, 0x7c, 0xee, 0xa3, 0x5a, 0x7c, 0x0f, 0x28, 0x9c, 0x2d, 0x05, - 0x23, 0x53, 0x1c, 0xda, 0xe3, 0x05, 0x4a, 0x93, 0x79, 0x78, 0xa8, 0xa3, 0x0a, 0x1b, 0xf2, 0x11, 0x0e, 0xd8, 0x7e, - 0x4c, 0x61, 0x89, 0x0a, 0x25, 0xfa, 0x2e, 0xda, 0xcd, 0xc1, 0x77, 0xa5, 0x03, 0xde, 0x96, 0x21, 0x2e, 0xa6, 0x9b, - 0x9d, 0x78, 0x8b, 0x96, 0xe5, 0xab, 0x38, 0xd8, 0x66, 0x84, 0xa1, 0x6c, 0x0a, 0x70, 0xe7, 0xbd, 0xaa, 0x50, 0xe4, - 0xf8, 0xd6, 0x0c, 0x8e, 0xea, 0x0d, 0xd2, 0x45, 0x13, 0xa0, 0x0e, 0x46, 0x3d, 0xf0, 0x13, 0x82, 0x1c, 0x50, 0x19, - 0xbd, 0xdb, 0xa2, 0x2d, 0xae, 0x05, 0xcf, 0x84, 0x80, 0x34, 0xad, 0x48, 0xb5, 0x1b, 0xa5, 0x51, 0x1f, 0x0d, 0xcd, - 0xbe, 0x89, 0x45, 0x02, 0x90, 0xcc, 0xe2, 0x55, 0x49, 0xa4, 0x02, 0xd8, 0x02, 0x3b, 0x36, 0x8b, 0x6e, 0xf8, 0x66, - 0x7d, 0x32, 0x60, 0x68, 0xe9, 0xb5, 0xef, 0xc9, 0xea, 0xa3, 0xf6, 0xb9, 0x86, 0x78, 0xc5, 0x71, 0x8e, 0x34, 0x99, - 0x2a, 0xea, 0x7c, 0xb2, 0x8e, 0xf2, 0x58, 0x9b, 0xcb, 0xe5, 0x8d, 0x0d, 0x65, 0xd0, 0x63, 0x83, 0x45, 0x4a, 0x5c, - 0x3b, 0x66, 0xbf, 0xbe, 0xb8, 0xc8, 0xa0, 0xe3, 0x9c, 0x3e, 0x90, 0x30, 0x4d, 0x27, 0x11, 0xea, 0x8e, 0x95, 0xaf, - 0xab, 0xd0, 0x2c, 0x08, 0xfb, 0xfe, 0x22, 0x19, 0x6b, 0xd8, 0x78, 0x37, 0x64, 0x73, 0x7d, 0xd5, 0xde, 0x0f, 0x50, - 0x07, 0xe2, 0x62, 0xc0, 0xc5, 0x5b, 0x50, 0xc6, 0xcc, 0xbf, 0xa3, 0x5e, 0x2b, 0xa5, 0x34, 0x6a, 0x79, 0x18, 0x6a, - 0x78, 0xab, 0xbd, 0xcc, 0x7f, 0x3c, 0xfb, 0x90, 0x0f, 0x05, 0x2a, 0x54, 0x21, 0x35, 0x4d, 0xa2, 0x6e, 0xd7, 0x41, - 0x6c, 0x6b, 0x27, 0x99, 0x5a, 0xb1, 0x88, 0x94, 0x47, 0x80, 0xbb, 0x70, 0x78, 0xb7, 0xfa, 0x85, 0x11, 0xdf, 0xec, - 0x73, 0x2d, 0xb4, 0x25, 0x9a, 0xb3, 0x23, 0xde, 0x45, 0x2b, 0x3b, 0x9c, 0x5a, 0x20, 0x1d, 0x3b, 0x15, 0xdb, 0x25, - 0x8a, 0xde, 0x63, 0x81, 0xad, 0x66, 0x6b, 0xeb, 0xb7, 0x56, 0xf4, 0x21, 0xac, 0x16, 0xb4, 0xb6, 0xe7, 0x32, 0x8d, - 0xcd, 0xc4, 0x09, 0x62, 0x01, 0x34, 0x7b, 0xfb, 0xaa, 0x24, 0xef, 0x33, 0x0b, 0x2e, 0x4b, 0xb1, 0x44, 0x8a, 0xb0, - 0x03, 0x3a, 0x89, 0x06, 0x4c, 0x54, 0x05, 0xc7, 0x46, 0xec, 0xf9, 0xa2, 0xde, 0x37, 0xae, 0x4a, 0x32, 0x28, 0x93, - 0xd6, 0x6d, 0xd5, 0x8b, 0xc9, 0xf7, 0x7e, 0x16, 0x48, 0x3e, 0x14, 0x0e, 0x60, 0xc7, 0x25, 0x5c, 0x7c, 0x16, 0x8c, - 0xdc, 0x2a, 0x65, 0x2d, 0xc0, 0x9c, 0xce, 0x99, 0xbf, 0x5a, 0x7a, 0x34, 0x2d, 0x29, 0x27, 0x0e, 0xd3, 0xf7, 0xe7, - 0x10, 0xc9, 0x15, 0x48, 0x3f, 0xef, 0x3d, 0xef, 0x15, 0x7d, 0xe3, 0x8f, 0x57, 0xfb, 0x94, 0x19, 0xcd, 0xa6, 0x2c, - 0xf5, 0x64, 0xc9, 0xd3, 0x2d, 0x15, 0x1c, 0xa3, 0x8b, 0x56, 0x37, 0x6c, 0xcd, 0x8a, 0x35, 0x23, 0xcb, 0xf0, 0x8f, - 0x60, 0x85, 0x6f, 0x60, 0x5d, 0x2c, 0x01, 0xcd, 0xdf, 0x18, 0x1f, 0x85, 0x3c, 0x2e, 0x3e, 0xd0, 0xf9, 0x19, 0x21, - 0xae, 0xc2, 0x54, 0x91, 0x70, 0xbe, 0x55, 0x6a, 0xa5, 0x04, 0x15, 0xd3, 0xf2, 0x99, 0x16, 0xdf, 0xa8, 0x6d, 0x95, - 0xd9, 0x5b, 0x7e, 0x99, 0xe4, 0xca, 0x74, 0x7e, 0x9e, 0x9c, 0x49, 0xf1, 0xf2, 0xc3, 0x12, 0x55, 0xe6, 0x9f, 0x46, - 0x68, 0xa3, 0xef, 0xe1, 0xc7, 0x0e, 0x3f, 0xc8, 0xbc, 0x40, 0x24, 0xd5, 0xb8, 0xc0, 0x38, 0x2a, 0x3f, 0x4d, 0xab, - 0x11, 0x33, 0x45, 0xf8, 0xc6, 0xa9, 0x03, 0xcb, 0xf7, 0xb9, 0x54, 0x73, 0x2e, 0x42, 0x05, 0x10, 0x7b, 0x1a, 0x3b, - 0xef, 0xc2, 0x9c, 0x31, 0x15, 0x09, 0x84, 0x71, 0x85, 0x76, 0x49, 0x30, 0x76, 0x4b, 0xa9, 0xb6, 0xd5, 0xbb, 0x05, - 0xf3, 0x9a, 0x8a, 0x08, 0x98, 0xc2, 0x3b, 0xd0, 0xbc, 0x99, 0x2d, 0x6d, 0xd0, 0x39, 0xb1, 0xa3, 0x02, 0xfb, 0x31, - 0xa6, 0xbc, 0xc3, 0xde, 0x6f, 0xa6, 0xcf, 0x19, 0xe7, 0xd0, 0x3d, 0x0f, 0xf5, 0xa6, 0x33, 0x5c, 0xf9, 0x86, 0x3e, - 0x9b, 0x11, 0x67, 0x0b, 0x24, 0x5f, 0x23, 0x5b, 0xb1, 0xae, 0x5a, 0x82, 0xba, 0x07, 0x92, 0xbd, 0x7d, 0x75, 0xdd, - 0x5b, 0x7d, 0x2e, 0x08, 0x1a, 0xdd, 0xad, 0x00, 0xbb, 0x83, 0x05, 0xef, 0x56, 0x67, 0xe2, 0x89, 0x03, 0x80, 0xec, - 0xd2, 0x7f, 0x12, 0x36, 0xd0, 0x9d, 0x76, 0x7f, 0xed, 0x84, 0xb2, 0xa0, 0x75, 0x36, 0xe5, 0x31, 0xb4, 0x65, 0x17, - 0x11, 0x43, 0x76, 0x1d, 0xf6, 0xac, 0x9b, 0xfb, 0x42, 0x58, 0x81, 0xc7, 0x3d, 0xb0, 0xbe, 0x08, 0x7c, 0x4a, 0x04, - 0x24, 0xe4, 0x5c, 0x88, 0xbf, 0x75, 0xa1, 0x66, 0x19, 0x77, 0x9b, 0x0e, 0xb1, 0x9b, 0x24, 0xf4, 0x07, 0x55, 0xe1, - 0xad, 0xa5, 0x95, 0xcf, 0x02, 0xca, 0x7c, 0x24, 0x23, 0x03, 0xe7, 0xdc, 0xd8, 0x9e, 0x76, 0x5e, 0x9a, 0x31, 0x2f, - 0x15, 0x5a, 0x66, 0xf2, 0x6e, 0xd5, 0xc0, 0xb3, 0xf6, 0xbf, 0x9b, 0xe3, 0xc4, 0x86, 0xe6, 0xb1, 0x1d, 0x73, 0xb4, - 0xbd, 0x18, 0xf7, 0x2d, 0xfb, 0xea, 0xe5, 0x32, 0x2e, 0x9b, 0x67, 0xbd, 0x5b, 0xbb, 0x55, 0xec, 0xa7, 0x88, 0x0a, - 0x9b, 0xc2, 0x64, 0xaa, 0x49, 0x0c, 0x83, 0xc0, 0x68, 0x01, 0xec, 0x4d, 0x34, 0xc3, 0x2e, 0xe6, 0xa0, 0xb9, 0x34, - 0xeb, 0x6e, 0xf6, 0x38, 0x7d, 0x9b, 0xf9, 0x4a, 0xd5, 0x5e, 0x55, 0xa3, 0x44, 0xce, 0xe9, 0xb0, 0x7f, 0x29, 0xed, - 0x3f, 0x8a, 0xbc, 0xa9, 0x61, 0x2c, 0x0e, 0x44, 0x63, 0x01, 0xc1, 0x65, 0x7a, 0xab, 0xcd, 0xb2, 0x08, 0xc9, 0xa9, - 0x15, 0xe5, 0x1f, 0x34, 0x80, 0x54, 0x5c, 0xad, 0x16, 0x37, 0xe3, 0x58, 0x70, 0x8c, 0x4a, 0x6d, 0x0c, 0x4f, 0xff, - 0x24, 0x1e, 0x52, 0xd1, 0x56, 0x97, 0x13, 0xcd, 0x4b, 0xb5, 0xe5, 0x10, 0x40, 0x20, 0x57, 0x1b, 0xd6, 0x38, 0xf4, - 0x57, 0x27, 0x73, 0x23, 0xd3, 0x61, 0x66, 0xaa, 0xc0, 0xf8, 0x5b, 0x45, 0x53, 0x30, 0x39, 0x17, 0x49, 0xcc, 0xdc, - 0xce, 0xc0, 0xb2, 0x06, 0xe8, 0x20, 0x7a, 0xc3, 0xb7, 0x93, 0x1f, 0xea, 0x4f, 0x2b, 0x8b, 0x22, 0x4e, 0x1d, 0x93, - 0xd3, 0xd7, 0x76, 0x50, 0x50, 0xab, 0xed, 0x5c, 0xc4, 0x6b, 0x9e, 0x13, 0x68, 0x5f, 0xf9, 0xd5, 0xec, 0xf4, 0xfa, - 0x85, 0xd3, 0xef, 0x90, 0x15, 0x48, 0x9d, 0xe2, 0x5f, 0xba, 0x32, 0xca, 0xd5, 0xce, 0x79, 0x36, 0xfd, 0xf2, 0x98, - 0x24, 0xdb, 0xc6, 0xbf, 0x46, 0x2e, 0x39, 0x20, 0xf9, 0x13, 0xe7, 0xc0, 0xc8, 0x16, 0xd3, 0x24, 0x61, 0xaa, 0xd7, - 0x24, 0xcd, 0x59, 0x58, 0xc7, 0x6e, 0x3a, 0xfe, 0x73, 0xec, 0xa2, 0x27, 0x91, 0x90, 0x5a, 0x6f, 0x69, 0xa4, 0x85, - 0x75, 0xef, 0x8c, 0x5c, 0xc8, 0xe6, 0xa1, 0x4c, 0x01, 0x19, 0xd3, 0xcd, 0xba, 0x4b, 0x25, 0x12, 0xb5, 0x60, 0x69, - 0x68, 0xb7, 0x93, 0xe1, 0x10, 0xb5, 0xf6, 0x91, 0xec, 0x54, 0xf4, 0x2e, 0x54, 0x85, 0xa1, 0x8e, 0xe4, 0x4b, 0x61, - 0x25, 0x16, 0x58, 0x7b, 0x29, 0xd7, 0x92, 0x05, 0x5d, 0x79, 0x79, 0x24, 0x14, 0xeb, 0x00, 0xb6, 0xd6, 0xa5, 0xd1, - 0x0d, 0xa0, 0x13, 0xc5, 0xc0, 0x75, 0xc8, 0x00, 0x94, 0x31, 0x85, 0xca, 0x2d, 0x2d, 0x2e, 0xb9, 0x16, 0xa5, 0x98, - 0x03, 0x52, 0xbf, 0xc6, 0xe0, 0x8c, 0xf9, 0xbd, 0x8f, 0x29, 0xc4, 0x91, 0x31, 0xbc, 0x6a, 0x49, 0xda, 0x32, 0xd7, - 0xd6, 0x8a, 0x69, 0x9d, 0x30, 0x75, 0x96, 0xfd, 0x34, 0xf8, 0xce, 0xbf, 0xa3, 0x8e, 0xb4, 0xbc, 0xc5, 0x91, 0x8a, - 0x70, 0x68, 0x7b, 0x62, 0x2e, 0x4c, 0x29, 0x3c, 0x66, 0xb7, 0x77, 0x84, 0x6e, 0x7a, 0x29, 0xe0, 0xb1, 0x70, 0x63, - 0x2a, 0x30, 0x8e, 0x1e, 0x3f, 0x14, 0x4e, 0x84, 0xe1, 0xd0, 0x54, 0x9d, 0xf0, 0x6e, 0x9a, 0x32, 0x0b, 0x72, 0x6a, - 0x24, 0x6c, 0x78, 0xb0, 0xee, 0x07, 0x50, 0x14, 0x09, 0x69, 0x16, 0x57, 0x8d, 0x26, 0x8a, 0xeb, 0x8a, 0x0b, 0xbb, - 0x2f, 0xc7, 0xf9, 0x45, 0x25, 0x0e, 0xdd, 0xb3, 0xaa, 0x63, 0x8b, 0xc4, 0x67, 0x53, 0x55, 0x46, 0x44, 0xd5, 0x7b, - 0x09, 0x81, 0xb9, 0xad, 0xa5, 0x1b, 0x7f, 0xec, 0x0a, 0x57, 0x06, 0x0f, 0x0c, 0x21, 0xd2, 0xf4, 0x6a, 0x5d, 0xa2, - 0xe4, 0xed, 0xea, 0x0f, 0xfb, 0x61, 0xfd, 0xc1, 0xd8, 0x64, 0x07, 0xb7, 0x0a, 0xa4, 0xcd, 0x39, 0xbf, 0x66, 0xa6, - 0xb5, 0x6c, 0xb5, 0x0f, 0x6a, 0x94, 0x07, 0x9b, 0xcb, 0x34, 0x14, 0xf3, 0x4f, 0xef, 0x0c, 0x1f, 0x9c, 0x70, 0x91, - 0xf8, 0x02, 0x12, 0x71, 0xd8, 0x9e, 0x3e, 0x3e, 0x52, 0xf9, 0x5b, 0x27, 0x54, 0xd8, 0x8d, 0x52, 0xb6, 0x83, 0xf2, - 0xbe, 0x3a, 0xdc, 0x13, 0x13, 0x35, 0xd8, 0x67, 0x97, 0xa5, 0xa3, 0x01, 0x92, 0x94, 0x26, 0xf6, 0x25, 0x8e, 0xf7, - 0xc5, 0x0c, 0xeb, 0x05, 0x22, 0x5e, 0x75, 0xb2, 0x14, 0x4a, 0xa6, 0xec, 0xf9, 0xec, 0x78, 0x1d, 0x64, 0xf2, 0x11, - 0x55, 0x1d, 0xd2, 0xdc, 0xd4, 0x72, 0x97, 0x13, 0x03, 0xdd, 0x6b, 0xd3, 0x9f, 0xdf, 0x37, 0x86, 0x6c, 0x2b, 0x91, - 0x6f, 0x7c, 0x7b, 0xd4, 0x3f, 0xbd, 0x7e, 0xa1, 0x21, 0xd9, 0x9b, 0x65, 0xec, 0x6e, 0x7f, 0xb8, 0x2c, 0xea, 0xa8, - 0xea, 0x07, 0x55, 0x30, 0x4b, 0xea, 0xa9, 0xe9, 0x2c, 0xa4, 0x04, 0x13, 0x0e, 0x04, 0x9c, 0xb5, 0x1e, 0x84, 0xaa, - 0xcb, 0xbf, 0xb6, 0x57, 0x57, 0xbb, 0xf1, 0x62, 0xe1, 0x69, 0x64, 0x23, 0x31, 0xd4, 0x61, 0xe9, 0x3b, 0xb3, 0x85, - 0xf0, 0x0c, 0xbf, 0xef, 0x6a, 0x24, 0x2e, 0x35, 0x00, 0x5f, 0x2f, 0xdf, 0x9d, 0xfb, 0xe1, 0xf0, 0x21, 0xb0, 0x17, - 0xcc, 0x8c, 0xf7, 0x59, 0x69, 0x8a, 0x25, 0x0d, 0x3f, 0x46, 0x36, 0xb3, 0xae, 0x7d, 0x12, 0x82, 0x08, 0xac, 0x21, - 0x42, 0x95, 0x87, 0x66, 0x0e, 0x65, 0xac, 0x1c, 0xab, 0x68, 0xed, 0xd9, 0x6f, 0x30, 0x25, 0xb2, 0xd9, 0x22, 0xa0, - 0x23, 0xfb, 0x7e, 0x79, 0x51, 0xcb, 0xf0, 0xba, 0x7f, 0x79, 0xf8, 0x22, 0x17, 0xb5, 0x59, 0x03, 0xf8, 0x3b, 0x92, - 0xd5, 0xb2, 0x37, 0x96, 0x5f, 0xe8, 0x14, 0x6c, 0xb5, 0x39, 0x30, 0x22, 0x92, 0x36, 0x8c, 0xb8, 0x20, 0x99, 0x33, - 0x31, 0x15, 0x42, 0x96, 0x1e, 0xf7, 0xf1, 0x32, 0x05, 0xc0, 0xe9, 0x72, 0x65, 0xc4, 0x05, 0x81, 0x90, 0x8e, 0xc3, - 0x98, 0x16, 0xd2, 0xb2, 0x9e, 0xed, 0x42, 0xb3, 0x51, 0xa3, 0xd0, 0x35, 0x87, 0x44, 0x8d, 0x99, 0x75, 0x8f, 0x43, - 0x5c, 0x6a, 0x3b, 0x21, 0x2b, 0xbf, 0xb9, 0x9a, 0x01, 0xd0, 0x98, 0x48, 0x2e, 0x97, 0xc3, 0x44, 0x96, 0x98, 0xcf, - 0x98, 0xb4, 0xe9, 0xeb, 0xc3, 0x37, 0x31, 0x3d, 0x43, 0xec, 0x1a, 0xeb, 0x0f, 0xd1, 0xf2, 0xdc, 0x8b, 0x10, 0xd4, - 0xba, 0x6c, 0xd9, 0xa3, 0x68, 0x2b, 0x64, 0xa2, 0x6d, 0x49, 0xd8, 0x02, 0x0d, 0xec, 0x33, 0x9e, 0x0d, 0x97, 0x83, - 0x28, 0x4b, 0x40, 0x6a, 0x29, 0x87, 0xfc, 0x1a, 0xed, 0x11, 0x62, 0x0c, 0x16, 0xac, 0x81, 0xe5, 0xbe, 0xe1, 0x30, - 0x0a, 0x12, 0xec, 0x81, 0xff, 0xbf, 0x20, 0x96, 0xab, 0x6f, 0x27, 0x7b, 0x5e, 0x57, 0x25, 0xda, 0x06, 0x03, 0xe0, - 0xa0, 0xe3, 0x11, 0x06, 0x8d, 0x6b, 0x1a, 0xa8, 0xae, 0x27, 0x97, 0x0b, 0x33, 0x36, 0x55, 0x90, 0x7a, 0x06, 0xdc, - 0x12, 0x6e, 0xfb, 0x59, 0xc6, 0x1c, 0x0c, 0x6c, 0x9c, 0xdd, 0x8d, 0xed, 0x1a, 0x43, 0xf0, 0xe8, 0x04, 0xed, 0x74, - 0xa7, 0x84, 0x3c, 0xaf, 0x1f, 0xad, 0xd5, 0xb0, 0xc3, 0xe7, 0xad, 0x69, 0xcf, 0x23, 0xcc, 0x88, 0xb8, 0x69, 0xba, - 0x60, 0x63, 0x29, 0xc1, 0x52, 0xa4, 0x88, 0x01, 0x6c, 0x47, 0xd9, 0x0d, 0x80, 0x16, 0xd8, 0x1f, 0xca, 0x6b, 0x8d, - 0x1e, 0x3d, 0x1b, 0x3e, 0xc7, 0xa8, 0xea, 0x32, 0x87, 0x91, 0x7a, 0xee, 0x50, 0x37, 0x1e, 0x78, 0x7e, 0xaa, 0xd6, - 0x28, 0x14, 0x8a, 0x25, 0x70, 0xf4, 0xf3, 0x7d, 0x1a, 0x89, 0x67, 0x99, 0x21, 0xec, 0xe4, 0x66, 0xf3, 0x04, 0xc4, - 0x3e, 0x34, 0x32, 0x21, 0x80, 0x10, 0x2c, 0x84, 0xd5, 0x1e, 0x50, 0xce, 0xdf, 0x13, 0xf6, 0x7d, 0x44, 0xc7, 0x4d, - 0x80, 0x07, 0x53, 0x50, 0x9c, 0xac, 0x7d, 0x2a, 0x22, 0x52, 0xf9, 0x49, 0x92, 0x6c, 0xc6, 0x49, 0x9d, 0x04, 0x66, - 0x47, 0x9c, 0x92, 0xa5, 0x58, 0x38, 0x2f, 0x9e, 0x70, 0x60, 0xd3, 0x35, 0x05, 0x4c, 0x27, 0xbe, 0xc8, 0x49, 0xd9, - 0x0c, 0x5a, 0x38, 0x1f, 0xe7, 0xb6, 0x8d, 0x05, 0x47, 0x65, 0x19, 0x3b, 0x7b, 0xab, 0xc6, 0x08, 0x1d, 0xf6, 0x4d, - 0x82, 0x7a, 0x3f, 0xa6, 0xb0, 0x76, 0xda, 0xe3, 0x23, 0x26, 0xc1, 0xa1, 0x42, 0xe8, 0x26, 0xa8, 0x59, 0xa5, 0x3f, - 0xea, 0x8e, 0x39, 0x35, 0x92, 0xa4, 0x3c, 0x2e, 0x37, 0x24, 0xa9, 0x93, 0x7d, 0xf6, 0x68, 0x4f, 0x1e, 0x28, 0x9c, - 0x26, 0x3c, 0xd1, 0x95, 0x02, 0x06, 0xc1, 0x8b, 0x04, 0xbb, 0xba, 0x2c, 0x14, 0xc9, 0x40, 0x16, 0x43, 0xbb, 0x01, - 0x67, 0x57, 0xe6, 0x94, 0x84, 0x7c, 0xe6, 0x0b, 0x9e, 0xd9, 0x6e, 0x86, 0xe8, 0x26, 0x5b, 0xd4, 0x90, 0x51, 0x30, - 0xb4, 0x5b, 0x28, 0x22, 0x74, 0xeb, 0xc2, 0xdf, 0xe1, 0x0f, 0xcf, 0x52, 0xd9, 0x5c, 0x70, 0x9d, 0x2e, 0xbc, 0xc6, - 0x5f, 0x7a, 0xd6, 0x8a, 0x9d, 0x6f, 0xad, 0x9d, 0x4b, 0x96, 0x8b, 0x5e, 0xf3, 0x1f, 0xb9, 0xc7, 0x05, 0x3a, 0xb1, - 0x05, 0xd1, 0x86, 0x26, 0xa8, 0x0c, 0xa7, 0x81, 0x0b, 0x0f, 0x14, 0x52, 0x7b, 0x1c, 0x96, 0xb2, 0x45, 0xf4, 0x93, - 0x79, 0xae, 0xae, 0xc1, 0x22, 0x31, 0x6b, 0xa5, 0xe8, 0x45, 0x53, 0xa1, 0x88, 0x8c, 0xae, 0x06, 0xa2, 0x54, 0x97, - 0x43, 0x9a, 0x02, 0x91, 0x53, 0x92, 0x78, 0x25, 0x73, 0x06, 0x45, 0x3e, 0xe8, 0x45, 0xff, 0x8b, 0x13, 0x51, 0x0f, - 0xf9, 0xfc, 0x27, 0x55, 0x3e, 0xcb, 0xa2, 0x7e, 0x14, 0x76, 0x7d, 0x19, 0x9b, 0x6c, 0x18, 0x03, 0x18, 0x34, 0xcc, - 0x21, 0xbb, 0x18, 0xd9, 0xaa, 0x76, 0xdd, 0x0c, 0x92, 0x73, 0x43, 0x7e, 0x36, 0x73, 0xc0, 0xfc, 0xfe, 0x5b, 0x28, - 0x1b, 0xbc, 0xc4, 0x8c, 0xc3, 0x7d, 0xe4, 0x27, 0x6f, 0x22, 0x0b, 0xfe, 0x70, 0x1a, 0x3a, 0x40, 0xd3, 0x21, 0xd4, - 0xe6, 0x8a, 0x09, 0x33, 0x03, 0x9b, 0xb2, 0x20, 0xa6, 0x45, 0x4f, 0x89, 0x1a, 0xff, 0xbd, 0x7f, 0xd6, 0x00, 0x34, - 0x7b, 0xe4, 0xcf, 0xd6, 0xe8, 0x40, 0xb7, 0xea, 0xd2, 0x47, 0xf7, 0x26, 0x99, 0x06, 0x00, 0x97, 0xdb, 0xeb, 0xb5, - 0xd8, 0x6e, 0xa7, 0x55, 0xc8, 0x3e, 0x98, 0xe1, 0xc6, 0xf1, 0x94, 0x9c, 0xb7, 0x29, 0x1b, 0x0b, 0x84, 0xa7, 0xcc, - 0x0a, 0x12, 0xbb, 0x6f, 0xdd, 0xb3, 0xb2, 0x7f, 0x8c, 0xff, 0xa5, 0xf1, 0xcb, 0x22, 0x3f, 0xdf, 0x6e, 0xa5, 0x12, - 0x78, 0xa5, 0x9f, 0xd1, 0x7b, 0x17, 0xc0, 0x72, 0x07, 0x91, 0x8c, 0x96, 0xf7, 0xd4, 0xa2, 0xea, 0xa9, 0x5f, 0x64, - 0xab, 0x71, 0xe3, 0xc4, 0x8e, 0xf2, 0xe6, 0xf3, 0x82, 0x8d, 0x40, 0xc5, 0xc3, 0x6b, 0x46, 0x98, 0xfe, 0x7d, 0x32, - 0x71, 0xea, 0x1d, 0x3b, 0x7b, 0x8f, 0x20, 0xeb, 0x89, 0xed, 0xdb, 0xb3, 0x2c, 0xfe, 0x1f, 0x8b, 0x93, 0x75, 0x02, - 0x4f, 0x0d, 0x82, 0xac, 0xfb, 0xcc, 0x0b, 0x2b, 0x40, 0x65, 0xf7, 0x28, 0xe3, 0xcb, 0xc3, 0xd0, 0x7f, 0xfd, 0xcc, - 0x19, 0x35, 0xba, 0x70, 0x8a, 0xe1, 0x9c, 0xa2, 0x31, 0x84, 0xe3, 0x8f, 0x4f, 0x27, 0xbd, 0xb8, 0x67, 0xfc, 0xa7, - 0x49, 0x2f, 0xac, 0xea, 0x35, 0x6d, 0x48, 0x1c, 0xff, 0xb0, 0xf9, 0x9b, 0x45, 0x1e, 0xec, 0x7c, 0xb5, 0x42, 0x8a, - 0xac, 0x0b, 0xa9, 0x4e, 0xab, 0x56, 0x55, 0x17, 0x03, 0xce, 0xd9, 0x1f, 0x8b, 0x97, 0x3a, 0xbb, 0x5f, 0xf4, 0x3f, - 0x9a, 0x79, 0x4d, 0xeb, 0xa3, 0x0f, 0xee, 0xa6, 0x50, 0x35, 0xfb, 0x19, 0xdd, 0x3b, 0xbd, 0xa3, 0x9c, 0xb2, 0x99, - 0x4b, 0x7c, 0xee, 0xab, 0xa5, 0xe7, 0x09, 0xb7, 0x16, 0x1a, 0x99, 0xa1, 0x3b, 0x75, 0x8f, 0xe0, 0x52, 0x24, 0x4d, - 0xcb, 0xde, 0xc2, 0x35, 0x13, 0xe9, 0x4c, 0x7f, 0x76, 0x92, 0xd2, 0x9b, 0xce, 0x67, 0x35, 0x45, 0xcc, 0xaf, 0x88, - 0x99, 0x71, 0x96, 0x04, 0x4f, 0x21, 0x22, 0xd0, 0xda, 0x8a, 0xf2, 0xa9, 0xa2, 0xba, 0xe2, 0x57, 0xbf, 0x9e, 0x65, - 0x81, 0x9f, 0x99, 0x4d, 0x75, 0x2b, 0x57, 0xf4, 0xd1, 0x69, 0x9e, 0xe5, 0x3a, 0x76, 0x20, 0x67, 0x1b, 0xe0, 0xc0, - 0xfe, 0x4d, 0x47, 0x30, 0xac, 0xad, 0xb9, 0x3f, 0x12, 0xbd, 0x31, 0x0a, 0xfe, 0x42, 0x00, 0x46, 0xa4, 0x68, 0xc3, - 0x3e, 0xda, 0x42, 0x17, 0x32, 0xaa, 0xf7, 0x27, 0x6e, 0xff, 0xbc, 0x71, 0xbd, 0xf3, 0x6b, 0xa7, 0x35, 0xa7, 0x54, - 0xe6, 0xe9, 0x74, 0xb4, 0x91, 0xdd, 0xf5, 0xb0, 0x0c, 0xf2, 0x5b, 0xbe, 0xd0, 0xe8, 0xc5, 0x2f, 0x1d, 0x6c, 0x69, - 0xf9, 0x11, 0xa9, 0x7a, 0x92, 0x08, 0xe4, 0x58, 0xcb, 0xc3, 0xab, 0xb9, 0x23, 0x95, 0x0a, 0x1c, 0xd5, 0x3d, 0x19, - 0xf9, 0x66, 0x4e, 0xd9, 0xb5, 0xa4, 0x1d, 0xc1, 0xc6, 0xb0, 0x6c, 0xbe, 0xe6, 0xd2, 0x2c, 0xb5, 0x5e, 0xd9, 0xb3, - 0x13, 0xe1, 0x05, 0x8b, 0x57, 0x62, 0x9b, 0x82, 0xcb, 0xaf, 0xc6, 0x92, 0xb9, 0x79, 0x3d, 0x91, 0x80, 0x59, 0xe6, - 0xd2, 0x6e, 0xf2, 0x19, 0xe9, 0x4a, 0xfd, 0x39, 0x2c, 0x4c, 0x9f, 0x7c, 0x63, 0x31, 0x41, 0xdb, 0xaa, 0x55, 0xb9, - 0xf2, 0x1c, 0xdf, 0xd0, 0xa4, 0xd8, 0x3b, 0xda, 0x33, 0xe9, 0x21, 0x1c, 0x89, 0xc1, 0xcd, 0xbc, 0xa5, 0x92, 0x32, - 0x8d, 0x63, 0x27, 0x49, 0xff, 0x55, 0x5f, 0x86, 0x49, 0x82, 0x83, 0x58, 0xfd, 0x07, 0xd5, 0x98, 0x01, 0x87, 0xd4, - 0x47, 0x27, 0x2a, 0x82, 0xd1, 0x4c, 0x21, 0xba, 0x41, 0xfd, 0x4a, 0x9d, 0x88, 0x67, 0x2f, 0x56, 0x38, 0xe9, 0xcb, - 0x1c, 0x69, 0x5e, 0xf8, 0x8e, 0xdd, 0x3e, 0x32, 0x80, 0x46, 0x61, 0x6e, 0x8c, 0x81, 0x5d, 0xd6, 0xa4, 0x2d, 0x05, - 0x37, 0x7a, 0x03, 0x4d, 0xe0, 0xe6, 0x3d, 0x9d, 0x85, 0x3e, 0x17, 0xe9, 0xc4, 0xe2, 0x8e, 0x76, 0x31, 0xb9, 0xd6, - 0x7c, 0x5d, 0xb0, 0x0b, 0xf9, 0xbb, 0xb9, 0x56, 0xde, 0xb6, 0x69, 0x2e, 0x54, 0x20, 0xc8, 0x51, 0xe0, 0x94, 0xcb, - 0x7b, 0xa2, 0x46, 0xc7, 0xc1, 0xeb, 0xd4, 0x86, 0xd2, 0x1f, 0xf8, 0x75, 0x10, 0x88, 0xce, 0x7e, 0xd0, 0xa6, 0xdf, - 0xb7, 0x54, 0x85, 0x59, 0xd4, 0x43, 0x2c, 0x89, 0x49, 0x77, 0x77, 0xeb, 0xa3, 0x8e, 0xcf, 0xea, 0x1a, 0xb7, 0xf0, - 0x12, 0x83, 0x2b, 0x38, 0x42, 0xab, 0x58, 0x48, 0x9e, 0x81, 0x4f, 0xb7, 0xb0, 0xf1, 0x63, 0xe6, 0x6e, 0x47, 0xe4, - 0xfe, 0xea, 0x7d, 0xc5, 0x91, 0xdd, 0x62, 0xac, 0x9e, 0x3c, 0x45, 0xec, 0x1d, 0xad, 0x32, 0xc3, 0x95, 0x6b, 0xde, - 0x2b, 0xdc, 0xf6, 0x9e, 0x4f, 0xf1, 0xc0, 0x0c, 0x02, 0x7b, 0x46, 0xcc, 0x8e, 0xb1, 0x7e, 0x6d, 0xd8, 0xdb, 0xbe, - 0x73, 0x5d, 0x0a, 0x18, 0xb5, 0x2e, 0xe8, 0x83, 0x20, 0xbe, 0xcf, 0x0c, 0x58, 0x7b, 0x0e, 0xcc, 0xde, 0xe8, 0x8e, - 0xdb, 0x24, 0xec, 0x4a, 0x7d, 0x3c, 0x3e, 0x64, 0xbd, 0x2b, 0x3d, 0x2a, 0x45, 0x1f, 0x05, 0x2e, 0x9a, 0x00, 0x31, - 0x07, 0x47, 0xb2, 0x17, 0x7b, 0xf2, 0x89, 0x98, 0x0b, 0x91, 0x8b, 0x66, 0xb8, 0x07, 0x04, 0x23, 0x87, 0x15, 0xb6, - 0xff, 0x88, 0xd2, 0x86, 0x87, 0x5b, 0x2c, 0x64, 0x98, 0xf3, 0x1a, 0xd7, 0xdd, 0xfd, 0x3b, 0x60, 0xce, 0x5d, 0xbd, - 0x45, 0xdf, 0xe9, 0x31, 0x28, 0xbd, 0x4f, 0x83, 0xa8, 0x55, 0xe4, 0x1e, 0x5e, 0x84, 0xf0, 0xba, 0xc8, 0x8b, 0x46, - 0x20, 0xdd, 0x1d, 0x86, 0xe1, 0x57, 0x10, 0x31, 0x7d, 0x2d, 0x01, 0x7f, 0xa2, 0x30, 0x10, 0x0b, 0x5e, 0x6e, 0xaa, - 0x4a, 0x5d, 0xd9, 0x7a, 0x0c, 0xb5, 0xf0, 0x0c, 0xac, 0xaa, 0x93, 0x8c, 0xe0, 0x6e, 0x73, 0x96, 0x32, 0xbf, 0xad, - 0xc8, 0x8f, 0x65, 0x5d, 0x1c, 0xd2, 0xa6, 0xbd, 0x8a, 0xdf, 0x32, 0xec, 0x05, 0x10, 0xa3, 0x2a, 0x33, 0x53, 0x25, - 0x22, 0x5f, 0x17, 0xa4, 0x8a, 0x94, 0x3d, 0x4b, 0xb6, 0x57, 0xf4, 0x57, 0xaf, 0xd8, 0x12, 0x67, 0xb6, 0x25, 0x27, - 0xfc, 0x54, 0x4d, 0xe2, 0xf9, 0xaf, 0xf2, 0xce, 0xfd, 0x6d, 0xfa, 0xfe, 0x7c, 0x98, 0xc4, 0x59, 0x2e, 0xe9, 0xba, - 0xb5, 0xb8, 0xf8, 0xa4, 0xf5, 0xb7, 0xab, 0x3d, 0x6a, 0xdf, 0xad, 0xe5, 0xf4, 0x76, 0xe4, 0x9a, 0xf9, 0x12, 0xd2, - 0xac, 0xf5, 0xe1, 0x24, 0x7f, 0x95, 0x61, 0x97, 0x37, 0x7a, 0xd0, 0xb4, 0x64, 0xfa, 0xe2, 0xe7, 0x8a, 0x6d, 0x19, - 0xba, 0x12, 0xbd, 0xf3, 0xd3, 0x17, 0xe3, 0xae, 0x11, 0xb3, 0x35, 0x90, 0x3c, 0x61, 0x5e, 0x44, 0x63, 0xcf, 0x8d, - 0x05, 0x02, 0xbd, 0x4f, 0xfb, 0x16, 0xcc, 0xd2, 0x6f, 0x9c, 0x28, 0xb9, 0x4f, 0xb0, 0x3f, 0xd2, 0x22, 0x18, 0xb8, - 0x73, 0x57, 0xbd, 0xe0, 0x38, 0x0b, 0x7d, 0xd4, 0xb5, 0xdc, 0x17, 0x31, 0x72, 0x9b, 0xe3, 0xf4, 0x6e, 0x29, 0x99, - 0x08, 0xfb, 0xc5, 0x53, 0xce, 0xac, 0xef, 0x7e, 0x99, 0x25, 0xad, 0xd5, 0x02, 0xfd, 0x8a, 0xab, 0xe7, 0x6e, 0xfd, - 0x27, 0x10, 0xbd, 0x9f, 0x76, 0x58, 0x2c, 0xad, 0xd4, 0x9d, 0xaa, 0xd2, 0x37, 0x78, 0x52, 0x06, 0xc8, 0x59, 0x40, - 0x67, 0xda, 0x5a, 0xee, 0x16, 0x46, 0xfd, 0xa5, 0xc7, 0xb9, 0xfe, 0xde, 0xca, 0x18, 0x1c, 0x42, 0xb4, 0xfd, 0x0a, - 0xe7, 0x71, 0x7b, 0x25, 0x5e, 0x0b, 0xaf, 0x28, 0x34, 0x5b, 0x1e, 0xbf, 0x54, 0x30, 0x89, 0x7e, 0x12, 0x91, 0x3b, - 0x3f, 0x5b, 0xb3, 0x30, 0x31, 0x9f, 0xce, 0x2d, 0xbf, 0x47, 0xa7, 0xe6, 0x02, 0x5a, 0xee, 0xf9, 0x81, 0x8b, 0xf9, - 0x3f, 0xcb, 0x2c, 0x4b, 0x6a, 0x85, 0x66, 0xd9, 0x36, 0xc0, 0xd1, 0x0d, 0x4f, 0x71, 0xe3, 0x39, 0x0e, 0x28, 0xb4, - 0x83, 0x52, 0x6f, 0xb5, 0x40, 0x8d, 0x14, 0x61, 0xa1, 0xa0, 0x90, 0x7e, 0x44, 0xf3, 0x28, 0x3b, 0x62, 0xc0, 0x48, - 0xb7, 0xfa, 0x9b, 0x5c, 0x5b, 0x64, 0x45, 0xab, 0xfd, 0xb2, 0x7c, 0xbf, 0x2f, 0x82, 0xe8, 0xbf, 0x5d, 0x80, 0x22, - 0xd6, 0x86, 0xec, 0x4d, 0xc0, 0x34, 0xa2, 0x98, 0xa2, 0xe0, 0xdb, 0x80, 0xa4, 0x50, 0x29, 0x7b, 0x17, 0xb6, 0x08, - 0x33, 0x97, 0x5a, 0x52, 0xc6, 0x98, 0x78, 0xde, 0x00, 0x74, 0xa4, 0xff, 0xda, 0xf8, 0x2e, 0x3b, 0x33, 0x1e, 0x26, - 0xe5, 0x1e, 0x11, 0x91, 0xa0, 0x9e, 0xca, 0x4a, 0xc0, 0x7e, 0xb3, 0x29, 0xbe, 0x15, 0x94, 0xa4, 0x49, 0xed, 0x45, - 0xb0, 0xdb, 0x86, 0x0c, 0x2e, 0xa3, 0xb5, 0x86, 0x82, 0x86, 0xef, 0x0d, 0xe3, 0x01, 0xab, 0x5c, 0xf4, 0x12, 0x9b, - 0xfc, 0x08, 0x9e, 0xa9, 0xe8, 0x2e, 0xdf, 0xa2, 0x8f, 0x77, 0x54, 0xe6, 0x65, 0xa7, 0x75, 0xed, 0xdd, 0x81, 0x41, - 0x18, 0x36, 0x3e, 0x35, 0xd0, 0x91, 0xbe, 0x1e, 0xb0, 0x41, 0xf3, 0x78, 0x86, 0x0d, 0x38, 0xa5, 0x2b, 0x32, 0x5a, - 0xe7, 0x23, 0xcb, 0x17, 0x7b, 0xfc, 0x3e, 0x1a, 0x21, 0x63, 0xe2, 0x08, 0xec, 0xa8, 0x01, 0x1e, 0x12, 0x66, 0x08, - 0x3f, 0xf6, 0x0e, 0xf6, 0xb5, 0x81, 0xff, 0x4a, 0x13, 0x50, 0x40, 0x8e, 0xf6, 0xb8, 0x90, 0x54, 0x3c, 0x86, 0x19, - 0x83, 0xc2, 0x87, 0x64, 0x28, 0x73, 0xfc, 0xef, 0xbb, 0x92, 0x62, 0xcd, 0x70, 0x57, 0x8c, 0x4c, 0x1b, 0xee, 0xbe, - 0x6b, 0xcc, 0x6f, 0xe9, 0xde, 0x51, 0x14, 0x3d, 0x1d, 0x03, 0x0f, 0xa1, 0x14, 0xa1, 0xec, 0xcc, 0x84, 0x2a, 0x00, - 0xfd, 0xa2, 0x19, 0x6d, 0x40, 0xeb, 0xc7, 0xc8, 0x1d, 0xdf, 0x5e, 0xc1, 0xc9, 0x45, 0xa2, 0xc0, 0xba, 0xf8, 0xfa, - 0x97, 0x4a, 0x7a, 0xef, 0xde, 0x25, 0x5b, 0xe5, 0xca, 0x9c, 0xda, 0xe2, 0xa1, 0x0b, 0xbe, 0x4c, 0xd7, 0xc7, 0xde, - 0xcb, 0x13, 0xa4, 0xa6, 0x61, 0xb5, 0x8e, 0x6d, 0xc2, 0x93, 0x16, 0xbb, 0xe4, 0xed, 0xfc, 0xe5, 0x49, 0x36, 0xf1, - 0x8a, 0xa5, 0x40, 0xa7, 0x67, 0x56, 0xc5, 0x36, 0xd2, 0xd3, 0x65, 0xc3, 0x67, 0x06, 0xf8, 0x3c, 0x1b, 0xc8, 0x3d, - 0xcf, 0xf5, 0xe7, 0xfa, 0xed, 0x92, 0x87, 0x84, 0x92, 0xdd, 0xd6, 0x38, 0xbd, 0x6b, 0x6c, 0x33, 0x1f, 0xcd, 0xdc, - 0x3e, 0xb6, 0x3e, 0xf3, 0x91, 0xc9, 0xd2, 0x05, 0x25, 0x61, 0x7b, 0x3c, 0x24, 0x9d, 0x6c, 0xb2, 0xe0, 0xcc, 0xa9, - 0x2f, 0x91, 0xcb, 0xe2, 0xbc, 0xae, 0x34, 0x17, 0x36, 0x2b, 0xe8, 0x32, 0x80, 0x53, 0x9d, 0x3a, 0x09, 0xae, 0x2a, - 0x02, 0xa7, 0xa6, 0x66, 0xaa, 0x28, 0x9e, 0xb2, 0x66, 0xbb, 0x39, 0x51, 0xfd, 0x14, 0x2d, 0x2e, 0x75, 0x2a, 0x4a, - 0xd4, 0x4c, 0xb6, 0xcc, 0x14, 0xc8, 0x64, 0x51, 0xa4, 0x39, 0x89, 0x15, 0x0e, 0xfa, 0x9e, 0x53, 0x24, 0x7b, 0xd1, - 0x6e, 0x3e, 0x5e, 0xd9, 0x5a, 0xb2, 0xc2, 0x68, 0x66, 0xab, 0x79, 0x76, 0x22, 0x15, 0xdb, 0x07, 0xca, 0xa1, 0x70, - 0xdf, 0x26, 0xb0, 0x52, 0x23, 0xe5, 0xa5, 0xa8, 0x23, 0x35, 0x3c, 0xc5, 0x5f, 0x9b, 0x6e, 0x88, 0xd1, 0x6c, 0xd8, - 0xd1, 0x46, 0xb3, 0xd9, 0x0c, 0x8a, 0x4d, 0x8d, 0x43, 0xab, 0xd4, 0x74, 0x1b, 0x91, 0xaf, 0x50, 0x35, 0xb2, 0x6f, - 0xac, 0x2c, 0x88, 0x25, 0x73, 0x88, 0xd7, 0x50, 0x98, 0x24, 0xf7, 0x28, 0xb6, 0xe8, 0xf5, 0xa2, 0xcd, 0xcd, 0x91, - 0x63, 0x43, 0x76, 0xae, 0xe2, 0x5c, 0xa6, 0x2b, 0x91, 0x47, 0x81, 0x50, 0x58, 0x89, 0xa4, 0x04, 0x93, 0x31, 0x4f, - 0xdf, 0xf8, 0x29, 0xe9, 0xb9, 0x47, 0x40, 0x34, 0xfb, 0x82, 0x6a, 0x45, 0x7d, 0x11, 0x23, 0x3e, 0x92, 0x90, 0x63, - 0xf8, 0x8a, 0x61, 0xf8, 0xde, 0xa6, 0xa2, 0xff, 0x6a, 0xe7, 0x53, 0x13, 0x65, 0x72, 0x54, 0xed, 0x10, 0x69, 0x03, - 0xb1, 0x35, 0x40, 0x3c, 0x4d, 0xc7, 0x12, 0x94, 0x46, 0x8f, 0xc1, 0xce, 0xe7, 0xe5, 0x69, 0x27, 0xd4, 0xe2, 0x48, - 0x77, 0x99, 0x9b, 0x00, 0x67, 0xfd, 0x30, 0xbd, 0x4d, 0xcc, 0xee, 0xfe, 0xcc, 0x01, 0xdd, 0x89, 0x71, 0x84, 0x8f, - 0x66, 0x97, 0x55, 0x08, 0x4f, 0xfc, 0x3b, 0xaf, 0xda, 0x94, 0x84, 0x13, 0xe2, 0x8d, 0x63, 0x03, 0x98, 0xce, 0xb4, - 0xa7, 0x6a, 0x39, 0x10, 0x29, 0x7e, 0x0d, 0xbe, 0xc1, 0x95, 0xd0, 0xa0, 0x20, 0x51, 0x3f, 0x8f, 0x5c, 0x13, 0x53, - 0x3d, 0xce, 0x7f, 0x44, 0x28, 0x03, 0x83, 0x04, 0x32, 0x2a, 0xd8, 0x3d, 0x6f, 0x8d, 0x28, 0xd6, 0x7a, 0xd2, 0xb2, - 0xcb, 0x99, 0xeb, 0x36, 0xb5, 0x33, 0x7b, 0xdf, 0x0a, 0x0e, 0x04, 0xfd, 0xe5, 0x56, 0xa6, 0x1f, 0x01, 0x06, 0xc3, - 0xac, 0x30, 0xff, 0x89, 0x0c, 0x9a, 0x2b, 0x64, 0xd4, 0x5d, 0x77, 0xd5, 0x3b, 0xc1, 0xd8, 0x99, 0x8c, 0x23, 0x9f, - 0xfc, 0x3c, 0x70, 0xf7, 0xad, 0x48, 0x35, 0x9e, 0xb9, 0x8d, 0x91, 0x4f, 0x26, 0x81, 0xd9, 0xb6, 0x6e, 0x54, 0x53, - 0x26, 0x38, 0x12, 0x31, 0x95, 0x7e, 0x73, 0x1f, 0xb7, 0xe1, 0x59, 0x7e, 0xf0, 0xdf, 0x6f, 0xd3, 0xc4, 0xb9, 0x17, - 0x76, 0x61, 0xba, 0x89, 0x37, 0x0e, 0xba, 0xdf, 0xb5, 0x8f, 0xe6, 0x1a, 0x0f, 0x53, 0x91, 0xd4, 0x76, 0xa2, 0xce, - 0x47, 0xea, 0xe1, 0x35, 0x9d, 0x9f, 0x49, 0xb3, 0xce, 0xf5, 0x9f, 0xaa, 0x0e, 0x06, 0xfd, 0x15, 0x73, 0xb6, 0x45, - 0xbc, 0xd7, 0x9e, 0x6b, 0x29, 0xbc, 0x83, 0xaf, 0xcc, 0xb9, 0x15, 0xf4, 0x2b, 0x17, 0x95, 0x67, 0xaf, 0x49, 0xd7, - 0x78, 0x52, 0x56, 0x13, 0x36, 0xf5, 0x20, 0x4e, 0xf9, 0xab, 0xe0, 0x18, 0xa0, 0x37, 0x54, 0x8d, 0x91, 0xb2, 0x8b, - 0xf7, 0xd5, 0xc0, 0x99, 0x0a, 0xf1, 0x8f, 0x82, 0xa1, 0x51, 0xda, 0x96, 0xea, 0x18, 0x5b, 0xef, 0x31, 0x8f, 0x47, - 0x95, 0xcb, 0xea, 0x09, 0x0b, 0x4e, 0x9d, 0x9d, 0xdf, 0xfd, 0x88, 0x6b, 0x1e, 0x60, 0x9d, 0xd5, 0xfe, 0x0a, 0x9c, - 0xd7, 0xfe, 0x33, 0xdd, 0x7c, 0x28, 0xba, 0x27, 0x5a, 0x6f, 0xe6, 0xde, 0xf3, 0x6c, 0xd6, 0x9f, 0xef, 0x45, 0x68, - 0x35, 0x5c, 0x67, 0x7c, 0x7a, 0xcb, 0xef, 0x40, 0x67, 0x3b, 0xe8, 0x1a, 0xef, 0x2b, 0xcd, 0x7b, 0x3b, 0x0b, 0x56, - 0xaa, 0xa8, 0x75, 0x8e, 0x1d, 0xba, 0xd6, 0x78, 0x3c, 0xb8, 0xc8, 0xa4, 0xb1, 0x3a, 0x59, 0x79, 0x68, 0x85, 0xca, - 0xd7, 0x8b, 0xb8, 0x63, 0x27, 0xd1, 0xcd, 0xb2, 0x11, 0x25, 0x12, 0xe4, 0x6f, 0x83, 0x42, 0x31, 0x1c, 0x32, 0xe1, - 0x61, 0xdc, 0x9b, 0x08, 0x61, 0x5e, 0x4b, 0xb9, 0x10, 0xab, 0x1d, 0x5e, 0xaf, 0xd0, 0x23, 0xe0, 0x60, 0x49, 0x95, - 0xb4, 0x91, 0x88, 0xba, 0x94, 0x7d, 0x58, 0xdd, 0xfe, 0x50, 0x2f, 0xee, 0xca, 0x5f, 0xd5, 0xb6, 0x66, 0xd1, 0xfc, - 0x8b, 0x12, 0x8e, 0x95, 0x08, 0x9b, 0x29, 0xb6, 0x75, 0xf4, 0x7f, 0x44, 0x85, 0x0e, 0x9d, 0x0b, 0x80, 0xda, 0x0f, - 0x95, 0x05, 0x8a, 0x62, 0x04, 0x68, 0x3f, 0xa9, 0xb2, 0x90, 0x7a, 0xc7, 0x1f, 0xcc, 0xae, 0x5b, 0x86, 0x2c, 0x17, - 0xc1, 0x58, 0x9d, 0x6d, 0x00, 0x08, 0xab, 0x4e, 0x60, 0x02, 0x51, 0x34, 0x8a, 0xb2, 0x29, 0x37, 0xd8, 0x2d, 0x5e, - 0x41, 0xb4, 0xfa, 0xfa, 0x4c, 0xf4, 0x8c, 0xac, 0xa4, 0x2a, 0x59, 0xe6, 0xfb, 0x57, 0x16, 0xcc, 0x95, 0x34, 0x7c, - 0x6b, 0xcf, 0xed, 0x6c, 0xd1, 0x79, 0x7f, 0x57, 0xd3, 0xbf, 0xb0, 0x9b, 0xe1, 0x6f, 0xba, 0x01, 0x33, 0xcc, 0x27, - 0xb7, 0xdf, 0x4f, 0xb1, 0x26, 0x1c, 0xff, 0xc8, 0x2a, 0x86, 0x85, 0x2b, 0x08, 0x16, 0x35, 0x46, 0x9c, 0x92, 0x7f, - 0xec, 0x03, 0x05, 0xda, 0xc3, 0x86, 0x02, 0x83, 0x51, 0xe5, 0xa1, 0x12, 0xe9, 0x53, 0xf1, 0xcb, 0x36, 0x90, 0x41, - 0x27, 0x1c, 0x4a, 0x06, 0x76, 0x6a, 0xd7, 0x2a, 0x31, 0x5b, 0x73, 0xeb, 0x3f, 0x66, 0x05, 0x9b, 0x61, 0xc0, 0x12, - 0xf5, 0x90, 0x46, 0x7a, 0x59, 0xb5, 0x08, 0xef, 0x0d, 0x4d, 0xdd, 0x43, 0x90, 0x5a, 0x16, 0x09, 0x7f, 0x60, 0x1e, - 0xa0, 0x46, 0x30, 0x66, 0x9a, 0x67, 0xa5, 0x1c, 0x42, 0x2e, 0xd3, 0xe3, 0x54, 0x14, 0xa3, 0x96, 0xe5, 0x3a, 0x63, - 0x15, 0x47, 0x5e, 0xb3, 0x38, 0x6f, 0x66, 0x51, 0xae, 0x51, 0x36, 0x2c, 0xb8, 0xfe, 0x0c, 0x89, 0x46, 0xb1, 0x41, - 0x43, 0xec, 0x8e, 0x73, 0x52, 0xa6, 0x39, 0x47, 0x1d, 0x92, 0x5b, 0x72, 0x8f, 0x58, 0xcd, 0x6c, 0x25, 0x4c, 0x8e, - 0x56, 0x6d, 0x46, 0xd8, 0xee, 0x68, 0x1c, 0x33, 0x4d, 0x1c, 0x4f, 0x21, 0xf4, 0x40, 0x9b, 0x3d, 0x2d, 0xd9, 0x71, - 0xf1, 0x7f, 0x90, 0x02, 0xba, 0x79, 0xb4, 0x42, 0x30, 0x17, 0xfb, 0x18, 0xa5, 0x86, 0x9b, 0x63, 0x17, 0xd8, 0xb0, - 0xfd, 0xe7, 0x26, 0xba, 0xa2, 0xe3, 0xb9, 0x5e, 0xa9, 0x91, 0x83, 0x38, 0xb1, 0x3e, 0xdb, 0x83, 0xd0, 0x7a, 0x44, - 0xc2, 0x81, 0xb2, 0xce, 0x7a, 0x65, 0x1e, 0xeb, 0xd2, 0x7f, 0xfd, 0x4b, 0x6d, 0x09, 0x41, 0x60, 0x58, 0x3d, 0xd8, - 0xfe, 0x04, 0x56, 0x5c, 0xc8, 0x12, 0x99, 0xf1, 0xc2, 0xbf, 0x62, 0x87, 0xaf, 0x69, 0x56, 0x56, 0x3a, 0xc7, 0xe5, - 0xcc, 0x42, 0xa7, 0xa1, 0x6a, 0x8e, 0x79, 0x1e, 0x32, 0x16, 0xd3, 0x0b, 0x83, 0x9c, 0x0b, 0x02, 0x1a, 0x9a, 0x73, - 0xee, 0xca, 0x7a, 0x93, 0xe0, 0x36, 0x82, 0x62, 0x29, 0x40, 0x57, 0xe8, 0x32, 0xbd, 0xf3, 0xcd, 0x30, 0x0e, 0x86, - 0xdc, 0xcc, 0x00, 0x84, 0x2d, 0x11, 0x54, 0x32, 0xf0, 0xac, 0xd8, 0xb3, 0x92, 0x73, 0x30, 0xe7, 0x15, 0xea, 0xbd, - 0x46, 0xfa, 0x1b, 0x24, 0x5c, 0xa0, 0x5a, 0x29, 0x70, 0x32, 0xa0, 0xcb, 0x52, 0x2b, 0x34, 0x2f, 0x11, 0x62, 0xac, - 0x01, 0x49, 0x6d, 0xe2, 0x97, 0xf3, 0x02, 0xf7, 0xbc, 0x9f, 0x0d, 0x67, 0x5d, 0x97, 0x00, 0xf2, 0x30, 0x2f, 0xbf, - 0xbd, 0xcc, 0x70, 0x90, 0x13, 0x90, 0xb8, 0x18, 0x98, 0x39, 0xa1, 0x9d, 0x5d, 0xc1, 0x96, 0xba, 0x18, 0x55, 0xb8, - 0xad, 0x61, 0xb2, 0x14, 0x95, 0x6d, 0xb8, 0x3e, 0x86, 0xce, 0x48, 0xfa, 0xce, 0x4f, 0x33, 0x09, 0x33, 0x74, 0xcd, - 0xc9, 0x54, 0xee, 0x04, 0x9b, 0x4f, 0x9a, 0x81, 0xbe, 0xd8, 0xfa, 0x73, 0xe8, 0x7f, 0xda, 0xd8, 0x04, 0xd3, 0xf7, - 0x8c, 0x64, 0xc4, 0x54, 0xa2, 0xcf, 0x1b, 0xcc, 0x3e, 0xed, 0xf7, 0xf9, 0x0e, 0x16, 0xeb, 0xcb, 0xd8, 0xcb, 0x8a, - 0x8d, 0xfa, 0xd8, 0x5a, 0xc6, 0x24, 0x71, 0x2c, 0xb9, 0x3d, 0x28, 0x29, 0xa8, 0xcc, 0x9b, 0xa8, 0x21, 0x23, 0xa6, - 0x35, 0x27, 0x3b, 0xf1, 0xbf, 0x73, 0xc5, 0xcc, 0xc4, 0xc0, 0x8f, 0xb1, 0xc7, 0x3e, 0xbe, 0x7a, 0xe2, 0xad, 0xf6, - 0x23, 0x67, 0xe8, 0x98, 0x3c, 0x40, 0x20, 0x17, 0x98, 0x97, 0x2e, 0x30, 0xe7, 0xd6, 0x8a, 0x35, 0x6b, 0x6a, 0xe5, - 0x3f, 0xbb, 0x2b, 0x7d, 0x60, 0xec, 0x13, 0x41, 0x7f, 0x36, 0xed, 0x66, 0xec, 0x1b, 0xb3, 0x57, 0x03, 0x4e, 0x1d, - 0xcc, 0x6c, 0xbc, 0xa9, 0xf4, 0x1f, 0x6a, 0x73, 0xc5, 0x02, 0x14, 0x39, 0x1b, 0xf9, 0xa4, 0xa9, 0x08, 0xfe, 0xb8, - 0x3a, 0x7b, 0xb1, 0xdd, 0xa2, 0x50, 0x70, 0x65, 0x34, 0xe1, 0x5d, 0x46, 0x3e, 0xd1, 0xd0, 0x06, 0x6f, 0xe4, 0x8d, - 0x6d, 0x5c, 0x46, 0xfb, 0x68, 0x3f, 0x07, 0xb1, 0x0b, 0x82, 0xb6, 0x26, 0x16, 0x04, 0x59, 0x53, 0xe7, 0x0d, 0x23, - 0x12, 0xfc, 0xd6, 0x5a, 0xe9, 0xbc, 0x8e, 0xbd, 0xd2, 0x1d, 0xe7, 0x43, 0x22, 0x46, 0xe0, 0xb6, 0xe8, 0x7a, 0x4b, - 0x42, 0x19, 0x97, 0x8e, 0x4e, 0x26, 0x78, 0xd4, 0x26, 0x4e, 0xaa, 0x6d, 0xaf, 0x47, 0x1d, 0x1e, 0xf5, 0xdd, 0xbc, - 0x18, 0x94, 0xb6, 0x3b, 0xfa, 0x6f, 0xe1, 0xad, 0xcc, 0x91, 0xc7, 0xb5, 0xbe, 0xd3, 0xdc, 0x02, 0xbd, 0x89, 0xe8, - 0x44, 0x51, 0x27, 0x9c, 0xbc, 0x52, 0x8e, 0xff, 0x0b, 0x85, 0x15, 0x0c, 0x81, 0xc9, 0x4c, 0x24, 0xaa, 0x2d, 0x48, - 0x67, 0xa1, 0xbf, 0xf5, 0xf1, 0xb5, 0x42, 0x16, 0xd8, 0x62, 0x06, 0x71, 0xa8, 0x07, 0x8d, 0xe0, 0x25, 0x14, 0x88, - 0xe2, 0xde, 0x19, 0x1a, 0x83, 0x1e, 0x94, 0x3b, 0xa4, 0x81, 0x62, 0xd0, 0xb2, 0x14, 0x1a, 0xda, 0x84, 0x54, 0xbb, - 0xdf, 0x1b, 0xca, 0xfa, 0x25, 0x37, 0xd4, 0x28, 0xa2, 0x51, 0x6f, 0x1d, 0x24, 0x20, 0xe8, 0x15, 0x07, 0x69, 0xa0, - 0xbc, 0x5e, 0x12, 0x23, 0x96, 0xf1, 0x38, 0xc8, 0xd5, 0xc2, 0xe3, 0x95, 0x90, 0x53, 0xb3, 0x42, 0xc8, 0x31, 0x80, - 0x61, 0xec, 0x81, 0x7b, 0x39, 0xec, 0x60, 0x11, 0xf0, 0xbc, 0x5c, 0x51, 0xcf, 0x46, 0xb1, 0xb0, 0xfd, 0xbb, 0xbc, - 0x98, 0x5f, 0xd2, 0xde, 0x26, 0x29, 0x8f, 0x55, 0x9a, 0x4a, 0xf0, 0xdd, 0x9f, 0xde, 0xc5, 0x7c, 0x2c, 0x59, 0xb3, - 0xa5, 0x32, 0x07, 0x13, 0xa2, 0xeb, 0x90, 0x91, 0x3e, 0x55, 0xc5, 0xb1, 0x49, 0x01, 0x35, 0x1c, 0x87, 0x9d, 0x0b, - 0xc2, 0xe3, 0x84, 0x35, 0x9c, 0x4b, 0xcc, 0x61, 0x87, 0x0a, 0x36, 0xc2, 0xe8, 0x86, 0x12, 0x62, 0x49, 0x6d, 0xc4, - 0xb7, 0x03, 0x5c, 0x82, 0xef, 0x17, 0x5a, 0x79, 0x1f, 0x20, 0xfe, 0xd8, 0xa4, 0x33, 0x40, 0x2e, 0xb1, 0xb2, 0x98, - 0xb0, 0xed, 0xdf, 0x2a, 0x6d, 0x2b, 0x0f, 0xd3, 0xcd, 0xbd, 0x39, 0xbb, 0x03, 0x85, 0x33, 0x27, 0x19, 0xf9, 0x31, - 0xe9, 0x51, 0x39, 0x93, 0xff, 0xdc, 0x30, 0x06, 0x64, 0xe6, 0x0e, 0xf6, 0x95, 0xc0, 0x98, 0xbe, 0xd2, 0xd1, 0x84, - 0x7f, 0x89, 0x94, 0x9f, 0x8d, 0x46, 0x4c, 0x5e, 0x61, 0xc8, 0x55, 0xfa, 0x4a, 0xbf, 0xcf, 0x5c, 0xf4, 0x52, 0xde, - 0x38, 0xc6, 0xa8, 0xb8, 0xc9, 0xf8, 0xc5, 0xc8, 0x16, 0x22, 0xf5, 0x66, 0xcc, 0xb6, 0x3f, 0x5b, 0xa2, 0x7b, 0x86, - 0x07, 0x92, 0xa0, 0x71, 0xa3, 0x40, 0x01, 0x76, 0x31, 0xc1, 0x90, 0xdc, 0x01, 0x93, 0xa6, 0x69, 0x9e, 0xa7, 0x50, - 0xd7, 0x6a, 0x38, 0xa9, 0x6c, 0xab, 0xbb, 0xac, 0x4c, 0x65, 0xdb, 0xc1, 0x70, 0x8d, 0x82, 0xc4, 0x51, 0xe3, 0x14, - 0x15, 0xb3, 0xea, 0x69, 0x52, 0x86, 0x05, 0x44, 0x5a, 0x71, 0x8e, 0xdf, 0x5c, 0x9a, 0x4c, 0x67, 0xa7, 0xd8, 0x2b, - 0x3c, 0x4f, 0x85, 0x08, 0x76, 0x67, 0x15, 0x09, 0xbb, 0xb6, 0x65, 0x1d, 0x2d, 0x64, 0xee, 0x5b, 0x17, 0xe8, 0x12, - 0xe2, 0x07, 0x6f, 0xf5, 0xdb, 0xfd, 0x04, 0xec, 0x20, 0x8c, 0xf5, 0x11, 0x5d, 0x7c, 0xd4, 0x0b, 0x4a, 0x2b, 0x3f, - 0x09, 0xce, 0xd9, 0x66, 0xe9, 0xfd, 0x2f, 0x58, 0xdf, 0x94, 0x17, 0x0b, 0x0a, 0x85, 0x15, 0xcb, 0x52, 0x5c, 0xb5, - 0x8c, 0xcf, 0x51, 0x85, 0x55, 0xc8, 0xb1, 0x87, 0x1e, 0x37, 0x10, 0xa9, 0x65, 0x91, 0x34, 0x69, 0xee, 0xac, 0x44, - 0xa6, 0x6b, 0xb0, 0xf3, 0x4a, 0x00, 0x76, 0x6c, 0x52, 0xd5, 0x8b, 0x85, 0xa7, 0x24, 0xc1, 0xd1, 0xad, 0x90, 0xbb, - 0x50, 0x65, 0x0f, 0x14, 0x62, 0x58, 0x07, 0x58, 0x38, 0x2b, 0x58, 0x12, 0xb6, 0x0f, 0xab, 0xf1, 0x63, 0x54, 0x5b, - 0xc0, 0xf8, 0x10, 0x42, 0x7d, 0xb7, 0x83, 0x8e, 0xa2, 0xa3, 0x35, 0x9a, 0xdc, 0xe3, 0x00, 0x19, 0xf4, 0x73, 0x3f, - 0x15, 0x5c, 0xf2, 0x80, 0xbc, 0x18, 0x39, 0x89, 0xab, 0xf1, 0xa6, 0x65, 0xea, 0x5c, 0xf9, 0xee, 0x4b, 0x1b, 0x61, - 0x5d, 0x20, 0x2e, 0xe4, 0x7d, 0xec, 0x90, 0x7d, 0x77, 0x18, 0xad, 0xae, 0x9b, 0x27, 0x8b, 0xfc, 0x59, 0x56, 0x4d, - 0x45, 0xf8, 0xd3, 0xf7, 0x1b, 0x6a, 0x73, 0x16, 0x50, 0xee, 0xbd, 0x5e, 0x70, 0x8a, 0x7a, 0x47, 0x05, 0x22, 0x98, - 0x64, 0xf8, 0xed, 0x23, 0xd2, 0x16, 0x24, 0x62, 0xcd, 0x87, 0x4b, 0xaf, 0x59, 0x7f, 0x0b, 0x82, 0x55, 0x13, 0xe1, - 0xec, 0x57, 0x1a, 0xc4, 0xc1, 0x4b, 0x11, 0x92, 0xae, 0x08, 0x06, 0x3a, 0x2a, 0x88, 0xad, 0xd8, 0xca, 0x5e, 0x56, - 0x6b, 0x08, 0x44, 0x9c, 0x83, 0xcd, 0x67, 0x96, 0xe1, 0x39, 0xf1, 0xea, 0x97, 0x07, 0x29, 0x5c, 0x8c, 0x41, 0xff, - 0xab, 0x65, 0xe1, 0x07, 0x07, 0x07, 0x56, 0x46, 0x56, 0x8e, 0x7a, 0xd7, 0x4b, 0xe5, 0xb6, 0xac, 0xe3, 0xd6, 0xaa, - 0xf7, 0xe4, 0x05, 0x28, 0x8d, 0x36, 0x83, 0x64, 0xb7, 0x8e, 0x99, 0x1a, 0xc3, 0x43, 0x56, 0x8b, 0xfa, 0x98, 0x70, - 0x87, 0xbd, 0x91, 0x86, 0xbd, 0x83, 0x89, 0x68, 0xbc, 0x6f, 0xff, 0xc4, 0x48, 0x43, 0xc2, 0x74, 0xcc, 0x21, 0x77, - 0x50, 0x66, 0x4c, 0x4f, 0x05, 0x6d, 0xc7, 0x11, 0xcf, 0x45, 0x92, 0xce, 0xfd, 0x2b, 0xc3, 0xfb, 0x0b, 0x19, 0x5b, - 0x42, 0x46, 0x77, 0x24, 0xa5, 0x08, 0xd7, 0xd2, 0x60, 0x60, 0x8c, 0x60, 0x3e, 0x25, 0x9a, 0x88, 0x65, 0xb7, 0xb9, - 0x20, 0xb1, 0xcf, 0xd5, 0x92, 0xbd, 0x55, 0x2c, 0xa6, 0x04, 0x2d, 0x8a, 0x5e, 0xbc, 0x5c, 0x99, 0x31, 0xe1, 0xd1, - 0xb5, 0x71, 0x13, 0x23, 0x76, 0x67, 0x56, 0x7b, 0x1b, 0x3c, 0x68, 0x9f, 0x7f, 0xbd, 0x51, 0xbc, 0xb8, 0x5d, 0xbe, - 0x84, 0xe0, 0x07, 0x4f, 0x93, 0xc5, 0x50, 0x06, 0xb9, 0xd8, 0x70, 0xc1, 0x03, 0x59, 0x44, 0x6d, 0xb7, 0x1e, 0x23, - 0x36, 0xcf, 0x27, 0x9f, 0xb6, 0x30, 0x3c, 0x93, 0x93, 0xc1, 0xfe, 0x45, 0x07, 0xbf, 0x01, 0x5a, 0x37, 0x29, 0xf2, - 0xef, 0x4a, 0xd5, 0x41, 0x46, 0xf0, 0xf1, 0xcb, 0xed, 0x2f, 0xca, 0x50, 0xd3, 0x33, 0x9a, 0x86, 0xdd, 0xf2, 0xf7, - 0xc9, 0x29, 0xd8, 0x77, 0x65, 0x00, 0xa8, 0xd3, 0xa5, 0x8c, 0xf8, 0x9c, 0x7c, 0x83, 0x30, 0x00, 0x22, 0xbf, 0xf9, - 0x55, 0x3b, 0x3e, 0x36, 0xc7, 0xe5, 0x0f, 0x6d, 0x7b, 0x96, 0x88, 0xfe, 0xae, 0x0d, 0xb3, 0x1d, 0xfb, 0x80, 0x15, - 0x0f, 0xa3, 0x44, 0xb4, 0xac, 0xf9, 0x90, 0xb9, 0x4f, 0xf1, 0xb0, 0x79, 0xb4, 0x6a, 0x23, 0x8a, 0x6c, 0xb0, 0x5d, - 0xb2, 0xbf, 0xd0, 0xd2, 0xf9, 0x66, 0x87, 0x66, 0x50, 0xb7, 0x47, 0xc8, 0xab, 0x08, 0x20, 0x1e, 0x83, 0xc1, 0x7f, - 0x6d, 0xe6, 0x3d, 0x5b, 0xac, 0x00, 0x3f, 0x3b, 0x76, 0xfe, 0xf2, 0x7c, 0x6a, 0x11, 0x04, 0x7d, 0xd6, 0x3c, 0xaa, - 0x47, 0x44, 0xd2, 0x4f, 0x67, 0x5b, 0xbd, 0x4f, 0x87, 0x51, 0x89, 0x47, 0x6c, 0xda, 0xfe, 0x1d, 0x8b, 0xba, 0xd8, - 0xde, 0xb3, 0xe9, 0xfc, 0xb9, 0x29, 0x74, 0x06, 0x91, 0xda, 0xc6, 0x99, 0x8c, 0x64, 0x47, 0xa6, 0x01, 0x0d, 0xd1, - 0x5e, 0x28, 0xaf, 0x1f, 0x50, 0x32, 0x0a, 0xe4, 0x18, 0x41, 0xae, 0x8d, 0x8c, 0x2d, 0x27, 0x4b, 0x10, 0x86, 0x25, - 0xce, 0xef, 0xa9, 0x43, 0xd0, 0x4b, 0x85, 0xe4, 0xec, 0x22, 0x5c, 0x6f, 0x87, 0x34, 0x1a, 0x00, 0x4a, 0x8d, 0xb7, - 0x09, 0x1e, 0xb6, 0x20, 0x46, 0x2a, 0xb2, 0x22, 0xf1, 0xa7, 0xc4, 0x45, 0xe5, 0x18, 0x8f, 0x00, 0x24, 0xc6, 0xf1, - 0x50, 0xea, 0x3c, 0xa8, 0x43, 0xf2, 0x8a, 0x89, 0x39, 0xd2, 0xb3, 0x0a, 0x3d, 0x98, 0x69, 0x68, 0x73, 0x35, 0x9a, - 0x2a, 0x68, 0x0e, 0x4a, 0xff, 0x81, 0xea, 0x2a, 0x1f, 0x92, 0x47, 0x06, 0x41, 0x18, 0xae, 0xd6, 0x5b, 0xea, 0xf7, - 0x15, 0x42, 0x8b, 0x03, 0x33, 0xc9, 0x20, 0xce, 0x8d, 0x0f, 0x5b, 0x5d, 0xe3, 0x8b, 0x7a, 0x02, 0x34, 0x27, 0xae, - 0x7c, 0xf8, 0x78, 0x32, 0x50, 0x38, 0x41, 0xc9, 0xe8, 0x4f, 0x50, 0x53, 0x2d, 0xe9, 0x76, 0x1e, 0x37, 0xdd, 0x94, - 0xaf, 0x92, 0x5b, 0x6a, 0x66, 0x29, 0x7a, 0x2d, 0xe5, 0x81, 0x66, 0xbb, 0x95, 0xf5, 0xd7, 0x7f, 0x6a, 0xf8, 0x04, - 0xd0, 0x45, 0xc2, 0xca, 0xc4, 0xb7, 0xa8, 0xc1, 0x2f, 0x3e, 0x1c, 0x9c, 0x8c, 0x61, 0x7b, 0xa8, 0xc5, 0xdc, 0xe1, - 0x38, 0xc7, 0xfe, 0x3d, 0x90, 0x1b, 0xdc, 0x4a, 0xa0, 0xe4, 0x6b, 0x59, 0x84, 0x99, 0xcc, 0x62, 0xa0, 0x72, 0x35, - 0xe8, 0x3a, 0xb0, 0x90, 0x35, 0xb5, 0xe6, 0x87, 0xfe, 0xa7, 0x0a, 0x32, 0xf7, 0x6c, 0x95, 0x02, 0x24, 0xc8, 0xb7, - 0xd2, 0x36, 0xed, 0x7d, 0x8b, 0xdc, 0x41, 0xf7, 0x08, 0x16, 0xb5, 0xdd, 0x61, 0x02, 0x68, 0xa1, 0x83, 0x10, 0x52, - 0xe7, 0x53, 0x28, 0x7a, 0xb9, 0x49, 0x26, 0x74, 0xae, 0x05, 0x9e, 0x2f, 0x1d, 0x1c, 0xfd, 0xfb, 0xe3, 0x81, 0x72, - 0x45, 0x02, 0x97, 0x13, 0x7c, 0x0a, 0x9b, 0xda, 0x9c, 0x01, 0x65, 0xa4, 0x7d, 0x75, 0xb8, 0x62, 0x1f, 0x05, 0xac, - 0x0b, 0x9d, 0x59, 0x08, 0x15, 0x99, 0xec, 0x48, 0xd8, 0x17, 0x45, 0x33, 0xc4, 0x79, 0xc1, 0x55, 0x6c, 0x03, 0x9f, - 0xdb, 0xa4, 0x83, 0x98, 0x8b, 0xb6, 0x05, 0x1f, 0x0b, 0xaa, 0xcc, 0x09, 0x8b, 0x6e, 0x80, 0xd1, 0x5e, 0x7b, 0xa9, - 0xf5, 0x83, 0x76, 0x42, 0x67, 0xc5, 0xbd, 0xeb, 0x2a, 0xc2, 0xc0, 0x27, 0xd8, 0xa9, 0xfd, 0x2b, 0x8a, 0xe3, 0x6f, - 0x9b, 0x71, 0xb4, 0xe0, 0x53, 0x04, 0x06, 0x90, 0x90, 0x6e, 0x98, 0x6d, 0xcd, 0x08, 0x3a, 0x7e, 0x08, 0x35, 0x4a, - 0x01, 0x29, 0x8d, 0x30, 0x38, 0xca, 0xe4, 0x37, 0x41, 0x86, 0xe4, 0xbc, 0x9c, 0xa3, 0x87, 0x21, 0x46, 0x0e, 0x48, - 0x65, 0xae, 0x6c, 0xc7, 0x5e, 0x55, 0x4f, 0x85, 0x3c, 0x71, 0x0e, 0x62, 0x31, 0xf4, 0xc8, 0x88, 0x3f, 0xc8, 0x54, - 0x67, 0xa0, 0x89, 0x01, 0x33, 0x82, 0x03, 0xb1, 0x29, 0x68, 0x84, 0xc0, 0x09, 0x59, 0xb6, 0x7c, 0x29, 0x56, 0x01, - 0x89, 0x50, 0xc4, 0xa2, 0x25, 0x92, 0x1f, 0x31, 0x32, 0x30, 0x43, 0x12, 0xe8, 0x31, 0x7b, 0x4d, 0x07, 0xc6, 0x05, - 0x18, 0x53, 0xa9, 0x1e, 0x40, 0x3e, 0x05, 0xa3, 0xb0, 0x88, 0x50, 0xcb, 0x5d, 0x79, 0x91, 0x34, 0x34, 0x58, 0xc3, - 0xb1, 0x68, 0x2e, 0xe6, 0x28, 0xbd, 0x67, 0xca, 0x10, 0x24, 0x57, 0xad, 0x8c, 0xb0, 0xd3, 0x9f, 0xc7, 0x21, 0xe4, - 0xab, 0x0e, 0x42, 0x9b, 0x1b, 0x67, 0x11, 0x20, 0xf4, 0x48, 0x6c, 0x63, 0x8c, 0x80, 0xa4, 0xa1, 0x03, 0xa9, 0x0b, - 0x10, 0x21, 0x21, 0x44, 0x92, 0x80, 0xe6, 0x7c, 0x8b, 0x44, 0x7c, 0x06, 0x61, 0xae, 0x0b, 0xd2, 0x64, 0x89, 0x4a, - 0xbf, 0x6f, 0x96, 0x61, 0xb9, 0xc3, 0xc9, 0x2c, 0xc8, 0x55, 0x95, 0xb3, 0x00, 0x89, 0x84, 0xd9, 0xea, 0x84, 0xa1, - 0xf3, 0x46, 0xfb, 0x49, 0xc0, 0xd9, 0xc2, 0x84, 0x0c, 0x04, 0xa3, 0x58, 0x14, 0x85, 0x4a, 0xf5, 0x49, 0x81, 0xc3, - 0x08, 0x0d, 0xef, 0x2e, 0x0a, 0x37, 0xf3, 0x64, 0x2d, 0xab, 0xe2, 0x11, 0x93, 0xfb, 0xa1, 0x96, 0x38, 0xa7, 0x40, - 0x72, 0x82, 0xa2, 0xd1, 0xfd, 0xd7, 0xcf, 0x1d, 0x95, 0x44, 0x78, 0xd1, 0xa2, 0xf4, 0x6b, 0x8b, 0xdb, 0x5c, 0xcd, - 0x09, 0x34, 0x69, 0x66, 0xc8, 0x37, 0x9d, 0x8a, 0xf9, 0x95, 0xc1, 0xe5, 0x2e, 0xd8, 0x10, 0x40, 0x9b, 0x41, 0xef, - 0x4b, 0xeb, 0x53, 0xfa, 0x01, 0x46, 0xdf, 0xb8, 0xf3, 0xc2, 0x68, 0x27, 0xeb, 0xbd, 0xa1, 0x0b, 0xeb, 0x67, 0x57, - 0xb5, 0xd3, 0x71, 0x44, 0x02, 0x67, 0x2d, 0x74, 0xc8, 0xe6, 0x95, 0xb0, 0x9c, 0xd9, 0xe2, 0xec, 0xd1, 0xaa, 0xb5, - 0x1c, 0x91, 0x8e, 0x34, 0x1c, 0x90, 0xe3, 0xd9, 0x07, 0xa8, 0xf3, 0x08, 0x18, 0x49, 0x39, 0xf3, 0x5e, 0x71, 0x9c, - 0x37, 0x44, 0x1a, 0xea, 0x39, 0x2f, 0x00, 0xec, 0xca, 0x22, 0x29, 0x79, 0x1d, 0x72, 0x2d, 0xfd, 0xe9, 0x98, 0x47, - 0x8c, 0xb1, 0x73, 0x2a, 0x23, 0x8c, 0x4e, 0xae, 0x6b, 0x8e, 0x8c, 0xb2, 0x0b, 0x26, 0x54, 0xf3, 0xae, 0x34, 0xe5, - 0x81, 0x2c, 0xb2, 0xe9, 0x4a, 0x0b, 0x4e, 0x47, 0x62, 0xae, 0x6e, 0x56, 0x51, 0x3d, 0x4c, 0x10, 0xb1, 0xde, 0xbe, - 0xc1, 0xe4, 0x11, 0xcf, 0x27, 0x82, 0x54, 0xa4, 0xcd, 0xe9, 0x59, 0xc9, 0x07, 0xcc, 0x16, 0x68, 0xb4, 0xf2, 0x5e, - 0x00, 0x94, 0xdf, 0x94, 0xa8, 0x48, 0xb9, 0x6c, 0xd1, 0x41, 0x34, 0xe2, 0xd7, 0x41, 0x36, 0xeb, 0x3d, 0x39, 0x9e, - 0x6f, 0x8d, 0xac, 0x86, 0xc8, 0xd0, 0xea, 0xe8, 0x37, 0x74, 0xe8, 0x2b, 0xc2, 0xa4, 0xd3, 0xf3, 0xd8, 0xd6, 0x02, - 0x2d, 0x86, 0x8a, 0xa7, 0x62, 0x8c, 0x93, 0xea, 0x1a, 0xb1, 0x4c, 0xa9, 0x6f, 0x31, 0xd1, 0x15, 0xf4, 0x93, 0x2d, - 0x05, 0x9b, 0x6f, 0x59, 0xc9, 0x8b, 0x8c, 0x08, 0x7b, 0x8d, 0xf0, 0x62, 0x18, 0x03, 0xf4, 0xaa, 0xa5, 0x74, 0x1e, - 0xe8, 0xad, 0xe8, 0x8a, 0x79, 0xec, 0xc3, 0xeb, 0x2e, 0x49, 0x5e, 0xe0, 0xd6, 0x3c, 0x66, 0x35, 0x96, 0xdf, 0xbc, - 0xfe, 0xc6, 0x54, 0x25, 0xd6, 0xca, 0xca, 0x4f, 0xba, 0x6c, 0xdf, 0x0f, 0x49, 0x83, 0xbc, 0x4d, 0x6b, 0xfb, 0xbd, - 0xc9, 0x37, 0x10, 0x1b, 0x8c, 0xa2, 0x99, 0x2e, 0x16, 0x87, 0x05, 0xd2, 0xaf, 0x97, 0xa0, 0x2b, 0xd3, 0x0c, 0xd2, - 0xbe, 0xaf, 0x2f, 0x7f, 0x03, 0x98, 0x11, 0x63, 0x1f, 0x72, 0x22, 0x5a, 0x89, 0x66, 0xcb, 0xfc, 0xec, 0xec, 0x2d, - 0x08, 0x01, 0x33, 0xd9, 0xcf, 0x0f, 0x33, 0x43, 0xc2, 0x5e, 0x33, 0x13, 0xa1, 0xc0, 0x9a, 0x66, 0x9e, 0x5d, 0xcd, - 0xed, 0xd3, 0x52, 0xb4, 0x78, 0xac, 0x75, 0x95, 0xfa, 0x5e, 0xc6, 0x93, 0x8b, 0xd8, 0x9e, 0x67, 0x68, 0x3d, 0x63, - 0xa4, 0x41, 0x87, 0x17, 0x22, 0x62, 0x8b, 0x67, 0xff, 0x81, 0x99, 0x19, 0x85, 0x80, 0x6a, 0x0a, 0x7d, 0x7b, 0x8b, - 0x78, 0x2c, 0x4d, 0x9e, 0x91, 0xd9, 0xf7, 0x24, 0xdf, 0xac, 0x93, 0xf7, 0x5e, 0xaf, 0x5c, 0xad, 0x70, 0x6a, 0x85, - 0x1b, 0xe8, 0x51, 0xbf, 0xd5, 0x90, 0x28, 0x42, 0x0e, 0xe3, 0xd2, 0x2f, 0xea, 0x08, 0xe7, 0x02, 0xaf, 0xa7, 0x6e, - 0xeb, 0x7a, 0x48, 0x35, 0x05, 0x71, 0xee, 0xb6, 0x70, 0x46, 0x6f, 0xcd, 0x91, 0xa1, 0x3b, 0xce, 0xf2, 0x42, 0x5d, - 0xdd, 0x1d, 0x98, 0x76, 0x68, 0x68, 0x78, 0x5c, 0xd7, 0xa3, 0xc9, 0x23, 0x11, 0x4d, 0xdc, 0x5a, 0xac, 0xbf, 0x23, - 0xca, 0x3c, 0x0d, 0x60, 0xa7, 0x31, 0xea, 0xbf, 0x4b, 0xf6, 0x68, 0x74, 0xc7, 0x24, 0x91, 0x0d, 0x99, 0x6d, 0x40, - 0x9b, 0x83, 0x23, 0x3d, 0xf5, 0x15, 0x95, 0xdf, 0x4b, 0x14, 0x1c, 0x2f, 0xc5, 0x2d, 0x97, 0xf8, 0xab, 0x78, 0xe8, - 0xe9, 0x24, 0xa6, 0xc1, 0x0d, 0x59, 0x5c, 0x19, 0xe0, 0x32, 0x69, 0x0b, 0x0b, 0x68, 0xd8, 0xc0, 0x02, 0x0a, 0xa3, - 0xcf, 0x61, 0x92, 0x88, 0x7b, 0x38, 0x64, 0xbb, 0xc9, 0x7b, 0x71, 0x4c, 0x14, 0xcf, 0xd5, 0xe4, 0xe8, 0x82, 0x17, - 0xd3, 0x41, 0xd4, 0xec, 0x34, 0xd2, 0xcf, 0x30, 0xbd, 0x97, 0xad, 0xeb, 0xc8, 0x00, 0x61, 0x06, 0x15, 0xea, 0x17, - 0xd2, 0x3e, 0x7b, 0x39, 0x64, 0x40, 0xd1, 0xa0, 0xce, 0x86, 0x1d, 0x62, 0x51, 0xc8, 0x6b, 0x17, 0x4f, 0xb8, 0x96, - 0x78, 0x8f, 0x1e, 0x65, 0x58, 0x5c, 0xe6, 0x63, 0xb4, 0xf3, 0x56, 0x96, 0xa6, 0x0b, 0xcb, 0xf9, 0x5d, 0x8c, 0x16, - 0xe8, 0x70, 0xf5, 0xb8, 0x48, 0xf7, 0x53, 0x7b, 0x5e, 0xf8, 0x9f, 0x43, 0x17, 0x5d, 0xfb, 0x4c, 0x26, 0x75, 0x25, - 0x8f, 0x11, 0xf5, 0x55, 0x2f, 0xac, 0xe2, 0xde, 0x6b, 0xcd, 0xf4, 0x51, 0x8e, 0x32, 0x0f, 0x55, 0x66, 0x0d, 0xc6, - 0xd3, 0x92, 0x0c, 0x1f, 0x1d, 0x01, 0x0e, 0x41, 0x13, 0x82, 0x99, 0xfb, 0x92, 0x18, 0xa3, 0x12, 0x30, 0xee, 0x2c, - 0xb0, 0xbc, 0x9e, 0xdd, 0xd3, 0xd0, 0x16, 0x5a, 0x3e, 0xe5, 0xfc, 0x83, 0x2d, 0x96, 0xf9, 0xa9, 0xb0, 0x59, 0xe2, - 0xe2, 0x8e, 0x85, 0x3c, 0xea, 0x45, 0x55, 0xda, 0x5a, 0xf9, 0x8a, 0x54, 0x76, 0x43, 0x16, 0x5e, 0xd6, 0x2d, 0x2f, - 0x45, 0xe7, 0x55, 0x8c, 0x72, 0x92, 0x63, 0x0c, 0xc5, 0x10, 0xe0, 0xcd, 0x1c, 0x74, 0xf7, 0x02, 0x67, 0x72, 0x03, - 0x99, 0xe9, 0xeb, 0xd8, 0x52, 0x41, 0x1e, 0xec, 0xea, 0x99, 0x85, 0x07, 0x90, 0xc8, 0xf2, 0xf1, 0x9c, 0x8c, 0x2d, - 0xcb, 0x93, 0xef, 0xe5, 0x93, 0x60, 0x06, 0xaf, 0x02, 0x64, 0xd9, 0x79, 0xcd, 0xc1, 0x9f, 0x75, 0x87, 0x73, 0x4b, - 0x6b, 0x83, 0x6a, 0x1f, 0x7a, 0xce, 0x96, 0x0c, 0xbe, 0x12, 0x60, 0x34, 0x13, 0xa8, 0x2c, 0x41, 0x30, 0x4b, 0x8b, - 0xf9, 0x82, 0x60, 0x8e, 0xa3, 0x50, 0xb0, 0x3a, 0xe5, 0xe7, 0x61, 0x53, 0x14, 0x45, 0x3c, 0xfc, 0x3c, 0x0e, 0x95, - 0x67, 0x84, 0x55, 0x7c, 0xad, 0x88, 0xf2, 0xa1, 0xc6, 0x93, 0x81, 0x14, 0x40, 0xff, 0xa6, 0x2b, 0xa2, 0xfd, 0x15, - 0x69, 0x14, 0x14, 0xf6, 0x99, 0xbb, 0xd0, 0xce, 0x1a, 0x71, 0x91, 0x7e, 0x93, 0x61, 0x5e, 0x89, 0x67, 0x7e, 0x65, - 0x5d, 0xd6, 0x3a, 0xdf, 0x83, 0x6a, 0x3f, 0x52, 0xda, 0x59, 0xce, 0x2c, 0x39, 0x40, 0xbb, 0xa6, 0x69, 0x33, 0x9f, - 0x90, 0xb3, 0xb8, 0xda, 0x61, 0x0a, 0x52, 0x81, 0x57, 0x4d, 0x23, 0x95, 0xe2, 0xbc, 0x13, 0x05, 0x1c, 0x2e, 0xa7, - 0xf8, 0xbf, 0x39, 0x51, 0xbb, 0xf9, 0x05, 0x79, 0x6c, 0xef, 0xea, 0x97, 0x83, 0xac, 0x2d, 0x1c, 0x1d, 0x5c, 0xe7, - 0xb8, 0x89, 0x1a, 0xa2, 0x2a, 0x78, 0x6b, 0xc8, 0x97, 0xe6, 0x21, 0x05, 0x96, 0x23, 0x2d, 0x5a, 0x7d, 0x1e, 0xf7, - 0x89, 0x68, 0x9f, 0xba, 0x70, 0x3a, 0x2e, 0x33, 0x36, 0x87, 0xba, 0xc8, 0x8f, 0x49, 0xdb, 0x03, 0x06, 0x96, 0x7a, - 0xa2, 0x8d, 0x0f, 0x5d, 0xc4, 0x6d, 0x77, 0x06, 0xd2, 0xf5, 0x72, 0x1a, 0x4a, 0x66, 0x31, 0x70, 0xe1, 0x68, 0xcc, - 0xe3, 0x06, 0x9d, 0x76, 0xc5, 0x46, 0x64, 0x77, 0x30, 0x5c, 0x89, 0x51, 0xd5, 0x61, 0xec, 0x2e, 0x6a, 0x4e, 0xb0, - 0x52, 0x3d, 0xf6, 0x59, 0x74, 0x40, 0x82, 0x27, 0x14, 0x1c, 0x79, 0xe0, 0x11, 0x3e, 0xab, 0x83, 0x0e, 0x8f, 0x3a, - 0x03, 0xab, 0xea, 0x06, 0xdb, 0xea, 0x30, 0x06, 0xca, 0x11, 0x84, 0x22, 0xf2, 0xdd, 0x82, 0x3a, 0x85, 0xc7, 0xfc, - 0x86, 0x30, 0xa5, 0xf4, 0x7c, 0xce, 0xf6, 0xe2, 0xdb, 0x01, 0xfb, 0xdd, 0x27, 0x5e, 0xd2, 0x35, 0x8c, 0xc3, 0x0f, - 0xff, 0xaa, 0xc5, 0xf2, 0xeb, 0x01, 0xe6, 0xf7, 0x41, 0xaa, 0x4b, 0x58, 0xcb, 0x19, 0xc0, 0x1f, 0x6d, 0x19, 0x77, - 0x0d, 0x86, 0xf5, 0x11, 0x2a, 0x22, 0x3c, 0xe2, 0xa0, 0x7f, 0xaa, 0x05, 0x80, 0xe2, 0x38, 0xad, 0x80, 0xc8, 0x42, - 0x34, 0x3f, 0x2f, 0x67, 0x5f, 0x96, 0x65, 0x68, 0x4b, 0x4b, 0x56, 0x8f, 0x13, 0x69, 0xd8, 0x4c, 0x82, 0x4a, 0x88, - 0x5e, 0x11, 0x31, 0x22, 0x66, 0x86, 0xd6, 0x4b, 0xfb, 0x3d, 0x75, 0x57, 0x10, 0x46, 0xad, 0xdb, 0x70, 0xaf, 0xeb, - 0x51, 0x6f, 0xa4, 0xd9, 0xaf, 0xb5, 0x32, 0x80, 0x7d, 0x4b, 0xbe, 0xc0, 0x91, 0x84, 0x2d, 0xed, 0xf8, 0xef, 0x03, - 0xb1, 0xe8, 0x1f, 0x42, 0xd8, 0xc4, 0x26, 0xc8, 0x19, 0xbc, 0xd4, 0x3a, 0x7b, 0x1b, 0x24, 0xc2, 0x24, 0xd6, 0x6a, - 0x3d, 0x85, 0x24, 0x9a, 0x00, 0x52, 0xa1, 0x7d, 0xc6, 0xf4, 0x8a, 0x54, 0x9c, 0x3f, 0xdf, 0xb5, 0x6c, 0xae, 0x9a, - 0xf2, 0x89, 0x95, 0x23, 0xce, 0xd6, 0x4f, 0x96, 0x24, 0x9b, 0xf0, 0x5d, 0x22, 0xc1, 0x37, 0x16, 0xbb, 0xca, 0xab, - 0x7c, 0x0d, 0x9a, 0x14, 0x02, 0x1d, 0x5c, 0xee, 0x1c, 0x32, 0xd4, 0x62, 0x19, 0xd5, 0xd1, 0x16, 0x8b, 0x4c, 0xef, - 0x77, 0xca, 0xea, 0xb3, 0x08, 0x0d, 0x27, 0x16, 0xc3, 0x28, 0x95, 0x5e, 0x6c, 0xd1, 0xca, 0x9f, 0xf4, 0x7f, 0xc8, - 0x02, 0xa5, 0xea, 0x78, 0x89, 0x5b, 0x35, 0x74, 0x87, 0xae, 0xa8, 0x37, 0xa2, 0xb5, 0x63, 0xff, 0xf2, 0xc6, 0xa4, - 0x8e, 0x35, 0x6d, 0x10, 0xbc, 0x0e, 0xfa, 0x99, 0x29, 0x38, 0xd9, 0x78, 0x15, 0xe9, 0x14, 0x06, 0x04, 0x0a, 0x61, - 0x08, 0xf6, 0x19, 0xc9, 0xa6, 0xa5, 0x74, 0x67, 0x17, 0x27, 0xea, 0xd8, 0x38, 0x33, 0xca, 0xda, 0x45, 0xbc, 0xb4, - 0xf1, 0xd6, 0x13, 0x7a, 0xf1, 0xbd, 0x78, 0xb6, 0xe2, 0xa4, 0xb6, 0x8c, 0x88, 0x17, 0x1c, 0x0f, 0x97, 0x31, 0x87, - 0x6a, 0xe3, 0xd6, 0x82, 0x1e, 0x13, 0x5a, 0x0d, 0x9b, 0x9d, 0xb5, 0x9c, 0xf2, 0xb5, 0x18, 0x17, 0xe5, 0x8b, 0x37, - 0x0b, 0x28, 0x03, 0x42, 0x47, 0x8b, 0x48, 0x02, 0x9f, 0x15, 0x76, 0x63, 0x8e, 0x27, 0xc9, 0x92, 0xf9, 0xb5, 0x92, - 0x47, 0x80, 0x99, 0x18, 0x2e, 0xde, 0x86, 0xac, 0x9e, 0xa0, 0x4b, 0x76, 0xb0, 0x52, 0x37, 0x08, 0xb2, 0x04, 0x3b, - 0xc0, 0x5f, 0x78, 0x3f, 0xc6, 0xde, 0x39, 0xbf, 0xd9, 0x3a, 0xfc, 0x3f, 0xc1, 0x83, 0x79, 0x58, 0xdb, 0xee, 0x17, - 0x1b, 0xf5, 0xe5, 0xff, 0x4f, 0x75, 0x0d, 0xad, 0x03, 0x1f, 0x3e, 0x80, 0xf0, 0x78, 0x79, 0xa8, 0x45, 0xab, 0xad, - 0xbd, 0xc3, 0x90, 0x4c, 0x9c, 0x28, 0x2b, 0x76, 0x54, 0xef, 0x50, 0xb4, 0x9b, 0xf9, 0xb3, 0x23, 0x03, 0xd4, 0x3f, - 0x98, 0x78, 0x1f, 0x34, 0xd2, 0xdd, 0x2f, 0x20, 0x13, 0xeb, 0x51, 0x87, 0x5c, 0xa5, 0xf4, 0xf3, 0x73, 0xf7, 0xd6, - 0x7d, 0x94, 0xae, 0xd2, 0xc1, 0xfd, 0x45, 0x57, 0xed, 0xc1, 0x06, 0x17, 0x3b, 0xc5, 0xad, 0x5a, 0xfb, 0xa4, 0x74, - 0x95, 0x25, 0x3e, 0x04, 0x20, 0xc0, 0x56, 0x99, 0xc9, 0xca, 0x53, 0xbe, 0x85, 0x84, 0x77, 0xad, 0x4f, 0x67, 0x7f, - 0xbd, 0x0e, 0x6f, 0x14, 0x6b, 0xbb, 0x8b, 0x47, 0x6b, 0x07, 0x04, 0xe5, 0xdc, 0x6b, 0x28, 0x27, 0x10, 0xe2, 0x25, - 0x62, 0xae, 0x00, 0x97, 0xc3, 0xc8, 0x78, 0x8a, 0x1c, 0x39, 0x44, 0xb7, 0x11, 0xc1, 0xba, 0x4a, 0x5b, 0x15, 0xc7, - 0x5e, 0xcb, 0x23, 0xb3, 0x85, 0x71, 0x13, 0x11, 0x87, 0x45, 0x05, 0x46, 0x9e, 0x86, 0x1d, 0xce, 0x76, 0x86, 0x5e, - 0xcd, 0x42, 0x16, 0xa4, 0x09, 0xdb, 0xa5, 0x7e, 0x1f, 0x4e, 0x4e, 0x58, 0x7d, 0xd5, 0x42, 0xec, 0x05, 0x70, 0x9a, - 0xbc, 0x35, 0xe4, 0x57, 0x67, 0x7a, 0x46, 0xb8, 0x2c, 0x92, 0x7b, 0x2c, 0x04, 0xa1, 0xb2, 0xb5, 0x5d, 0x26, 0xcb, - 0xd2, 0x31, 0xc4, 0xfb, 0x8c, 0x21, 0xcc, 0xf0, 0x82, 0x40, 0xa6, 0x09, 0x4a, 0x19, 0x7e, 0x0b, 0xf7, 0x5c, 0x60, - 0x6c, 0x90, 0x9b, 0xe9, 0x30, 0x12, 0xae, 0xe8, 0x76, 0x80, 0xc8, 0xd2, 0x7c, 0xa2, 0x58, 0x4d, 0x55, 0x87, 0x7d, - 0x67, 0x12, 0xa2, 0xf6, 0x88, 0xf5, 0x78, 0x4a, 0xb7, 0xdb, 0x49, 0xbe, 0xca, 0x5c, 0x8a, 0x21, 0xa2, 0x4a, 0x47, - 0xee, 0x92, 0x6b, 0xe2, 0x94, 0x58, 0x5a, 0x65, 0x1c, 0x24, 0xb4, 0x63, 0xa1, 0x6d, 0x3c, 0xa5, 0x07, 0x91, 0xb6, - 0x8b, 0x5d, 0x52, 0xa5, 0x93, 0xc7, 0xfc, 0x88, 0x18, 0x32, 0xd3, 0x2f, 0xb0, 0xb6, 0xbf, 0xdc, 0x7c, 0x0a, 0x47, - 0x45, 0x62, 0xe7, 0x8e, 0xc0, 0x1f, 0x03, 0x6c, 0x5e, 0x4a, 0x4b, 0x61, 0x54, 0xa1, 0x73, 0xd5, 0x56, 0x2f, 0x0c, - 0x65, 0x43, 0x88, 0x40, 0x32, 0xcb, 0x12, 0x3e, 0xca, 0x1a, 0x06, 0x39, 0xf5, 0xbd, 0x06, 0x64, 0xdb, 0x83, 0x60, - 0xf9, 0x48, 0x95, 0xa5, 0xbe, 0xbf, 0x7c, 0x36, 0x09, 0x1f, 0xeb, 0x10, 0x66, 0x19, 0x70, 0xcd, 0x7a, 0xef, 0x86, - 0xc6, 0xfd, 0x61, 0x06, 0xf5, 0x2f, 0x5c, 0xe9, 0x1b, 0x7c, 0x8d, 0x3c, 0x16, 0x2e, 0xf5, 0xc8, 0x7b, 0x4b, 0x9e, - 0x6d, 0x53, 0xf2, 0x99, 0x16, 0x2b, 0xde, 0xc0, 0x67, 0x11, 0xef, 0x5a, 0xf1, 0x7d, 0x59, 0xdd, 0xd9, 0x76, 0xe6, - 0x04, 0xd3, 0x0c, 0xf6, 0x60, 0x86, 0xee, 0xfa, 0xa0, 0x95, 0x4a, 0x53, 0x47, 0xfa, 0xf6, 0xc1, 0xc7, 0xad, 0xf7, - 0x7f, 0x21, 0x4d, 0x74, 0x03, 0x84, 0xa2, 0xd2, 0xd7, 0x21, 0xca, 0x0e, 0x69, 0x62, 0xda, 0xa1, 0x4a, 0x14, 0x1d, - 0x3a, 0x65, 0x96, 0xa5, 0x00, 0xc3, 0x37, 0x96, 0x1f, 0x29, 0x5c, 0x2b, 0xc9, 0x0d, 0x84, 0x5a, 0x83, 0xf8, 0x6c, - 0x32, 0xbd, 0x2f, 0xd3, 0x82, 0x02, 0x16, 0x4c, 0xbe, 0x8e, 0x61, 0x17, 0xe9, 0xef, 0xe6, 0x0d, 0x09, 0xce, 0x09, - 0x87, 0x23, 0x1b, 0x08, 0xa0, 0x4c, 0xdb, 0x05, 0x17, 0xf7, 0x1b, 0xca, 0x9f, 0x5b, 0x69, 0xcf, 0x90, 0x5a, 0x70, - 0x18, 0xe8, 0x25, 0xfa, 0xbf, 0xee, 0x0c, 0x1f, 0xca, 0xe3, 0x85, 0x83, 0x39, 0x11, 0x6e, 0x71, 0xf6, 0x95, 0x65, - 0x56, 0xb9, 0xe2, 0xfe, 0xc0, 0xc8, 0x44, 0x6b, 0xd7, 0xd7, 0x07, 0xab, 0x15, 0xb5, 0x0a, 0x35, 0xf4, 0x95, 0xfb, - 0x9f, 0xe9, 0x5e, 0xee, 0x99, 0x31, 0x0f, 0xc5, 0xdc, 0x61, 0x5e, 0x34, 0x34, 0x3e, 0x43, 0x34, 0x44, 0xa9, 0xb1, - 0x1a, 0x70, 0x32, 0x26, 0xf5, 0xf1, 0xa0, 0xc3, 0x52, 0x3a, 0x27, 0x46, 0x95, 0x5a, 0x64, 0x90, 0x60, 0x72, 0x3c, - 0x97, 0x36, 0x87, 0x02, 0x11, 0x34, 0xf3, 0x1a, 0x1a, 0xfd, 0x28, 0x87, 0x15, 0x6e, 0x2c, 0xcb, 0x25, 0x86, 0x8c, - 0x20, 0xa8, 0x2c, 0x1b, 0x37, 0x75, 0x93, 0xa0, 0x28, 0x9c, 0xfa, 0xb1, 0x41, 0x41, 0xf1, 0xdb, 0x99, 0x2f, 0x4d, - 0x76, 0xdc, 0x3d, 0x1a, 0xc0, 0xa2, 0x58, 0x97, 0x78, 0xd9, 0xc5, 0x44, 0x6e, 0x72, 0x83, 0x55, 0x46, 0x20, 0xe6, - 0xf0, 0x27, 0xa8, 0x92, 0x22, 0xa6, 0x8b, 0xb8, 0xb9, 0x34, 0x17, 0x47, 0x32, 0xb5, 0xab, 0x07, 0x6e, 0x43, 0xa3, - 0x5a, 0x4d, 0xf4, 0xda, 0x32, 0x3f, 0x91, 0x88, 0x4e, 0x58, 0x3c, 0x91, 0x57, 0x4c, 0x44, 0x12, 0x0c, 0x0c, 0x28, - 0xda, 0x16, 0x42, 0x51, 0xe8, 0x35, 0x9f, 0xae, 0x96, 0xf3, 0x73, 0xb9, 0x05, 0x49, 0xa1, 0xd1, 0xef, 0x13, 0x48, - 0xf5, 0xd3, 0xa6, 0x3f, 0x61, 0xf1, 0x3f, 0x89, 0x09, 0xb7, 0x3d, 0xf4, 0x0c, 0xc4, 0xa7, 0x1e, 0xe0, 0xd3, 0x53, - 0x07, 0x0a, 0xd3, 0xcb, 0x17, 0xc1, 0x83, 0x22, 0xea, 0xc6, 0x9c, 0x58, 0xf2, 0x18, 0x4a, 0x7c, 0x5f, 0x95, 0x4f, - 0x31, 0xa3, 0xda, 0x4a, 0xe1, 0x9e, 0x04, 0x8a, 0x26, 0xae, 0x64, 0xf3, 0x39, 0x65, 0x5c, 0x86, 0xe2, 0xe3, 0x84, - 0xf3, 0x86, 0xe5, 0x52, 0x16, 0x4a, 0x5e, 0xe1, 0xfd, 0x60, 0x0e, 0x21, 0xcb, 0x15, 0xa9, 0x21, 0xbf, 0x2a, 0x61, - 0x7f, 0x0f, 0xa4, 0x71, 0x05, 0x63, 0xb6, 0xf6, 0x0a, 0xeb, 0xc7, 0x62, 0xa5, 0x1f, 0x90, 0x6b, 0xc4, 0x3d, 0x1c, - 0x32, 0x00, 0xc3, 0x7e, 0x77, 0x44, 0xcd, 0x48, 0x85, 0x0b, 0x73, 0xf7, 0x92, 0x40, 0xc2, 0x36, 0x08, 0x9b, 0xed, - 0x8b, 0x79, 0xf8, 0xf8, 0x57, 0x6b, 0xce, 0x0e, 0xd6, 0x4a, 0xb8, 0x74, 0x74, 0x95, 0x09, 0xf2, 0xf2, 0x31, 0x12, - 0x67, 0x6e, 0xa7, 0xa9, 0x65, 0x41, 0x54, 0x5a, 0x8c, 0x67, 0x2b, 0x71, 0xb3, 0x4c, 0xe1, 0xb1, 0xc7, 0x04, 0xed, - 0xcc, 0x4b, 0x70, 0x09, 0x88, 0x3e, 0xc8, 0xf8, 0xca, 0x3a, 0x89, 0x5e, 0x79, 0x36, 0xfe, 0x2c, 0xbb, 0xf7, 0xa8, - 0xff, 0xaa, 0x48, 0xed, 0x7a, 0xd6, 0xdd, 0xa1, 0x24, 0x15, 0x4c, 0xbb, 0x1b, 0xf0, 0x71, 0xd2, 0x4f, 0x4c, 0xbe, - 0x51, 0x10, 0x37, 0xc0, 0xd9, 0x77, 0xe3, 0x40, 0xb7, 0x80, 0xf5, 0xe6, 0x83, 0x44, 0x03, 0x57, 0x23, 0xd2, 0xb9, - 0x59, 0xaf, 0xaf, 0x4d, 0x0b, 0x05, 0x20, 0x05, 0xb3, 0x92, 0x90, 0xbc, 0x2b, 0x17, 0x6d, 0x7d, 0x22, 0xb6, 0x00, - 0x62, 0xba, 0x81, 0xc4, 0x71, 0x44, 0xb9, 0xc6, 0xa3, 0x6f, 0x96, 0x1e, 0x3d, 0xeb, 0x88, 0xdd, 0x3f, 0x85, 0xd6, - 0xf4, 0xb2, 0x83, 0xed, 0x9c, 0x22, 0xa8, 0x50, 0x86, 0x8e, 0xea, 0xd9, 0x0d, 0x9b, 0x5b, 0xc7, 0xb2, 0xd0, 0xa3, - 0x87, 0x20, 0x96, 0xcc, 0x7b, 0xdb, 0x08, 0x8d, 0x10, 0xdf, 0xfd, 0x42, 0xc0, 0x38, 0x5a, 0xff, 0x42, 0xab, 0x6c, - 0xa8, 0xe3, 0xd4, 0xc6, 0x83, 0x8f, 0x9b, 0x55, 0x61, 0xe5, 0x92, 0xf9, 0xdc, 0xbb, 0x63, 0x8a, 0x7a, 0x2a, 0xdf, - 0x7a, 0x2d, 0x7b, 0x32, 0x3a, 0x6a, 0x68, 0x8f, 0x7c, 0xd2, 0xd6, 0xb7, 0x86, 0xad, 0x48, 0x1a, 0xc9, 0xa4, 0xb9, - 0xf3, 0xc1, 0x09, 0xb5, 0x79, 0xd8, 0x21, 0x71, 0xc2, 0xdc, 0xfa, 0xdd, 0x3c, 0x92, 0xb2, 0x78, 0x04, 0x5b, 0xf8, - 0x66, 0x68, 0xd3, 0x30, 0x26, 0x1d, 0x27, 0xe0, 0xba, 0xd2, 0x3f, 0xcd, 0xa0, 0xc4, 0x6a, 0x61, 0x61, 0x3c, 0x03, - 0x98, 0x8a, 0x29, 0xe2, 0xa5, 0x0a, 0x86, 0x1a, 0x24, 0xe7, 0x6a, 0x10, 0xcc, 0x74, 0xcc, 0xd8, 0x99, 0x97, 0x79, - 0x0f, 0x6d, 0x6d, 0xcc, 0xc2, 0x42, 0xcf, 0xc6, 0xd4, 0x3c, 0xaa, 0x14, 0x30, 0x35, 0x82, 0x6e, 0x87, 0x71, 0x71, - 0xb7, 0x47, 0x7e, 0x5a, 0x8e, 0x9c, 0x5d, 0x0c, 0x8e, 0xc7, 0x5e, 0x66, 0x8b, 0x53, 0x0f, 0x9e, 0x07, 0x98, 0x11, - 0x2a, 0x6c, 0x15, 0x2f, 0xd0, 0x9e, 0x35, 0xfd, 0x07, 0xbe, 0x89, 0x8d, 0x31, 0x98, 0x37, 0xc6, 0xd1, 0x9a, 0xa5, - 0x2b, 0xde, 0xd3, 0x30, 0x42, 0x16, 0x31, 0x22, 0xcb, 0x59, 0x53, 0xcc, 0xad, 0x54, 0x31, 0x9e, 0x41, 0x22, 0x58, - 0xbe, 0xc2, 0x54, 0x00, 0xe1, 0x60, 0x76, 0xa3, 0xc1, 0x6e, 0xd6, 0xc7, 0xb5, 0x7e, 0x04, 0x44, 0x60, 0x00, 0xd5, - 0xc5, 0x39, 0xd7, 0x26, 0x3a, 0x00, 0x96, 0xdf, 0x47, 0x00, 0x20, 0x09, 0xcc, 0x50, 0x24, 0xa0, 0xe8, 0x55, 0x4b, - 0x5f, 0xf3, 0x62, 0x0e, 0x9d, 0x1e, 0x0a, 0x82, 0x60, 0x2b, 0xf7, 0xe8, 0x34, 0x48, 0xb3, 0xb9, 0x41, 0x1f, 0xf1, - 0xed, 0x59, 0x51, 0x89, 0x83, 0xcb, 0xaf, 0x8a, 0xa0, 0xf8, 0x27, 0x43, 0xf6, 0x26, 0x63, 0xa6, 0x23, 0xde, 0xea, - 0xc8, 0xa3, 0x85, 0x7c, 0x31, 0x4e, 0x17, 0x9f, 0xa1, 0xd8, 0x43, 0x36, 0x28, 0xab, 0x64, 0xec, 0xc4, 0x93, 0xa1, - 0x11, 0x49, 0xfd, 0xe3, 0x30, 0xf7, 0x45, 0x3d, 0x8a, 0xd2, 0x3c, 0xad, 0x27, 0xd4, 0x8a, 0xa9, 0x76, 0x23, 0xb0, - 0x26, 0xe5, 0x99, 0xd0, 0x19, 0x5b, 0xea, 0x97, 0x0a, 0x52, 0x76, 0x6a, 0x4c, 0xc5, 0x4e, 0xce, 0x8b, 0x9c, 0xa3, - 0xa7, 0x3c, 0x08, 0xe3, 0xc0, 0xd8, 0x9f, 0x4e, 0x97, 0xd5, 0xee, 0xd9, 0x09, 0xe2, 0xf1, 0x6a, 0xa8, 0xf6, 0x21, - 0x5d, 0xab, 0x26, 0xa6, 0x40, 0xd3, 0x9e, 0xa6, 0xff, 0x25, 0x81, 0x3e, 0x0f, 0xc1, 0x9e, 0xe9, 0xb3, 0x91, 0x6a, - 0x07, 0xd1, 0xfe, 0xa0, 0x85, 0x77, 0xf8, 0x1a, 0x25, 0x54, 0xbf, 0xe7, 0x04, 0xe8, 0xf8, 0x06, 0x6b, 0xc4, 0x96, - 0x24, 0xce, 0xe7, 0x22, 0x95, 0x9d, 0x63, 0x46, 0x2d, 0x20, 0x17, 0x44, 0x81, 0xe7, 0x3a, 0x8d, 0xca, 0x42, 0x96, - 0xbc, 0xc1, 0x8d, 0x9f, 0xfd, 0x9a, 0x29, 0x14, 0xfe, 0x69, 0x38, 0x08, 0x58, 0x06, 0xb0, 0x30, 0x9f, 0x5e, 0x61, - 0xce, 0x99, 0x9d, 0x25, 0x0c, 0x59, 0x80, 0x96, 0x3a, 0x7a, 0x0b, 0x9d, 0x04, 0x00, 0x44, 0x47, 0xc5, 0x18, 0xc8, - 0xab, 0x1d, 0x55, 0x9f, 0xc0, 0xa1, 0x77, 0xd2, 0x73, 0x69, 0xee, 0x26, 0x10, 0x45, 0x08, 0x08, 0x90, 0xd8, 0x1a, - 0x0a, 0x22, 0x6f, 0x39, 0x88, 0xa8, 0x4a, 0xec, 0x04, 0xb7, 0x42, 0xb3, 0xe0, 0x46, 0x32, 0x22, 0x8d, 0x00, 0x7a, - 0x05, 0x08, 0x31, 0x23, 0x50, 0xe6, 0x3c, 0xd2, 0xf8, 0x05, 0x1e, 0x26, 0x2f, 0x44, 0xc1, 0xe7, 0x14, 0xb5, 0xde, - 0x83, 0xe8, 0x9e, 0x9b, 0xb3, 0xf6, 0xc7, 0x84, 0x10, 0x3d, 0x02, 0x6b, 0x28, 0xab, 0x7f, 0x45, 0x29, 0x60, 0x34, - 0xc0, 0xd9, 0xde, 0xe1, 0xdc, 0x63, 0xfe, 0x51, 0xf2, 0xa0, 0x0a, 0x1d, 0xf3, 0x88, 0x5c, 0x3a, 0x9f, 0x74, 0xab, - 0xb0, 0x5e, 0xd4, 0x0e, 0x6c, 0xb7, 0x1e, 0x8f, 0xd5, 0x4b, 0x75, 0xad, 0x41, 0x1a, 0x8a, 0xff, 0xa2, 0xfc, 0x68, - 0x0c, 0x95, 0xf3, 0x8b, 0xf1, 0xa0, 0x7b, 0xd1, 0x61, 0xbd, 0x8b, 0x5c, 0x40, 0x45, 0x09, 0x00, 0xb4, 0xdb, 0xa1, - 0x9d, 0x33, 0x9b, 0x7f, 0xbb, 0xfd, 0x85, 0xaf, 0x2c, 0x55, 0x8b, 0x3a, 0xcf, 0x1a, 0x0a, 0xce, 0xcb, 0x71, 0xfe, - 0x2f, 0x3c, 0xd8, 0xcb, 0x93, 0xce, 0x98, 0x2a, 0x42, 0x9c, 0xba, 0x33, 0xfb, 0x26, 0x1f, 0x87, 0x2d, 0x21, 0x76, - 0xaa, 0x9b, 0xbf, 0xd9, 0xcc, 0x83, 0xa9, 0xaf, 0x76, 0x80, 0x1b, 0x37, 0xb7, 0xcc, 0xd8, 0xab, 0xc7, 0xd0, 0x31, - 0x01, 0xe0, 0xad, 0x25, 0x8a, 0x22, 0xe2, 0x25, 0xe1, 0xdf, 0x1f, 0x8f, 0x0f, 0x55, 0xc3, 0x07, 0x7d, 0x1b, 0xef, - 0x44, 0xa1, 0x29, 0x30, 0xc1, 0x3a, 0x60, 0x98, 0x0f, 0xe8, 0x7b, 0x85, 0xcd, 0x8c, 0x1a, 0xdf, 0x76, 0xba, 0x28, - 0x40, 0x4c, 0x61, 0x70, 0xa5, 0xf1, 0x49, 0x5e, 0x64, 0x3c, 0xa8, 0x02, 0x6d, 0xde, 0x26, 0xfb, 0xaa, 0x30, 0x34, - 0x3c, 0xed, 0xd6, 0x43, 0x8f, 0x1d, 0x34, 0x8b, 0x5b, 0xc3, 0xf8, 0x85, 0x74, 0x90, 0xbf, 0xb1, 0xc9, 0x2c, 0x51, - 0xfc, 0xfe, 0x47, 0xe7, 0x24, 0xf7, 0x7c, 0xd0, 0x4e, 0x8a, 0x9a, 0x0a, 0x9d, 0x3f, 0x2b, 0x1f, 0x97, 0xf3, 0xb3, - 0xf0, 0xee, 0x2c, 0xd4, 0x1d, 0x59, 0x0a, 0x12, 0x39, 0x0d, 0x4d, 0xae, 0xd5, 0x62, 0xcd, 0x89, 0x8b, 0xb7, 0xb6, - 0xc5, 0x27, 0x70, 0xb3, 0xe4, 0x0c, 0x61, 0x2a, 0xde, 0xc4, 0x84, 0xe0, 0x30, 0x10, 0x14, 0x86, 0x8b, 0xe2, 0x10, - 0x09, 0x83, 0x37, 0x3b, 0x3c, 0xb1, 0x5b, 0x06, 0x1b, 0x5f, 0xcd, 0x1b, 0x65, 0x9e, 0xb1, 0x9e, 0x98, 0x81, 0x6a, - 0x16, 0x55, 0xd7, 0x8b, 0x01, 0x56, 0xff, 0x84, 0xd7, 0xd2, 0x89, 0xd9, 0x7a, 0x90, 0x25, 0xa9, 0x61, 0x53, 0x2e, - 0x51, 0x4d, 0x19, 0xdb, 0x58, 0x43, 0xc1, 0xb5, 0xc3, 0x23, 0xfd, 0xe1, 0xfa, 0x4f, 0xce, 0x67, 0x89, 0x67, 0xa1, - 0xe7, 0x2b, 0x87, 0xc0, 0x5a, 0xec, 0xb2, 0x76, 0x7d, 0xe8, 0x6b, 0x36, 0x47, 0x61, 0x1b, 0x0d, 0xa5, 0x74, 0x16, - 0x2f, 0x88, 0xae, 0x83, 0x32, 0x90, 0x2e, 0x1d, 0x26, 0x3a, 0x7b, 0x5f, 0x35, 0xeb, 0x0e, 0x34, 0xde, 0xf4, 0x88, - 0x44, 0x1b, 0xbb, 0x6a, 0x30, 0xaf, 0xe8, 0x9c, 0xa2, 0x9b, 0x63, 0x4b, 0xa0, 0xbf, 0xda, 0x1c, 0x6e, 0x4c, 0x5f, - 0x02, 0x31, 0xa5, 0x80, 0x7c, 0xcb, 0xa6, 0xe6, 0x9e, 0xf3, 0x40, 0x3e, 0x61, 0x2a, 0x34, 0x64, 0xed, 0x3a, 0xec, - 0xc6, 0x1a, 0x2f, 0x39, 0x22, 0xf5, 0xcf, 0xb5, 0x08, 0x0b, 0xaf, 0x2e, 0x58, 0xb6, 0xc5, 0x47, 0x27, 0xac, 0x49, - 0xd2, 0xb6, 0x87, 0x05, 0xb4, 0xd8, 0x61, 0x51, 0x9e, 0x5a, 0xcf, 0x25, 0x2e, 0x66, 0x62, 0x7c, 0x4d, 0x97, 0x2e, - 0x39, 0xb0, 0xec, 0x1c, 0x01, 0x8d, 0x07, 0x2b, 0xbd, 0x15, 0xbe, 0x55, 0x74, 0xbf, 0x6a, 0x46, 0x25, 0xce, 0x34, - 0x90, 0xd6, 0x0b, 0x58, 0x23, 0xd4, 0xb5, 0xfc, 0xc0, 0x19, 0xc7, 0x02, 0x6c, 0xcb, 0xf4, 0xfe, 0x76, 0x29, 0x2d, - 0xc4, 0x0e, 0x01, 0x9e, 0x71, 0x17, 0xfd, 0x03, 0xcd, 0x0a, 0x60, 0x4c, 0x4e, 0x4d, 0xc8, 0xc5, 0x7b, 0xdd, 0x10, - 0x32, 0xa6, 0x7f, 0xd2, 0x3e, 0xb6, 0x6c, 0x47, 0x87, 0x04, 0x1c, 0x19, 0x06, 0xc6, 0xad, 0x57, 0x29, 0x6b, 0x77, - 0x33, 0x1c, 0x23, 0xaa, 0xa5, 0x15, 0xf7, 0xcb, 0x44, 0x81, 0x67, 0xc0, 0x6e, 0x5c, 0x34, 0xed, 0xb5, 0x41, 0x2e, - 0x91, 0x9d, 0xc1, 0xab, 0x53, 0x45, 0x66, 0x61, 0x8c, 0x5d, 0x25, 0x0b, 0x3c, 0x3e, 0xf6, 0x84, 0x31, 0xfe, 0x27, - 0x29, 0x41, 0xf9, 0xfe, 0xbb, 0xa4, 0x93, 0x0a, 0x95, 0xc2, 0x1e, 0x4e, 0xaf, 0xe3, 0x2b, 0xfa, 0x2a, 0x11, 0x58, - 0xf3, 0xa8, 0x7e, 0xdc, 0x00, 0x83, 0xaa, 0x0d, 0x78, 0x74, 0x43, 0x29, 0xde, 0x54, 0xf8, 0x26, 0x77, 0xa1, 0x55, - 0x51, 0x8e, 0xca, 0x01, 0x6b, 0x8e, 0xdc, 0x1c, 0x59, 0x22, 0xd8, 0xb2, 0x76, 0x90, 0xa2, 0x02, 0xc3, 0x9e, 0x55, - 0x83, 0xb4, 0x2a, 0x3d, 0x1c, 0x19, 0x7f, 0x4d, 0x80, 0x16, 0x40, 0x18, 0x96, 0x3f, 0x33, 0x93, 0x8c, 0x97, 0x29, - 0x2b, 0xb9, 0xa9, 0xe6, 0x28, 0x9a, 0x98, 0x86, 0x4e, 0xee, 0xe9, 0x84, 0x1f, 0x6a, 0x8e, 0x38, 0x1b, 0x04, 0xb5, - 0x55, 0xd5, 0x3a, 0x83, 0x61, 0x50, 0x27, 0x1d, 0x01, 0xf2, 0x51, 0xd2, 0x60, 0xc2, 0x73, 0x73, 0x8e, 0x9e, 0xc7, - 0x79, 0x19, 0x96, 0x93, 0x76, 0x36, 0x4b, 0x00, 0x3e, 0xb5, 0x14, 0xb6, 0x90, 0x81, 0x31, 0x8c, 0x3f, 0x02, 0x72, - 0xc7, 0xa7, 0xcf, 0x4b, 0xcb, 0x1e, 0x95, 0x5e, 0xde, 0xfc, 0xf0, 0xf1, 0x07, 0x83, 0x37, 0x18, 0x2a, 0x1a, 0xbc, - 0x7b, 0xaf, 0x2f, 0xe9, 0x3b, 0x99, 0x60, 0xac, 0x41, 0xe7, 0x20, 0x8a, 0x55, 0x68, 0x47, 0xb6, 0x2a, 0xeb, 0x22, - 0x27, 0xdb, 0xd7, 0x27, 0xe5, 0xe7, 0x97, 0x22, 0x94, 0x6a, 0x41, 0x21, 0x6f, 0xb1, 0x8a, 0x0d, 0x42, 0x28, 0x54, - 0xe0, 0xa0, 0x08, 0x01, 0x8e, 0x22, 0xee, 0xee, 0x34, 0x14, 0x00, 0x52, 0x52, 0x14, 0xcc, 0xa9, 0xcb, 0xda, 0xdb, - 0x5c, 0x60, 0xb3, 0x73, 0xa6, 0xee, 0x23, 0x3e, 0xc7, 0x84, 0xd5, 0x39, 0x47, 0x8a, 0x04, 0xb2, 0xb6, 0xec, 0xd6, - 0x22, 0x4b, 0x75, 0x77, 0x34, 0x64, 0xc8, 0xac, 0x20, 0xe7, 0x5e, 0x3e, 0x2b, 0x10, 0x5a, 0x41, 0xfe, 0x93, 0x26, - 0x36, 0x60, 0x8c, 0x63, 0xfb, 0xc7, 0xef, 0x54, 0xf0, 0x37, 0x5f, 0xc3, 0x3d, 0xf9, 0x6d, 0x3a, 0xc1, 0x2a, 0xc5, - 0x60, 0x50, 0xf3, 0x2b, 0xe7, 0x4c, 0xaf, 0xcd, 0x18, 0x88, 0x89, 0x63, 0x56, 0xbe, 0x87, 0x57, 0xe9, 0x8b, 0x52, - 0xb4, 0x19, 0x54, 0xa4, 0x4c, 0x2a, 0x80, 0x84, 0x26, 0xed, 0x21, 0xf5, 0x1a, 0x4c, 0xca, 0xb2, 0x29, 0xb6, 0x69, - 0xae, 0xd4, 0xf6, 0xb1, 0xa3, 0xa6, 0xd6, 0x83, 0x32, 0x89, 0x87, 0x38, 0x7d, 0x16, 0x78, 0x1c, 0x63, 0x42, 0x88, - 0x14, 0x12, 0x7f, 0x71, 0xa6, 0xd5, 0xe3, 0x2b, 0x2a, 0xee, 0xb9, 0x8f, 0xa0, 0x63, 0x0c, 0x8d, 0xe9, 0x54, 0xb0, - 0x1b, 0xd2, 0x19, 0x12, 0x7b, 0x9d, 0x1b, 0x99, 0xee, 0xd6, 0xab, 0x0e, 0x1f, 0x8c, 0xcc, 0x4f, 0x79, 0xc7, 0xae, - 0xf7, 0x46, 0x06, 0x6b, 0x9d, 0xd2, 0xd3, 0x9a, 0xf2, 0xf4, 0x7f, 0xc3, 0x15, 0xee, 0xa8, 0x2e, 0x2d, 0x12, 0x5d, - 0x9e, 0x21, 0xc1, 0xb8, 0x48, 0x8a, 0xb4, 0xde, 0x25, 0x4c, 0x36, 0xbd, 0x62, 0xed, 0x9a, 0xd1, 0x65, 0x61, 0x7e, - 0xc8, 0xe6, 0x17, 0x5d, 0x8b, 0xf1, 0x0e, 0xac, 0xb3, 0xaf, 0xf2, 0xcc, 0x39, 0x46, 0x9e, 0xc1, 0x8c, 0x85, 0xbd, - 0x2a, 0xa8, 0x43, 0x5a, 0x58, 0x07, 0xa8, 0x1e, 0xa3, 0x28, 0xe3, 0xd1, 0x4b, 0x9b, 0x42, 0x7a, 0xa0, 0xdb, 0xee, - 0x95, 0x5f, 0x5e, 0x45, 0x85, 0x02, 0x20, 0x2e, 0x44, 0x58, 0x78, 0x34, 0x83, 0xc1, 0x05, 0x0a, 0x85, 0xb7, 0x39, - 0xe8, 0xc5, 0x35, 0x9c, 0xb7, 0x1f, 0xa4, 0xd4, 0x70, 0x8a, 0x29, 0x1d, 0x27, 0x5f, 0x70, 0x67, 0xbd, 0xac, 0x40, - 0x7e, 0x38, 0xb3, 0x16, 0xbb, 0x66, 0x97, 0x42, 0x36, 0xa4, 0xe8, 0xaa, 0xdd, 0xed, 0x9d, 0xb2, 0xb6, 0x67, 0xe6, - 0xc3, 0xb2, 0xa6, 0x68, 0x56, 0x12, 0x85, 0x9e, 0x43, 0x14, 0x43, 0xc5, 0xd0, 0xcc, 0xb5, 0x65, 0x5d, 0xd4, 0x52, - 0x0d, 0x95, 0xba, 0x46, 0x50, 0xd5, 0xcd, 0x51, 0xfd, 0x73, 0xd6, 0xe3, 0xdc, 0xb5, 0xc1, 0xd0, 0x7a, 0xf2, 0x30, - 0x5e, 0xc6, 0xea, 0x1c, 0x1f, 0x2f, 0x7c, 0x8e, 0x73, 0xdb, 0xbe, 0x57, 0xf7, 0x3b, 0x05, 0x6d, 0x59, 0x7c, 0x13, - 0xff, 0x83, 0xea, 0xff, 0xb2, 0x01, 0x23, 0x93, 0x8f, 0x0f, 0xcb, 0x99, 0xd6, 0x17, 0x59, 0x4c, 0x76, 0xe4, 0xb1, - 0x33, 0x4d, 0x9e, 0xb1, 0xb0, 0x57, 0x77, 0x6f, 0x23, 0x67, 0xc1, 0x61, 0x73, 0xe6, 0x10, 0x06, 0xb2, 0x32, 0xfe, - 0xb0, 0x65, 0xb4, 0x6e, 0x9d, 0x36, 0x75, 0xf8, 0x30, 0x34, 0x31, 0xd9, 0x6b, 0x3c, 0xc5, 0x10, 0xe6, 0xd9, 0x94, - 0xb1, 0x2d, 0xe0, 0x45, 0x65, 0x28, 0xe2, 0x32, 0xae, 0x39, 0x82, 0x29, 0xad, 0x06, 0xf6, 0x59, 0x45, 0xf1, 0x1c, - 0x55, 0xba, 0xa8, 0x9e, 0xdb, 0x37, 0x3d, 0x60, 0x48, 0x46, 0xce, 0x7e, 0xb9, 0xfa, 0x18, 0x1a, 0x58, 0xb7, 0xa3, - 0xaf, 0x06, 0x3c, 0x43, 0x24, 0xfa, 0xbc, 0x33, 0x36, 0x20, 0xb6, 0x58, 0x99, 0xe5, 0x50, 0x48, 0xfe, 0x71, 0x3b, - 0x5c, 0xc6, 0xea, 0x53, 0x7e, 0xa4, 0x2f, 0x59, 0xec, 0x86, 0xa6, 0xd6, 0xc1, 0x5f, 0xa9, 0x0a, 0x22, 0xe5, 0x5d, - 0x4b, 0x75, 0x97, 0x21, 0x6d, 0x4a, 0x3d, 0xfa, 0x7b, 0xa0, 0x2c, 0x8d, 0x58, 0x89, 0xa5, 0x51, 0x35, 0x26, 0xfe, - 0xef, 0xf4, 0x29, 0x3a, 0x23, 0x3f, 0xb5, 0xb0, 0xe2, 0xbe, 0x22, 0x16, 0x2e, 0xe1, 0x98, 0xe9, 0xd5, 0x16, 0x1d, - 0x15, 0x22, 0x28, 0xe0, 0xb3, 0x45, 0xef, 0xcd, 0x86, 0x4c, 0x04, 0x8d, 0xb7, 0x79, 0x7a, 0x1d, 0x4f, 0xf7, 0xf3, - 0x19, 0xd9, 0x11, 0x9a, 0x2e, 0xac, 0x4d, 0x41, 0xe1, 0x20, 0x70, 0x6e, 0x21, 0xd0, 0x5c, 0x95, 0x81, 0x09, 0x8e, - 0xf3, 0x62, 0xcb, 0x27, 0x50, 0x9d, 0xee, 0x81, 0x34, 0xa8, 0x5a, 0x9e, 0x6a, 0x95, 0xba, 0x8f, 0xe9, 0xb4, 0xd5, - 0x3a, 0x6b, 0x83, 0x52, 0xfc, 0x00, 0xbb, 0xa0, 0x80, 0x56, 0x2f, 0x51, 0x82, 0xb8, 0x39, 0x34, 0x5f, 0xca, 0x5e, - 0x33, 0xe7, 0x68, 0xef, 0xd0, 0x92, 0x71, 0x41, 0xfb, 0xfb, 0xfb, 0x03, 0x21, 0x73, 0x14, 0xad, 0x83, 0xa6, 0x64, - 0x2e, 0xf7, 0x88, 0xab, 0x48, 0xe5, 0x9f, 0x17, 0x6c, 0xa8, 0xe0, 0xe5, 0xf6, 0x77, 0xa8, 0x1f, 0x16, 0x75, 0xd1, - 0x7e, 0x0b, 0xf1, 0x1a, 0xf9, 0x47, 0xf0, 0xfe, 0x28, 0x20, 0x1a, 0x7e, 0x9a, 0xf0, 0x3b, 0x68, 0xb3, 0x57, 0xf7, - 0x0b, 0xdf, 0xf7, 0x7d, 0x8b, 0xdd, 0xe0, 0xad, 0xef, 0x9f, 0x3a, 0x58, 0x85, 0xc3, 0x1e, 0xb8, 0x9e, 0x18, 0xdd, - 0xfe, 0xfc, 0xfc, 0xbe, 0x86, 0x8a, 0x2f, 0xce, 0xb0, 0x9b, 0xa9, 0x7c, 0xa0, 0xee, 0x9d, 0xdc, 0xd2, 0x7e, 0xa1, - 0xe6, 0x35, 0x04, 0xa4, 0x5c, 0x38, 0x27, 0xae, 0x4f, 0x0a, 0x5c, 0x81, 0x16, 0x52, 0x3a, 0xba, 0x2d, 0xf1, 0x9e, - 0x35, 0xa4, 0xfd, 0xb0, 0x01, 0x36, 0x9d, 0xf6, 0x1d, 0x52, 0x71, 0x98, 0xc9, 0xd2, 0x6c, 0x42, 0xfe, 0x6b, 0x8e, - 0x3a, 0x55, 0x07, 0xf7, 0x79, 0xb1, 0x2e, 0x0c, 0xeb, 0x6e, 0x3c, 0xce, 0x9f, 0xaa, 0x3d, 0x61, 0xc4, 0x0d, 0x63, - 0x75, 0xc8, 0x6f, 0x90, 0x06, 0xf4, 0x76, 0x34, 0x93, 0x22, 0xfb, 0x81, 0x00, 0x80, 0xaf, 0xd6, 0x8c, 0xa5, 0x41, - 0xd9, 0x37, 0xfd, 0x1c, 0x2a, 0x34, 0x41, 0x8c, 0xca, 0x5e, 0x03, 0x24, 0xe0, 0x22, 0x5b, 0x97, 0xc5, 0x7b, 0xa1, - 0x22, 0xa1, 0x5b, 0x97, 0xd0, 0xa9, 0xde, 0xc9, 0x10, 0x56, 0x5d, 0x22, 0xc2, 0x9c, 0xf6, 0x84, 0xaf, 0xeb, 0x7c, - 0xf8, 0x3c, 0x16, 0x7b, 0xce, 0xd3, 0xcf, 0xb0, 0xb9, 0x30, 0x0d, 0x0d, 0x44, 0x33, 0x0e, 0xdd, 0x8f, 0xd4, 0x96, - 0xe2, 0xd6, 0xac, 0x62, 0x3c, 0xfe, 0x72, 0x5e, 0x55, 0x64, 0xfd, 0xe5, 0x22, 0xc3, 0x14, 0xe1, 0x66, 0x16, 0xf5, - 0xf2, 0xa2, 0x10, 0x66, 0xa7, 0x8b, 0x06, 0x82, 0x66, 0xb4, 0x6d, 0x3d, 0xb8, 0xa1, 0xb4, 0x11, 0xfa, 0x45, 0x95, - 0x68, 0x6d, 0xd5, 0xf7, 0xfd, 0x06, 0xd9, 0xe5, 0x1c, 0x07, 0x6d, 0x5e, 0xc0, 0xf1, 0xbd, 0x7f, 0xea, 0x97, 0xab, - 0xbd, 0x75, 0x9a, 0xbf, 0xe0, 0x16, 0x5f, 0x90, 0xb0, 0xfc, 0x30, 0xc3, 0x41, 0x29, 0x21, 0xc3, 0xc9, 0x47, 0x38, - 0x17, 0xd6, 0xe8, 0x92, 0xcf, 0xf6, 0x5c, 0x18, 0xe8, 0x60, 0x45, 0xb4, 0x23, 0xbe, 0xe1, 0xa7, 0xba, 0x2d, 0x44, - 0x10, 0x3b, 0x58, 0xc6, 0x80, 0x67, 0x64, 0x72, 0x22, 0xa3, 0x3a, 0x4c, 0x60, 0x9a, 0x4d, 0x98, 0x06, 0x76, 0x9b, - 0x00, 0x9a, 0x3a, 0x18, 0xa7, 0x38, 0x03, 0x7d, 0x18, 0xaa, 0xad, 0x67, 0x25, 0x19, 0xf3, 0x81, 0xa0, 0x9d, 0xed, - 0x8f, 0x1a, 0x65, 0x5e, 0x6c, 0x37, 0xdb, 0x48, 0xf3, 0xaa, 0x14, 0x43, 0x3b, 0x90, 0xd9, 0x91, 0x34, 0x64, 0xea, - 0x1e, 0xd4, 0xb8, 0x50, 0xa8, 0x36, 0x0c, 0xc2, 0x01, 0x4a, 0x91, 0xa6, 0x39, 0xf5, 0x08, 0xb3, 0xe8, 0xd6, 0x14, - 0xde, 0x59, 0x66, 0xb8, 0x5a, 0x22, 0xa0, 0x04, 0x11, 0xc7, 0x5d, 0x74, 0x18, 0xc5, 0x83, 0xbd, 0x51, 0x77, 0x4a, - 0xa8, 0xaf, 0x5c, 0x2c, 0xd6, 0xa3, 0xad, 0x16, 0x7b, 0x82, 0x69, 0x5a, 0xd7, 0xfb, 0x81, 0x18, 0xed, 0xf9, 0x66, - 0x22, 0x55, 0xea, 0x12, 0x54, 0x95, 0xde, 0xb7, 0x1f, 0xb2, 0x8a, 0x3d, 0x86, 0xc7, 0x4a, 0xa5, 0x44, 0xb1, 0x53, - 0xd3, 0xce, 0xe2, 0x34, 0x45, 0xda, 0x65, 0x99, 0x78, 0x13, 0xfa, 0x1d, 0x49, 0xbb, 0x2d, 0xb3, 0xb6, 0x17, 0x8b, - 0x9b, 0x93, 0x48, 0xb1, 0x1c, 0xac, 0x35, 0xbc, 0x2d, 0x73, 0xec, 0x82, 0xb7, 0x39, 0xb7, 0x7e, 0xc1, 0x58, 0x43, - 0xeb, 0x33, 0xd6, 0xdf, 0xa4, 0x47, 0x46, 0x14, 0xa0, 0xfa, 0x37, 0x59, 0x08, 0x12, 0x37, 0xcc, 0xf8, 0x1d, 0xb5, - 0x61, 0x51, 0x5d, 0xd4, 0x3d, 0x4b, 0xac, 0x88, 0x58, 0x38, 0x7f, 0x5f, 0x9d, 0x05, 0x72, 0xe9, 0x6c, 0xc5, 0x35, - 0x0f, 0x47, 0x5d, 0x76, 0x3d, 0xb8, 0x53, 0x18, 0x53, 0xf3, 0xc9, 0x42, 0xf5, 0x86, 0x7b, 0x2e, 0x3e, 0xd7, 0x12, - 0x5e, 0x57, 0xfb, 0xdc, 0x9c, 0xe6, 0xf2, 0x2d, 0x2e, 0xab, 0x2a, 0xb5, 0x99, 0xc0, 0xa4, 0x6b, 0xad, 0xfe, 0x38, - 0x82, 0x35, 0x14, 0x91, 0xb8, 0x49, 0xd4, 0xc1, 0x66, 0x59, 0x87, 0x72, 0x9b, 0x09, 0x56, 0x92, 0x0d, 0xf6, 0x80, - 0x70, 0x6a, 0xb1, 0x99, 0x63, 0xa7, 0x0d, 0xe1, 0xf0, 0x1d, 0xb7, 0xa6, 0x88, 0x8a, 0x53, 0x77, 0xe1, 0xa9, 0x65, - 0xf9, 0xc3, 0xec, 0x6a, 0x4d, 0xd3, 0xf5, 0x1d, 0x6a, 0x64, 0x49, 0xb8, 0x72, 0x2f, 0x63, 0x98, 0x0f, 0x2d, 0xe4, - 0x59, 0xaa, 0x8e, 0x60, 0xd0, 0xd2, 0x2d, 0x37, 0xfc, 0x7d, 0xf8, 0x74, 0x5c, 0x6b, 0x22, 0xda, 0x38, 0xbe, 0xdc, - 0x43, 0x2a, 0x27, 0xfb, 0x49, 0xcc, 0x0b, 0x95, 0xd3, 0xe9, 0x49, 0x91, 0x80, 0x87, 0x9b, 0xb8, 0x70, 0x89, 0x72, - 0x2d, 0xcb, 0x74, 0x35, 0xc9, 0xa9, 0xa1, 0x42, 0xce, 0x8c, 0xa1, 0xc5, 0xfb, 0x59, 0xc4, 0x30, 0x63, 0x13, 0x66, - 0x66, 0x53, 0x53, 0xd3, 0x0e, 0x45, 0xee, 0x43, 0x25, 0x8f, 0xc4, 0x64, 0xe5, 0xd0, 0x38, 0x3a, 0x35, 0xdd, 0x63, - 0x70, 0x5d, 0x21, 0x9c, 0x6a, 0x54, 0xfb, 0x01, 0x74, 0x71, 0xfe, 0x85, 0xdb, 0x51, 0xbf, 0x1c, 0x8c, 0x7e, 0x6b, - 0x54, 0x13, 0x95, 0xf9, 0xd0, 0x0c, 0x5d, 0x3b, 0x32, 0x98, 0x1c, 0x03, 0xe0, 0x26, 0x13, 0x84, 0x0d, 0x1f, 0x57, - 0x60, 0x16, 0x7b, 0xaa, 0xaf, 0x7f, 0x0e, 0x52, 0x38, 0x97, 0xa9, 0x67, 0x61, 0xd4, 0x72, 0x80, 0x4b, 0x03, 0x0b, - 0xe3, 0x4a, 0x43, 0x0c, 0x9b, 0xdf, 0x8f, 0xb6, 0x89, 0x4c, 0xd2, 0x3d, 0xab, 0x29, 0x00, 0x9a, 0x4e, 0x41, 0xe4, - 0xdf, 0xa3, 0xe4, 0x05, 0xc7, 0xd1, 0x29, 0x3d, 0xfd, 0xa2, 0xd4, 0xa3, 0x19, 0xb4, 0xf7, 0x78, 0x75, 0xc1, 0xac, - 0x27, 0x23, 0xed, 0x88, 0x87, 0xd9, 0x09, 0xe4, 0x07, 0x48, 0x4d, 0xe9, 0x5a, 0x73, 0x63, 0xf7, 0x35, 0xc8, 0x96, - 0xed, 0x68, 0x90, 0xc3, 0x1a, 0xf9, 0x1a, 0x54, 0xca, 0xa1, 0x7c, 0x93, 0xcc, 0xe3, 0x24, 0xd8, 0xd7, 0xc8, 0xed, - 0x3b, 0xee, 0x6b, 0xb6, 0xb7, 0x43, 0x52, 0x1d, 0x92, 0xb0, 0xef, 0xb6, 0x69, 0x92, 0xe0, 0x70, 0x83, 0x0c, 0xc2, - 0x05, 0x6c, 0x64, 0xe8, 0xdb, 0xeb, 0x46, 0x21, 0x9a, 0xef, 0x1a, 0x7c, 0xaf, 0xee, 0x8b, 0x37, 0x66, 0x30, 0x49, - 0x92, 0x44, 0x60, 0x36, 0x53, 0x1a, 0x13, 0xe5, 0x1b, 0xc3, 0x73, 0xb5, 0xe7, 0x07, 0xe5, 0x5c, 0x4b, 0xd8, 0x33, - 0x1d, 0xbf, 0x1d, 0x8d, 0x57, 0xa5, 0xdf, 0xe0, 0x55, 0x52, 0x12, 0xdd, 0xf9, 0xfb, 0x00, 0x8e, 0xbc, 0x29, 0xeb, - 0x17, 0xf3, 0x1d, 0xa7, 0xc7, 0xd2, 0xe6, 0xed, 0x26, 0x2e, 0xf0, 0x37, 0x4f, 0xa4, 0x5e, 0xf1, 0xa5, 0xa6, 0x49, - 0xbf, 0x6e, 0xf1, 0x60, 0x17, 0x30, 0x79, 0xcb, 0x0d, 0xb3, 0x06, 0x7d, 0xb3, 0xca, 0x4d, 0xdf, 0x42, 0x79, 0x58, - 0xce, 0x63, 0x9e, 0x3a, 0x84, 0x5f, 0x3c, 0xaa, 0x43, 0x65, 0x34, 0xb7, 0x66, 0x27, 0xf4, 0x37, 0x98, 0xd7, 0xdc, - 0xc1, 0x0c, 0x27, 0xb2, 0x24, 0x0d, 0x6f, 0x7a, 0x7a, 0x3b, 0xca, 0x3c, 0x08, 0x42, 0x92, 0x22, 0xda, 0x06, 0x76, - 0xd0, 0x82, 0x0a, 0xb8, 0x41, 0xd4, 0xec, 0x3d, 0x62, 0xb6, 0x97, 0x76, 0x1f, 0xe7, 0xbd, 0x77, 0x3c, 0x59, 0x13, - 0x21, 0x67, 0x08, 0xa1, 0xf8, 0x7b, 0xda, 0xcf, 0x61, 0xcf, 0x08, 0x57, 0x5a, 0xa1, 0x60, 0xc4, 0x0d, 0xaa, 0x7e, - 0xcc, 0x16, 0x10, 0x2d, 0x12, 0x90, 0xb3, 0x5d, 0x0b, 0x6b, 0x26, 0x33, 0xf9, 0x49, 0x0c, 0x95, 0xd4, 0xb6, 0x7c, - 0xc3, 0x7f, 0xae, 0x0a, 0x49, 0x60, 0x31, 0x27, 0x75, 0xdf, 0x47, 0x12, 0x8b, 0x9b, 0x35, 0x9b, 0x87, 0x72, 0xed, - 0xf3, 0x72, 0xac, 0xbd, 0x83, 0xbe, 0x50, 0x71, 0x59, 0x2e, 0xaf, 0x4a, 0xbb, 0x44, 0x5d, 0xeb, 0x30, 0xb4, 0xa4, - 0xb4, 0x62, 0xd8, 0x87, 0x56, 0xf5, 0xc8, 0x91, 0xc3, 0xdf, 0x03, 0x69, 0xb8, 0xbb, 0xcc, 0xf0, 0xe6, 0xa5, 0xeb, - 0x5d, 0x34, 0x6d, 0xa5, 0x22, 0xe1, 0x4e, 0x6e, 0xbb, 0xa2, 0x33, 0x24, 0x88, 0x58, 0x0f, 0x1f, 0xe5, 0x87, 0x0b, - 0x86, 0x55, 0x8a, 0x36, 0xa4, 0xdb, 0x6c, 0x2e, 0x33, 0x37, 0x92, 0xb2, 0xdd, 0x9f, 0x56, 0xbd, 0x09, 0xaa, 0x75, - 0xa2, 0x36, 0xcf, 0xed, 0xb6, 0xd8, 0xba, 0x67, 0x00, 0xf5, 0x93, 0x33, 0x85, 0x23, 0x26, 0x88, 0x89, 0x56, 0x29, - 0x17, 0x61, 0xe6, 0x11, 0x0c, 0xf7, 0xd6, 0xfc, 0x84, 0xd8, 0xc7, 0x8b, 0x1c, 0x3f, 0xa6, 0x07, 0xb8, 0xe7, 0x13, - 0xb7, 0xcf, 0x69, 0x92, 0x83, 0xec, 0x88, 0xed, 0x46, 0xf1, 0x90, 0x8b, 0xee, 0x86, 0x4d, 0x25, 0x2c, 0x13, 0xe7, - 0xaa, 0xe5, 0xda, 0x18, 0x94, 0x0a, 0x45, 0x45, 0xee, 0x23, 0x65, 0xf1, 0xfb, 0x49, 0x55, 0xbe, 0x07, 0x91, 0xd8, - 0xf6, 0x49, 0x04, 0x52, 0xfd, 0xa3, 0xa0, 0x94, 0x12, 0xe6, 0xa5, 0x91, 0x67, 0xea, 0x4f, 0x28, 0x65, 0xc1, 0x43, - 0xc0, 0x17, 0x07, 0x9c, 0x0b, 0x6d, 0xfd, 0xf7, 0xb9, 0xee, 0x79, 0x3a, 0xf4, 0x92, 0xc2, 0x9d, 0xa3, 0xba, 0x4b, - 0xe4, 0x4e, 0xc9, 0xf8, 0x14, 0xa7, 0xe8, 0x41, 0xae, 0xd5, 0xb7, 0xdd, 0xbe, 0xa1, 0x6b, 0xbc, 0x7c, 0xa2, 0xf8, - 0xd6, 0xa6, 0xf2, 0x47, 0x51, 0xa7, 0xd3, 0x18, 0x9b, 0xec, 0x99, 0x72, 0x26, 0x17, 0x67, 0xb9, 0x9f, 0x1a, 0x0c, - 0x8d, 0x78, 0xc4, 0xd5, 0x12, 0xeb, 0xec, 0x3d, 0x66, 0x15, 0x27, 0xbc, 0x21, 0x0d, 0x04, 0xa8, 0xa4, 0x17, 0x1c, - 0xd1, 0x17, 0x68, 0xcb, 0xfa, 0xd2, 0xdd, 0xed, 0x47, 0x7a, 0xdc, 0xc1, 0xd1, 0x68, 0x55, 0x45, 0xbe, 0x4e, 0x0e, - 0x2a, 0xb9, 0x10, 0xa2, 0xd6, 0xf3, 0x1b, 0xd8, 0x42, 0xf3, 0x8b, 0xc9, 0x82, 0xfe, 0x2e, 0x6b, 0x4e, 0xd9, 0x7f, - 0xd6, 0xca, 0xb5, 0x21, 0x40, 0x1e, 0x17, 0xe4, 0xee, 0x15, 0xb8, 0x4c, 0x88, 0xfa, 0xc3, 0x7d, 0xcf, 0x76, 0x22, - 0xf2, 0xa1, 0x46, 0x8b, 0x45, 0xaf, 0x2a, 0x64, 0xbf, 0x3d, 0x1b, 0x77, 0xce, 0x1c, 0xf8, 0x3d, 0x2f, 0xbc, 0x92, - 0x4f, 0xfc, 0x86, 0x86, 0xf4, 0x1e, 0xd6, 0xb3, 0xa2, 0x6b, 0x16, 0x80, 0x52, 0x43, 0x0a, 0x7d, 0x0d, 0xdb, 0x73, - 0x50, 0x69, 0x9f, 0x79, 0x51, 0x8a, 0x80, 0xf1, 0x8d, 0xdd, 0x33, 0xf9, 0x54, 0x56, 0xc4, 0x25, 0x62, 0x96, 0x0e, - 0x18, 0x60, 0x64, 0x8e, 0x91, 0x51, 0xad, 0x1e, 0xaf, 0x70, 0x07, 0x8e, 0x94, 0x60, 0xab, 0xfd, 0xf3, 0xb8, 0x49, - 0xe6, 0xcf, 0x1c, 0x94, 0xfa, 0x84, 0xbc, 0xe7, 0x12, 0x82, 0xf1, 0xfc, 0xe4, 0x40, 0x75, 0xae, 0xc5, 0x06, 0x7b, - 0x3d, 0x67, 0x39, 0xce, 0xbc, 0x07, 0x46, 0xb0, 0xf5, 0xaf, 0xe2, 0x1f, 0xcb, 0x13, 0x77, 0x8b, 0x07, 0x31, 0xa9, - 0x95, 0xd3, 0xb5, 0x36, 0x5b, 0xe8, 0x6e, 0x20, 0xc3, 0x99, 0xe6, 0xcd, 0x9a, 0xba, 0xdc, 0x54, 0xc3, 0xc0, 0x6a, - 0xe6, 0x84, 0x5c, 0xcc, 0x91, 0xf8, 0x2f, 0x18, 0xe7, 0x66, 0x0d, 0x65, 0x2e, 0xc7, 0x66, 0x72, 0x09, 0xe4, 0xea, - 0x14, 0xfb, 0xcd, 0x3f, 0xfc, 0x06, 0x54, 0xc2, 0xf2, 0xa3, 0x7f, 0x88, 0xf2, 0x03, 0xcb, 0xd4, 0x1c, 0x7e, 0xe4, - 0xa8, 0x87, 0x32, 0x97, 0xc7, 0xff, 0x80, 0xac, 0xcf, 0xfa, 0xca, 0xf7, 0x93, 0xbb, 0xef, 0x9b, 0xe4, 0xcf, 0x6c, - 0x35, 0x27, 0x9b, 0x5d, 0x6b, 0xef, 0xe7, 0x7b, 0xf0, 0xbd, 0xf9, 0x3d, 0x32, 0xab, 0x85, 0xde, 0x28, 0xd4, 0x55, - 0x0f, 0x58, 0xe8, 0xd5, 0x4f, 0x7d, 0x8b, 0xd0, 0xec, 0x43, 0xac, 0xc1, 0x39, 0x44, 0x54, 0xba, 0xa7, 0x5e, 0xc3, - 0xb6, 0xbe, 0x77, 0x27, 0x06, 0xba, 0x66, 0x38, 0xef, 0x69, 0x93, 0xc8, 0x6d, 0xd4, 0xc3, 0xe6, 0xfd, 0xd9, 0x15, - 0xd6, 0x44, 0xb7, 0xba, 0x61, 0xe7, 0x52, 0xb2, 0x7c, 0x6b, 0x0f, 0xe0, 0xb1, 0x7a, 0x10, 0xf6, 0xae, 0x99, 0x3f, - 0x96, 0x03, 0x7f, 0x96, 0xf2, 0x4e, 0xb5, 0xb4, 0xfa, 0x8d, 0x6f, 0x55, 0x1f, 0xfb, 0x80, 0x37, 0xc2, 0x53, 0x41, - 0x75, 0xf6, 0x9c, 0x3d, 0x79, 0x71, 0x21, 0xbe, 0xd1, 0x0d, 0x2e, 0xa1, 0x5b, 0x15, 0x79, 0x03, 0x5f, 0xda, 0xbc, - 0xaa, 0xe0, 0x79, 0x68, 0xc9, 0x28, 0x4f, 0x9a, 0x72, 0x6c, 0xe6, 0x76, 0x31, 0x49, 0xb7, 0x32, 0x3f, 0xba, 0x51, - 0x81, 0x0b, 0x04, 0x92, 0x74, 0x65, 0x08, 0xff, 0x04, 0x27, 0x5e, 0x2b, 0xe1, 0xd3, 0x8d, 0x66, 0xbd, 0xd7, 0x55, - 0x3d, 0xee, 0x1a, 0xf4, 0x22, 0x3e, 0xb5, 0xd3, 0x5e, 0x7b, 0x84, 0xbf, 0xbf, 0x7f, 0x9e, 0x69, 0xe4, 0xbf, 0xce, - 0xec, 0xe4, 0x3f, 0xcf, 0xcd, 0xe4, 0xbf, 0xce, 0x0d, 0x9c, 0x5a, 0x7d, 0xcf, 0xbe, 0x7a, 0x61, 0x5f, 0xbd, 0xb2, - 0xc7, 0x4c, 0xed, 0xa1, 0x75, 0xad, 0x73, 0xd0, 0x8e, 0x5d, 0xcf, 0xf5, 0x96, 0x1c, 0xf0, 0xad, 0xae, 0xb2, 0x64, - 0xfd, 0xdb, 0xc9, 0xee, 0xde, 0x15, 0x53, 0xf9, 0xfe, 0x00, 0xc1, 0x93, 0xef, 0x87, 0x65, 0xad, 0xa2, 0x6c, 0xce, - 0xb4, 0x8c, 0xad, 0x74, 0xb6, 0xf7, 0x50, 0x3c, 0x9d, 0x3e, 0x42, 0xb2, 0xad, 0xe1, 0x0c, 0x55, 0x26, 0xf0, 0x1f, - 0x49, 0x3f, 0x36, 0x2a, 0xbd, 0x68, 0xbc, 0x74, 0xef, 0x48, 0xca, 0xf3, 0x17, 0x43, 0xc4, 0xc8, 0xb4, 0x9c, 0xda, - 0x3b, 0x98, 0xba, 0xc7, 0xac, 0xc5, 0xcb, 0x0e, 0xc8, 0x6c, 0xe9, 0x56, 0x52, 0x81, 0x10, 0xc6, 0xb6, 0x85, 0xff, - 0x2c, 0xc0, 0xaa, 0xfa, 0x96, 0x59, 0x3a, 0xcd, 0x9e, 0xa2, 0xa5, 0xd3, 0x0b, 0xd0, 0x20, 0x0e, 0x43, 0x99, 0xee, - 0x0a, 0x99, 0xc3, 0xf3, 0x2a, 0xae, 0x20, 0xab, 0x5f, 0x28, 0xf9, 0xef, 0x73, 0xf6, 0x70, 0xfd, 0x41, 0x40, 0x83, - 0xff, 0xdb, 0x64, 0x3b, 0xe8, 0x4f, 0x68, 0x6b, 0x9c, 0x72, 0x49, 0xa4, 0xfd, 0x5c, 0xc9, 0xdb, 0x33, 0xdf, 0x67, - 0xd7, 0xb7, 0xcf, 0x18, 0xce, 0xcf, 0x55, 0x08, 0x64, 0xce, 0xda, 0x4f, 0xf7, 0xf5, 0x31, 0x15, 0xb9, 0xeb, 0xbc, - 0xe7, 0x04, 0xab, 0xdc, 0x99, 0x52, 0x6b, 0x66, 0x72, 0x7e, 0xfe, 0xf2, 0x3f, 0xcc, 0xaf, 0x25, 0xe5, 0xa0, 0xef, - 0xf5, 0x92, 0xdd, 0xdc, 0x17, 0xca, 0xd2, 0xf3, 0x4c, 0xf9, 0xe8, 0x83, 0x4a, 0x3e, 0x1f, 0xd0, 0x74, 0x3f, 0xdd, - 0xf9, 0x8f, 0xea, 0x01, 0xdd, 0xa6, 0xf9, 0xac, 0xfb, 0x65, 0x49, 0x39, 0xe0, 0x07, 0xbd, 0x7c, 0x7e, 0x7b, 0x8b, - 0x7f, 0x6c, 0x3a, 0xdf, 0xd3, 0x05, 0x80, 0xf0, 0xfc, 0x28, 0xd9, 0x1c, 0x87, 0x9c, 0xc9, 0x9d, 0xeb, 0x0a, 0xcf, - 0xa8, 0x5a, 0x0e, 0x85, 0x5c, 0x2c, 0xf1, 0x19, 0xf9, 0x98, 0x27, 0xb2, 0xd1, 0x27, 0xb0, 0x4b, 0x99, 0xbd, 0x87, - 0x25, 0x64, 0xb7, 0xcd, 0xa7, 0x70, 0x94, 0xcf, 0x3d, 0xa2, 0x6d, 0x76, 0x1d, 0x16, 0x26, 0x6d, 0x69, 0x2a, 0x2e, - 0x3c, 0x60, 0xdf, 0x09, 0x0a, 0x83, 0xd5, 0x48, 0xed, 0x63, 0x46, 0x4e, 0x6f, 0x21, 0xba, 0xce, 0x38, 0x95, 0xbd, - 0xdf, 0xc1, 0x80, 0xa5, 0xf0, 0xf0, 0xd0, 0x7b, 0x0d, 0x68, 0x87, 0xcf, 0xb9, 0xe8, 0xa3, 0x9b, 0x50, 0xaf, 0x06, - 0xe0, 0xc4, 0x59, 0x36, 0xdd, 0x78, 0xb9, 0x9f, 0xf3, 0x87, 0xce, 0xe5, 0xca, 0xea, 0x63, 0x0d, 0x6d, 0x9b, 0xa3, - 0x33, 0xce, 0x57, 0x09, 0x2a, 0x8c, 0x30, 0x67, 0x78, 0xfe, 0xf5, 0xd4, 0x7d, 0xa0, 0x04, 0x7d, 0xa2, 0xd7, 0x9c, - 0x90, 0xd1, 0x7f, 0x22, 0x50, 0xa7, 0x93, 0xb4, 0x67, 0xf5, 0x47, 0xff, 0x1e, 0x3d, 0xb4, 0x4d, 0x8f, 0x7a, 0xab, - 0xe0, 0x3e, 0x85, 0x06, 0xa5, 0x52, 0x69, 0xac, 0x6d, 0x8e, 0x7f, 0x75, 0x72, 0x9d, 0x46, 0x6d, 0x8f, 0x70, 0x76, - 0xa6, 0xcd, 0x79, 0xdc, 0xde, 0xcc, 0xdc, 0xab, 0x17, 0x0f, 0xfd, 0x17, 0xff, 0x65, 0x18, 0x97, 0x8c, 0xb4, 0x20, - 0x37, 0xa9, 0x3d, 0xab, 0x1e, 0x1b, 0xf3, 0xaa, 0x7f, 0xab, 0x7e, 0x64, 0x54, 0xc0, 0xc6, 0x58, 0xcf, 0xe1, 0x32, - 0x3e, 0xcd, 0xeb, 0xa8, 0x28, 0x0b, 0x36, 0xc4, 0xf9, 0x70, 0xbb, 0xd7, 0xde, 0x23, 0x3b, 0xd0, 0xe4, 0xd7, 0x5f, - 0x66, 0xd3, 0x8f, 0xb6, 0xf3, 0x3b, 0x50, 0xcc, 0xfa, 0xfe, 0x94, 0x62, 0x83, 0xba, 0x02, 0xb7, 0x01, 0x97, 0xef, - 0xd8, 0x34, 0xf3, 0xaa, 0xf1, 0xbe, 0x7f, 0xc0, 0x5a, 0x12, 0x8a, 0x56, 0x0a, 0x0e, 0x8b, 0x75, 0x19, 0x45, 0x69, - 0xb1, 0x26, 0xfa, 0x55, 0xa7, 0xaa, 0xd3, 0xb6, 0x1b, 0x38, 0x37, 0x11, 0xa6, 0xaa, 0xb7, 0xa2, 0x1f, 0x22, 0xf2, - 0x36, 0x9e, 0xea, 0xab, 0x6d, 0x20, 0x86, 0xa7, 0xb8, 0x6e, 0xad, 0x7a, 0x0d, 0x67, 0x30, 0xa0, 0x27, 0x7d, 0x71, - 0x0c, 0xc1, 0xc3, 0x97, 0x01, 0x4b, 0xbd, 0xe9, 0xd2, 0xe1, 0xed, 0x63, 0xad, 0xd6, 0x9b, 0x3a, 0xaf, 0x3e, 0x55, - 0x6a, 0xd3, 0xf2, 0x74, 0x8f, 0x92, 0x21, 0xd1, 0xfe, 0xaa, 0x7c, 0xf6, 0xd3, 0x21, 0x63, 0x7b, 0x26, 0x9e, 0x2a, - 0x5e, 0x28, 0x69, 0x79, 0x57, 0xf1, 0x30, 0x8e, 0x3b, 0x29, 0x6a, 0x08, 0x56, 0xfc, 0x63, 0x18, 0x16, 0xe9, 0x9c, - 0xad, 0x0f, 0x75, 0xf0, 0x4a, 0x28, 0xe9, 0xca, 0xb5, 0xd6, 0x0a, 0x74, 0x6c, 0xe3, 0x99, 0x9f, 0x39, 0x9d, 0x09, - 0x50, 0xf9, 0x55, 0x98, 0x04, 0x14, 0x44, 0x22, 0x3c, 0x51, 0x2d, 0xbc, 0x28, 0xfa, 0x0c, 0xe6, 0xd0, 0x0c, 0xab, - 0xc1, 0x34, 0x15, 0xfd, 0x8d, 0x32, 0x30, 0xd7, 0x21, 0x82, 0x17, 0x99, 0x6b, 0xf3, 0x31, 0x0f, 0x1d, 0x8a, 0x9c, - 0x91, 0x53, 0x7f, 0xb0, 0xa4, 0xbc, 0x81, 0x3c, 0x56, 0xa1, 0xf8, 0x57, 0x30, 0x88, 0x73, 0x36, 0x00, 0x85, 0x8c, - 0x3d, 0x8f, 0x00, 0x60, 0x49, 0x3e, 0x49, 0x02, 0x6f, 0xfa, 0xbb, 0xb3, 0xf1, 0x59, 0x51, 0xb0, 0x5f, 0xed, 0x9b, - 0x49, 0xd3, 0x2c, 0xdc, 0xdd, 0xb3, 0x65, 0xf7, 0x14, 0x41, 0x04, 0x48, 0x32, 0x9b, 0x56, 0xec, 0x3d, 0xc4, 0xaf, - 0x14, 0x30, 0x03, 0x93, 0x0c, 0xe0, 0x84, 0x69, 0x49, 0xeb, 0x8a, 0x9f, 0x5c, 0x1d, 0xb6, 0x72, 0x5b, 0x28, 0xc1, - 0x22, 0x32, 0x8f, 0x6e, 0x89, 0x34, 0x4b, 0xe9, 0x9e, 0x5b, 0xeb, 0x3b, 0x19, 0xc7, 0x0f, 0x23, 0xe7, 0x89, 0xe3, - 0xf8, 0x35, 0x89, 0x68, 0x45, 0x44, 0x71, 0xba, 0x75, 0x0e, 0xd9, 0x15, 0x94, 0x8a, 0x15, 0x80, 0xaa, 0x07, 0x4c, - 0x35, 0xc1, 0x9a, 0x5f, 0xdc, 0x05, 0x7b, 0xf9, 0x40, 0x7b, 0x42, 0x71, 0x92, 0xac, 0x8c, 0xf5, 0xd0, 0x17, 0x7c, - 0x85, 0x5d, 0x2e, 0x46, 0x9b, 0x1d, 0x93, 0x24, 0xb5, 0xa2, 0x09, 0x06, 0xd4, 0x35, 0xc3, 0x69, 0xd7, 0xce, 0x3f, - 0x72, 0x9a, 0xd9, 0x74, 0x40, 0x8e, 0x71, 0x29, 0x74, 0x1b, 0xf7, 0xa4, 0x10, 0x47, 0x43, 0xe8, 0xe3, 0x30, 0x14, - 0x46, 0x3f, 0xc3, 0x66, 0x56, 0x9f, 0xf6, 0x31, 0x17, 0xb4, 0x35, 0xa6, 0xa8, 0xaa, 0xcb, 0xae, 0x29, 0x00, 0x1b, - 0x29, 0x67, 0xb0, 0x02, 0xfe, 0x78, 0xd9, 0x4e, 0x57, 0x0f, 0x37, 0x36, 0xf9, 0x0f, 0x6e, 0xf6, 0x1b, 0xe9, 0x27, - 0xf0, 0x47, 0x48, 0x66, 0xd6, 0x04, 0xd6, 0x10, 0xce, 0x4b, 0x62, 0x81, 0xe8, 0x71, 0xbe, 0x1f, 0x04, 0x7f, 0x5c, - 0x2d, 0x1e, 0x14, 0x5b, 0x98, 0xb4, 0x92, 0x73, 0xa2, 0x5e, 0x53, 0xa7, 0x8e, 0x7c, 0x90, 0x98, 0x44, 0x4c, 0x28, - 0xcf, 0xa3, 0x9f, 0x66, 0xb5, 0x9a, 0x05, 0xb5, 0x4d, 0x54, 0xec, 0x15, 0xba, 0x73, 0x3b, 0x67, 0x48, 0xb2, 0x23, - 0x38, 0xd5, 0x65, 0xd9, 0x70, 0x7b, 0xdb, 0x9a, 0x79, 0xd3, 0xf0, 0x35, 0x9d, 0xc3, 0x32, 0xee, 0x82, 0x8e, 0xb5, - 0xf1, 0x9a, 0xd8, 0x1e, 0x0c, 0x1e, 0x16, 0x4f, 0x94, 0x4e, 0xa3, 0xe9, 0xa6, 0x9e, 0x99, 0x9b, 0x7d, 0x4d, 0x5d, - 0x4d, 0xb4, 0xb3, 0x04, 0x9a, 0xcf, 0x46, 0xf1, 0x1a, 0x5b, 0xe6, 0x1a, 0x39, 0xb6, 0x96, 0xb8, 0x5b, 0xe6, 0x1d, - 0x8b, 0x91, 0xbb, 0x81, 0x51, 0x62, 0xee, 0x22, 0x86, 0x9a, 0x9f, 0xc3, 0xdc, 0x9e, 0x98, 0x40, 0xa8, 0x7f, 0x5d, - 0x4f, 0x66, 0x70, 0x31, 0x4d, 0x23, 0x19, 0xd6, 0x83, 0xd2, 0xf7, 0x44, 0x73, 0x8f, 0x78, 0xce, 0x09, 0xb6, 0x6d, - 0x2b, 0x5f, 0x7c, 0xcd, 0x18, 0xf8, 0xc0, 0x54, 0x77, 0x10, 0x5c, 0xd1, 0x5b, 0xd0, 0x3c, 0x83, 0xeb, 0x01, 0xb3, - 0x6f, 0x84, 0xf9, 0xbc, 0x10, 0x75, 0xfb, 0x44, 0x26, 0xff, 0x05, 0x84, 0x62, 0x7a, 0xab, 0xf3, 0x47, 0xfb, 0x1c, - 0xee, 0x3c, 0x64, 0x81, 0xc7, 0x92, 0x38, 0x64, 0xf8, 0xc7, 0x8d, 0xb6, 0x8c, 0x45, 0xcf, 0x9c, 0xc7, 0x2d, 0x89, - 0x09, 0xa5, 0xda, 0x5d, 0x4b, 0xa2, 0xbc, 0x16, 0x61, 0x51, 0x85, 0xd8, 0x6d, 0x15, 0x52, 0x19, 0x75, 0x45, 0xa4, - 0x8a, 0xc7, 0x59, 0x37, 0x3b, 0x43, 0x69, 0x04, 0x19, 0x0a, 0x26, 0xa8, 0x6a, 0x9f, 0x44, 0xb5, 0x14, 0xf3, 0xa0, - 0x4d, 0x13, 0xf5, 0xf0, 0xba, 0x2a, 0x63, 0xe1, 0x71, 0xd6, 0xbd, 0xed, 0x88, 0x75, 0xeb, 0x3a, 0xce, 0xb3, 0x75, - 0xe4, 0xad, 0x1c, 0x99, 0xd7, 0x15, 0x61, 0x2b, 0xc2, 0xf6, 0x41, 0x2d, 0x22, 0xca, 0x50, 0x22, 0xe1, 0xc0, 0x16, - 0xd4, 0xdb, 0x0b, 0x65, 0x36, 0x10, 0xee, 0x95, 0xf5, 0x51, 0xc9, 0x56, 0xd2, 0xb6, 0x95, 0x52, 0xb0, 0x80, 0x42, - 0x58, 0x68, 0xec, 0x39, 0xeb, 0xfe, 0xf6, 0xb9, 0x8e, 0xad, 0xff, 0xdb, 0x40, 0x6c, 0xf6, 0xef, 0xde, 0xdf, 0x8f, - 0x31, 0xc0, 0xa8, 0x7b, 0xd6, 0x15, 0xe9, 0x5b, 0x5d, 0xdf, 0x22, 0x7d, 0xf3, 0xf5, 0x4d, 0x6d, 0x4e, 0x78, 0x96, - 0xb1, 0x36, 0x6a, 0xe3, 0xce, 0x0d, 0xb4, 0x0e, 0xfb, 0x92, 0x92, 0xda, 0xef, 0xdb, 0xe5, 0xa7, 0xb1, 0x2a, 0xf3, - 0xa5, 0x99, 0x94, 0xb2, 0xe9, 0xc1, 0xa9, 0x5a, 0xd3, 0x65, 0x84, 0xd4, 0xbd, 0x18, 0x6a, 0x2b, 0xd5, 0xa9, 0xab, - 0xdb, 0x7c, 0x7c, 0x31, 0x26, 0xc6, 0x2f, 0xff, 0x0a, 0x17, 0xcf, 0x77, 0x4c, 0x87, 0xb6, 0xbc, 0xf3, 0xbe, 0xad, - 0xc4, 0xb8, 0xdc, 0x94, 0x70, 0x8e, 0x66, 0x16, 0x32, 0x46, 0x5c, 0x56, 0x9d, 0xbb, 0xe0, 0x32, 0x82, 0xc0, 0x17, - 0x74, 0x55, 0x29, 0x99, 0xa5, 0xbe, 0xad, 0xa3, 0xcf, 0xf7, 0x44, 0x95, 0xc3, 0x9f, 0x0b, 0x4c, 0xe8, 0x42, 0x57, - 0x95, 0xeb, 0x7b, 0x45, 0xc4, 0x50, 0x14, 0x71, 0xce, 0xa9, 0xf4, 0x2e, 0x2c, 0x7c, 0x53, 0x8f, 0xa7, 0x44, 0x6d, - 0x1b, 0xa4, 0x98, 0xc5, 0x98, 0x4b, 0x4b, 0x31, 0x97, 0xf2, 0x88, 0xed, 0xf3, 0x18, 0x08, 0x8b, 0x49, 0x20, 0xf2, - 0xe1, 0xca, 0x85, 0x63, 0xf9, 0x22, 0x60, 0xb0, 0x8a, 0x3e, 0x10, 0x9c, 0xdf, 0x99, 0x65, 0x17, 0x7f, 0x9b, 0x0f, - 0x47, 0x26, 0xe3, 0x2a, 0x0c, 0x81, 0x3b, 0xe2, 0xb7, 0x4e, 0x3b, 0x94, 0x01, 0xce, 0x19, 0x4d, 0x0c, 0x98, 0x75, - 0xd3, 0x34, 0x38, 0x55, 0x4d, 0x5b, 0xe5, 0x6e, 0x5e, 0x61, 0x26, 0x24, 0x31, 0x10, 0xe5, 0x66, 0xf8, 0x95, 0x1a, - 0x09, 0xc8, 0xf9, 0xfb, 0x2e, 0xce, 0xc9, 0x29, 0x85, 0x13, 0x95, 0x4c, 0x82, 0xaf, 0x1d, 0x78, 0x87, 0xba, 0x15, - 0x2f, 0xc4, 0x71, 0x9a, 0xf2, 0xc8, 0x04, 0xf4, 0x40, 0xed, 0x40, 0x94, 0x55, 0x4b, 0x8e, 0xc2, 0x44, 0x42, 0x28, - 0x85, 0x8f, 0xf8, 0x4c, 0xe6, 0xa2, 0xaa, 0x35, 0xaf, 0xfa, 0x82, 0x6e, 0x41, 0x62, 0x40, 0x54, 0x11, 0x22, 0xc9, - 0xa4, 0x5a, 0x37, 0x54, 0x58, 0x2c, 0x5d, 0x5a, 0x0c, 0xe2, 0x04, 0xc9, 0x3c, 0x2e, 0x04, 0xff, 0x32, 0xb0, 0xb7, - 0x1c, 0x6f, 0x7a, 0xef, 0x06, 0x75, 0x35, 0x32, 0x93, 0x9d, 0xf7, 0xe6, 0x45, 0xaf, 0xa4, 0x25, 0x97, 0x0f, 0x89, - 0x42, 0x7f, 0x5f, 0xb7, 0x9d, 0x65, 0x35, 0x91, 0x82, 0x79, 0x59, 0x54, 0x17, 0x95, 0xed, 0xa5, 0x95, 0x0b, 0x3c, - 0xee, 0x1e, 0x26, 0x48, 0xf0, 0xdd, 0x66, 0xf2, 0x14, 0xb8, 0x48, 0xd6, 0xd8, 0x72, 0x9f, 0x48, 0xa3, 0xa3, 0xdb, - 0x28, 0x59, 0x1d, 0xd9, 0xda, 0x3f, 0x41, 0x94, 0xe4, 0xcc, 0x5a, 0x89, 0xae, 0xff, 0x59, 0xea, 0x26, 0x17, 0x85, - 0xb5, 0x38, 0xe4, 0x20, 0x6e, 0x3a, 0x0b, 0x61, 0x4a, 0xf6, 0x56, 0x60, 0x23, 0x44, 0x86, 0x8b, 0x49, 0x16, 0xe4, - 0xdc, 0x8b, 0x1f, 0x1c, 0x29, 0xf8, 0x8f, 0x48, 0x0d, 0x2d, 0x99, 0xd2, 0xff, 0x70, 0x1d, 0xe1, 0x5b, 0x19, 0x0e, - 0x92, 0xd9, 0x8b, 0x17, 0xdc, 0x96, 0x9e, 0x77, 0xcc, 0x06, 0x49, 0xf8, 0xfd, 0xec, 0xf2, 0x59, 0x6f, 0x0f, 0xe2, - 0x0f, 0x65, 0x42, 0xf0, 0x45, 0x47, 0xb5, 0x8b, 0xa7, 0x51, 0x71, 0x3a, 0x94, 0x5f, 0x8f, 0x4f, 0xcd, 0xef, 0xed, - 0xf2, 0x02, 0x7e, 0xfa, 0xe5, 0x9c, 0x03, 0x33, 0xf0, 0x85, 0xb6, 0x1a, 0x6b, 0xd8, 0x0b, 0x83, 0x3d, 0x86, 0x92, - 0x45, 0x3a, 0xb4, 0x9f, 0x8d, 0x30, 0x1f, 0xba, 0xde, 0x66, 0xfd, 0x1d, 0xc3, 0xac, 0xce, 0x30, 0xbe, 0xb1, 0xaf, - 0x6a, 0x65, 0x76, 0xdb, 0xb0, 0xa7, 0x92, 0x9d, 0xf6, 0xe5, 0x06, 0x53, 0x37, 0x67, 0x6f, 0x43, 0xcd, 0xe5, 0x9b, - 0x51, 0x5c, 0x79, 0x33, 0x0f, 0x4b, 0x08, 0x18, 0x33, 0xcc, 0xb9, 0x22, 0xe7, 0x5a, 0xd9, 0x0f, 0x96, 0xd8, 0x1f, - 0xb6, 0x42, 0xda, 0x54, 0x45, 0x32, 0xb3, 0x81, 0x8f, 0xb5, 0x5a, 0x7b, 0x5a, 0x0f, 0xcc, 0xd2, 0x89, 0xe9, 0x58, - 0xb3, 0xb4, 0x82, 0xa1, 0x54, 0x68, 0xb5, 0xd4, 0x1d, 0xae, 0xd2, 0x97, 0x5a, 0x5e, 0xf2, 0x84, 0x84, 0xfd, 0x04, - 0xb2, 0x13, 0xdf, 0xc3, 0x3d, 0x69, 0xfb, 0xce, 0xac, 0xb1, 0x31, 0x95, 0x25, 0xca, 0x93, 0x72, 0x05, 0x65, 0xea, - 0x1d, 0x60, 0xa8, 0xa8, 0x31, 0x36, 0x74, 0x87, 0x06, 0x6d, 0x34, 0x0e, 0xf7, 0x85, 0xeb, 0x6d, 0x41, 0xfe, 0xa3, - 0xbe, 0xcf, 0xc9, 0x57, 0x67, 0xb3, 0xa8, 0xa7, 0xf5, 0x56, 0x63, 0xe4, 0xc8, 0x78, 0x80, 0xd7, 0x9b, 0x93, 0x2a, - 0x5b, 0x30, 0x64, 0xaf, 0xa1, 0xfe, 0xa9, 0x99, 0xba, 0x90, 0x76, 0x62, 0x46, 0x94, 0xf1, 0x20, 0x92, 0x04, 0x3d, - 0x59, 0x0f, 0x82, 0x6b, 0x96, 0x85, 0xb5, 0xc9, 0xc8, 0x3d, 0x18, 0xce, 0x91, 0x8a, 0xe8, 0x12, 0x8a, 0xe2, 0x9c, - 0xcd, 0xe3, 0x13, 0x86, 0x1c, 0xe5, 0xb1, 0x58, 0x96, 0x2c, 0xa8, 0xf7, 0x2d, 0x8c, 0xd4, 0x64, 0x9b, 0x8e, 0xa5, - 0xe4, 0xb2, 0x03, 0x38, 0xb1, 0xa3, 0xed, 0x3c, 0x61, 0x4e, 0x6d, 0x5d, 0x82, 0x9d, 0xec, 0xd4, 0xdc, 0xad, 0xc8, - 0x00, 0xc9, 0x03, 0x21, 0x0a, 0x03, 0x3e, 0xdf, 0xaf, 0x08, 0x50, 0xcd, 0x71, 0x8a, 0xc4, 0x1f, 0x84, 0xf2, 0xc7, - 0x13, 0x49, 0xa7, 0xc2, 0x72, 0xd7, 0x33, 0xbc, 0x39, 0x0e, 0xa0, 0x95, 0x7a, 0xb2, 0xf9, 0x41, 0x89, 0xb2, 0x91, - 0xbf, 0x8a, 0xb5, 0x8e, 0x18, 0x22, 0x1c, 0xf8, 0xcd, 0x6a, 0x43, 0xd2, 0x78, 0xb3, 0xba, 0x38, 0x1a, 0x85, 0x42, - 0x57, 0x07, 0xdc, 0x47, 0x2a, 0x00, 0xfb, 0x66, 0xc3, 0x53, 0x37, 0x4e, 0x77, 0x51, 0x96, 0x25, 0x9c, 0x06, 0x13, - 0xf8, 0x67, 0xd3, 0xb5, 0xba, 0x85, 0x8b, 0x35, 0xcd, 0xc4, 0x47, 0x71, 0x3a, 0xdd, 0xd7, 0xbd, 0x0e, 0x01, 0xff, - 0x72, 0x89, 0x1d, 0xd2, 0x27, 0xa4, 0x8a, 0x83, 0x11, 0x73, 0x74, 0x8c, 0x4b, 0x9a, 0xe9, 0xa9, 0x21, 0x77, 0x97, - 0xca, 0x47, 0x28, 0x07, 0xaa, 0x73, 0x3c, 0x3d, 0x64, 0x37, 0xc3, 0x31, 0x42, 0x6d, 0x67, 0x88, 0x2b, 0x03, 0xf5, - 0x04, 0xc8, 0x95, 0x04, 0xc2, 0x32, 0xcf, 0x67, 0x48, 0xdf, 0x33, 0x66, 0x02, 0x1a, 0x3a, 0x50, 0x6e, 0x7a, 0x52, - 0xe6, 0x90, 0x7a, 0xa8, 0x83, 0x10, 0x13, 0x1e, 0xf4, 0xb2, 0xa9, 0x69, 0x65, 0x1d, 0x8d, 0x50, 0x69, 0x42, 0x41, - 0xfc, 0x02, 0xa7, 0xe8, 0xab, 0x21, 0xf2, 0x97, 0x91, 0xf2, 0x3a, 0x2b, 0xf3, 0x86, 0xf4, 0x12, 0x2d, 0xb2, 0xfa, - 0xc6, 0xc8, 0xec, 0x48, 0x5d, 0x56, 0x7a, 0xed, 0x05, 0x60, 0x1e, 0x0e, 0xc1, 0x89, 0x44, 0xc4, 0x3c, 0x89, 0x26, - 0xb2, 0xa9, 0x50, 0xfe, 0xcc, 0xee, 0x49, 0x01, 0x5c, 0xce, 0x23, 0x41, 0x13, 0x81, 0x8f, 0x1d, 0x00, 0x67, 0x66, - 0x10, 0xe0, 0x6c, 0x35, 0x69, 0x04, 0xc6, 0x5c, 0x2b, 0x6f, 0x35, 0xfb, 0x98, 0x11, 0xe5, 0xb8, 0x98, 0x1b, 0xd9, - 0x5d, 0x93, 0xfb, 0x53, 0xcc, 0x13, 0x1b, 0x73, 0xf8, 0xb9, 0xf6, 0x2a, 0x99, 0xfe, 0x65, 0x06, 0x3e, 0x29, 0x51, - 0x7d, 0x69, 0x50, 0xbc, 0x6e, 0xe3, 0x82, 0x36, 0xda, 0x35, 0xe4, 0xb2, 0xe8, 0x30, 0x58, 0xae, 0xfd, 0xbf, 0x7e, - 0x7b, 0x3e, 0xef, 0x2b, 0xe7, 0x63, 0x76, 0xc5, 0x7d, 0x70, 0x58, 0x33, 0xe4, 0xfc, 0xba, 0x2e, 0x9e, 0xe3, 0xfb, - 0xf5, 0xb7, 0xb9, 0xf1, 0x74, 0x77, 0x10, 0x64, 0x2e, 0xa4, 0x3e, 0xb3, 0x84, 0xe8, 0xc3, 0xd0, 0xe2, 0xd9, 0x18, - 0x55, 0xa2, 0xf1, 0xa5, 0x43, 0x8a, 0x65, 0x8b, 0xa7, 0x27, 0x81, 0x78, 0x39, 0xdc, 0x93, 0x2d, 0x10, 0x2b, 0x4a, - 0x84, 0x39, 0x9d, 0x88, 0x34, 0x8e, 0x80, 0xf1, 0x4a, 0xdc, 0x33, 0x04, 0x46, 0x1a, 0x65, 0xd6, 0xb4, 0xff, 0xd8, - 0x88, 0xec, 0x73, 0x48, 0x34, 0x19, 0x36, 0xe5, 0x93, 0xcd, 0xa8, 0xbd, 0x12, 0x09, 0x45, 0xc3, 0xba, 0x9f, 0xa6, - 0x19, 0x95, 0xf7, 0x62, 0x1c, 0x12, 0x87, 0x70, 0xd2, 0xbb, 0xdf, 0xaf, 0xbf, 0x95, 0x3c, 0xfc, 0x1e, 0xf6, 0x1f, - 0xbf, 0xf8, 0x1f, 0xbf, 0x87, 0x7b, 0xf2, 0x8b, 0x9f, 0xfc, 0x1e, 0xf2, 0xc9, 0x2f, 0xe2, 0xa5, 0xd2, 0xf4, 0x95, - 0xdd, 0x79, 0x30, 0x16, 0x0c, 0xe5, 0xb2, 0x8c, 0x6c, 0xa5, 0x0a, 0x7e, 0xf1, 0x21, 0xe1, 0x3e, 0x17, 0x48, 0xc9, - 0xa9, 0x64, 0x82, 0x95, 0xa8, 0x64, 0x65, 0xe8, 0x14, 0xd4, 0xa7, 0x01, 0x3e, 0x4a, 0xbd, 0xfd, 0x9c, 0x7f, 0xba, - 0x35, 0x92, 0xc6, 0x40, 0x3c, 0x19, 0x82, 0xae, 0xdc, 0x99, 0x5b, 0xcf, 0x4d, 0x49, 0x18, 0x65, 0x39, 0x62, 0xb4, - 0xa2, 0xd2, 0x8e, 0xb3, 0x44, 0xef, 0x3c, 0x18, 0x34, 0x13, 0xf4, 0xed, 0x7b, 0xe8, 0xa4, 0xb0, 0x3b, 0x43, 0x01, - 0x72, 0x96, 0x95, 0x02, 0x1e, 0xd8, 0xc7, 0x5e, 0x3c, 0x47, 0x5a, 0x79, 0x35, 0xa9, 0xa2, 0x06, 0xd7, 0xe4, 0x60, - 0x8c, 0x11, 0x12, 0xf7, 0xf4, 0x2f, 0xf9, 0x98, 0x9c, 0xb9, 0x79, 0xab, 0x59, 0xb8, 0xc7, 0xd4, 0x72, 0x40, 0x73, - 0x62, 0x54, 0xcd, 0x0c, 0x5b, 0x44, 0xad, 0x59, 0xcd, 0x99, 0x45, 0x9c, 0x2c, 0xc5, 0xd6, 0x55, 0xd8, 0xf3, 0x1e, - 0x3f, 0xe5, 0x1f, 0xe6, 0x34, 0x57, 0x8f, 0x34, 0xd8, 0x17, 0x19, 0xbb, 0x0f, 0xae, 0x70, 0x5a, 0x6b, 0x30, 0x3d, - 0xe1, 0x6c, 0x2d, 0xae, 0xaf, 0xa6, 0xf0, 0x05, 0x69, 0x75, 0xcf, 0xa5, 0x88, 0x46, 0x37, 0xc9, 0xc4, 0x86, 0xa1, - 0xb5, 0xd9, 0x7d, 0x6d, 0xa1, 0xd1, 0x66, 0x05, 0xad, 0x59, 0xd9, 0xfd, 0xe6, 0x8d, 0x36, 0xb1, 0xc9, 0x9c, 0x05, - 0x99, 0xa8, 0xba, 0x09, 0xd2, 0xa6, 0xc0, 0x27, 0x27, 0x2b, 0x8c, 0x47, 0x20, 0x8b, 0xdc, 0xe6, 0x64, 0x7f, 0xe9, - 0xa8, 0x65, 0x54, 0x95, 0x10, 0x89, 0xcf, 0xca, 0x2d, 0xe4, 0x12, 0x74, 0xbc, 0x38, 0x10, 0xc1, 0xe5, 0x30, 0x2e, - 0x95, 0x9a, 0x46, 0xdb, 0x35, 0xda, 0x5b, 0xc8, 0x73, 0xa8, 0xcb, 0x4f, 0x83, 0x0d, 0x61, 0x88, 0x6a, 0xf4, 0xa1, - 0xcd, 0x3c, 0xbd, 0xa6, 0x4b, 0xfb, 0xf5, 0xf7, 0x01, 0x38, 0x7a, 0xb1, 0xbd, 0x90, 0xcc, 0x5d, 0x9f, 0x92, 0x48, - 0x20, 0x51, 0xf2, 0x05, 0xa0, 0x07, 0x80, 0x5e, 0xf5, 0x12, 0x56, 0x03, 0x06, 0xad, 0x54, 0x81, 0x9e, 0x29, 0x78, - 0x00, 0x32, 0x43, 0xcb, 0x41, 0xe5, 0x8f, 0x48, 0xf0, 0xb5, 0x43, 0xb2, 0x98, 0xf0, 0xd2, 0x50, 0xbc, 0x8e, 0x09, - 0xed, 0x7c, 0x98, 0x9a, 0x5e, 0x22, 0xf7, 0x14, 0x29, 0x1d, 0xb1, 0x45, 0x3f, 0xfd, 0xf4, 0xaa, 0xa7, 0x85, 0x93, - 0x3c, 0xb2, 0x7c, 0xac, 0xfd, 0x5b, 0xd6, 0xb6, 0xab, 0xea, 0x8f, 0x4c, 0x49, 0x1d, 0x68, 0x43, 0x28, 0xd7, 0x33, - 0x65, 0x4f, 0xe9, 0x2b, 0xd8, 0x59, 0x0c, 0x8b, 0x5e, 0xbb, 0xcf, 0x6a, 0x73, 0xf8, 0xd0, 0x45, 0x0f, 0x44, 0x13, - 0x6e, 0x5f, 0x23, 0x81, 0xe6, 0x12, 0xc1, 0x62, 0x78, 0x46, 0x97, 0x76, 0xe3, 0x43, 0x4e, 0x51, 0x10, 0xab, 0xc0, - 0x87, 0x74, 0xfd, 0x84, 0x86, 0x0c, 0x65, 0xbb, 0x8d, 0x02, 0x67, 0x35, 0xd0, 0x7c, 0x5f, 0xe3, 0xb0, 0x57, 0x27, - 0x60, 0x6d, 0xc9, 0x7c, 0xb5, 0x69, 0xa3, 0xd8, 0x6b, 0x2e, 0xaf, 0xf6, 0xda, 0x0a, 0x81, 0x3f, 0x17, 0x9f, 0xfd, - 0xed, 0x79, 0x52, 0x7d, 0x9f, 0x9f, 0x94, 0xde, 0xdb, 0xac, 0xfa, 0xa0, 0x35, 0xd8, 0xfb, 0xe3, 0x94, 0xf7, 0x91, - 0xe5, 0x30, 0x29, 0x3d, 0x1f, 0x8d, 0x6a, 0xb1, 0x7b, 0x4d, 0xe6, 0xf1, 0x61, 0x25, 0x54, 0xb3, 0xa9, 0x91, 0x07, - 0xf7, 0x5a, 0x73, 0xa1, 0xef, 0x51, 0xa0, 0xba, 0xd7, 0xc2, 0xa9, 0xba, 0x2a, 0x25, 0x88, 0xc9, 0xc8, 0x68, 0xa6, - 0xd9, 0x58, 0x6f, 0x03, 0xf3, 0x71, 0xaa, 0x5f, 0xf0, 0x27, 0x52, 0x72, 0xd8, 0xed, 0xac, 0x2c, 0x4a, 0xc5, 0x24, - 0x25, 0xa0, 0xc5, 0xf6, 0x6f, 0x71, 0x70, 0x60, 0x50, 0xb5, 0xea, 0x3c, 0x60, 0x24, 0xf6, 0xc5, 0xe2, 0x23, 0x50, - 0xf1, 0x5b, 0x3b, 0xc8, 0xec, 0x86, 0x8f, 0x65, 0x29, 0x2c, 0xfc, 0x20, 0x4a, 0xa5, 0x9e, 0x80, 0x40, 0x4d, 0x9d, - 0xbc, 0x29, 0x41, 0xb0, 0x7c, 0x33, 0xa7, 0x8d, 0xbd, 0x30, 0x5d, 0x1d, 0xc8, 0xb5, 0x69, 0x24, 0x86, 0x22, 0xfe, - 0xc9, 0xb1, 0xe1, 0x3a, 0x9a, 0xb0, 0xea, 0x89, 0xe5, 0x5e, 0x94, 0x07, 0xa1, 0x41, 0xe8, 0x90, 0xa7, 0xca, 0x6d, - 0x19, 0xd6, 0xe7, 0x2d, 0x2f, 0x4f, 0xfa, 0x17, 0x1e, 0x1f, 0x2c, 0x3a, 0x7f, 0x42, 0x33, 0x17, 0x02, 0x29, 0xa8, - 0x62, 0x93, 0xc2, 0x1d, 0xa1, 0x2a, 0xcb, 0x9d, 0x97, 0x15, 0xcd, 0x6b, 0x33, 0x0f, 0xd2, 0xd5, 0x47, 0x05, 0x99, - 0x4b, 0x28, 0x09, 0xa5, 0x2e, 0x60, 0x0a, 0xa3, 0x2c, 0xde, 0xe8, 0xbb, 0xf5, 0x0f, 0xbb, 0x94, 0x84, 0x03, 0x3e, - 0x86, 0xc1, 0x4c, 0xe0, 0xdf, 0x0f, 0x29, 0x0d, 0xdc, 0xd4, 0xba, 0x16, 0xca, 0x18, 0xd2, 0x0a, 0xc1, 0x7c, 0x24, - 0xd1, 0x60, 0x82, 0xef, 0x3b, 0x83, 0x22, 0x27, 0x05, 0x2b, 0x8d, 0xdf, 0x8c, 0x7b, 0x0c, 0x1d, 0x67, 0xc6, 0x3b, - 0x3b, 0x5d, 0xb1, 0xb7, 0xe6, 0xb8, 0x3a, 0x84, 0x80, 0xcb, 0xb1, 0xdc, 0xca, 0xba, 0x20, 0xeb, 0x18, 0xf2, 0x2c, - 0xdc, 0x22, 0x71, 0xc9, 0x08, 0x3d, 0xa5, 0x43, 0x23, 0x95, 0x61, 0x09, 0x4e, 0x9b, 0xe1, 0x03, 0xdb, 0xb8, 0x82, - 0xba, 0x9d, 0x9d, 0x06, 0xea, 0xf6, 0x0a, 0x78, 0xb0, 0x6b, 0x42, 0x89, 0xd2, 0xc8, 0xaa, 0x80, 0x06, 0x23, 0xa0, - 0x2d, 0x0b, 0x94, 0x6a, 0x22, 0x26, 0x1a, 0x85, 0x51, 0x22, 0xb5, 0x94, 0xb2, 0xa3, 0xe9, 0x77, 0x5d, 0x24, 0x93, - 0x64, 0x1d, 0x8a, 0x83, 0x9e, 0x98, 0x24, 0xb5, 0x5a, 0x97, 0x2d, 0x3e, 0x1c, 0x88, 0xfd, 0x22, 0x95, 0x9e, 0xd8, - 0xdb, 0x69, 0x81, 0xdc, 0xec, 0x7b, 0x1a, 0x52, 0x43, 0xa3, 0xb3, 0xad, 0xd1, 0x79, 0x79, 0x2a, 0x9b, 0x1f, 0x74, - 0xd4, 0x72, 0xeb, 0xc6, 0x98, 0xa2, 0x0a, 0xa8, 0x3f, 0xd6, 0x82, 0xf4, 0xfd, 0x4b, 0xa1, 0x4e, 0x50, 0x34, 0x4c, - 0xed, 0x7b, 0x2c, 0x46, 0xba, 0x4e, 0xf3, 0x48, 0x48, 0x70, 0xef, 0x09, 0x02, 0x3c, 0x22, 0x4f, 0x23, 0x19, 0xd3, - 0x09, 0xc2, 0x10, 0x91, 0x75, 0xb2, 0xe6, 0x7d, 0x6e, 0xfd, 0xfe, 0x92, 0xbc, 0xef, 0xe2, 0x06, 0x93, 0xab, 0xfd, - 0x94, 0xde, 0xfb, 0xed, 0x76, 0x68, 0xed, 0x71, 0x12, 0x37, 0xe3, 0x85, 0xa5, 0xf6, 0x58, 0xd8, 0xff, 0x66, 0xf3, - 0xa9, 0x53, 0xa5, 0xb7, 0x6b, 0x0d, 0x69, 0x3c, 0xb3, 0xc6, 0x66, 0x3f, 0x09, 0xda, 0x91, 0x0b, 0xb4, 0x13, 0x3b, - 0x39, 0xab, 0x20, 0xa1, 0x21, 0x31, 0xa6, 0xb6, 0x73, 0x08, 0xd0, 0x8c, 0x75, 0xe6, 0xf6, 0xad, 0xf6, 0xed, 0x29, - 0x27, 0x65, 0x80, 0xf2, 0x52, 0xf8, 0x67, 0xdb, 0x49, 0x89, 0x7d, 0x1c, 0x63, 0x6c, 0x05, 0xf1, 0x21, 0x81, 0x54, - 0x05, 0x13, 0x5a, 0x4d, 0x1e, 0xd0, 0xc5, 0x29, 0x1d, 0x7f, 0xa6, 0x1f, 0x3e, 0xc0, 0xea, 0x6b, 0x1e, 0xd9, 0x66, - 0x0f, 0x1c, 0x63, 0x4a, 0xbd, 0xce, 0x0e, 0x58, 0x3f, 0xa5, 0xf7, 0xba, 0x58, 0x1b, 0x43, 0xca, 0x96, 0x5c, 0xbb, - 0xb6, 0x08, 0x99, 0x30, 0x64, 0x5d, 0x47, 0x28, 0xac, 0xe0, 0xfc, 0x86, 0x9c, 0xc0, 0xea, 0xfd, 0x9c, 0x2b, 0xf5, - 0x2c, 0x52, 0xb3, 0x4c, 0xd0, 0xce, 0x8e, 0x1c, 0xe9, 0x3c, 0xa9, 0xff, 0x6f, 0x25, 0x84, 0xe0, 0xd2, 0x9a, 0x6e, - 0x4b, 0xa8, 0x93, 0xfc, 0xe4, 0x2a, 0x5a, 0xc0, 0x73, 0x37, 0xca, 0x1f, 0xc9, 0xea, 0x6d, 0x82, 0x67, 0x83, 0x48, - 0x60, 0xc3, 0x72, 0x4a, 0x54, 0xc3, 0x6a, 0xab, 0x5b, 0xf8, 0xee, 0xd1, 0xed, 0x8d, 0x62, 0x0c, 0x15, 0x4e, 0x7e, - 0x0e, 0x94, 0x54, 0xdc, 0xeb, 0x92, 0x5a, 0x47, 0xe5, 0x7f, 0xa3, 0xb8, 0xc2, 0x49, 0x7c, 0x73, 0x93, 0xb3, 0x81, - 0x47, 0xdd, 0x53, 0x43, 0xb2, 0xbf, 0x5f, 0xa8, 0x10, 0x6d, 0xb4, 0x8e, 0x19, 0xa0, 0x0a, 0x1f, 0x41, 0x2e, 0x47, - 0xbe, 0x9f, 0x75, 0xe5, 0x17, 0xf9, 0xa5, 0x6f, 0xcf, 0x0d, 0x62, 0xcd, 0x5c, 0xa8, 0x59, 0xca, 0x28, 0xbf, 0x0c, - 0x6f, 0xe2, 0xb6, 0xc8, 0x20, 0xab, 0xcf, 0x6b, 0xec, 0x1d, 0x62, 0xe5, 0xd8, 0x6d, 0x4f, 0x58, 0x41, 0x4c, 0x90, - 0x2e, 0xc1, 0x53, 0x5d, 0x50, 0xc4, 0x28, 0x35, 0x67, 0x38, 0xd5, 0xa2, 0xba, 0x50, 0xce, 0xd5, 0x7a, 0x49, 0x05, - 0x84, 0xea, 0x7b, 0x2a, 0xe7, 0x25, 0x30, 0xec, 0x9d, 0xc7, 0x7e, 0xb0, 0x3c, 0x6f, 0xea, 0x5a, 0x99, 0x9d, 0xa6, - 0xeb, 0x1e, 0x2a, 0x1c, 0x68, 0x53, 0x7a, 0x4b, 0x57, 0xf3, 0x7c, 0xad, 0x16, 0xf8, 0x6d, 0x68, 0xc1, 0x33, 0xe7, - 0x13, 0xd0, 0x57, 0xc9, 0x23, 0x89, 0x3b, 0x4b, 0xd7, 0xae, 0x80, 0x16, 0x26, 0x93, 0xc0, 0x83, 0xd3, 0x7d, 0xad, - 0x92, 0xb5, 0x91, 0x70, 0x4c, 0x08, 0x03, 0x72, 0xd6, 0x07, 0xdb, 0x6e, 0x8c, 0x5c, 0xa2, 0xf6, 0xfa, 0x91, 0x86, - 0x16, 0x59, 0x3f, 0x68, 0xd2, 0xf3, 0x40, 0x51, 0x39, 0xaa, 0xde, 0xdc, 0x29, 0xa3, 0x87, 0x98, 0x27, 0x8c, 0xda, - 0xc4, 0xa0, 0x91, 0x1e, 0xa8, 0x33, 0x42, 0xce, 0x4f, 0x6c, 0x52, 0x7d, 0x8d, 0x0f, 0x9f, 0x09, 0x61, 0xac, 0x36, - 0x0d, 0xf9, 0x3c, 0x81, 0xf6, 0x6c, 0xe9, 0xb8, 0x53, 0x43, 0x86, 0xd7, 0xa6, 0xcb, 0x21, 0x19, 0x0b, 0x2e, 0x9b, - 0x21, 0x0c, 0x6a, 0x25, 0xe3, 0x34, 0xb1, 0xcf, 0xa9, 0x1b, 0x49, 0x57, 0xe5, 0x1a, 0x02, 0x1c, 0x77, 0x9c, 0x49, - 0xb3, 0xd8, 0x72, 0x8b, 0x92, 0xab, 0x4b, 0x4d, 0x88, 0x2d, 0x9a, 0x88, 0x12, 0x00, 0x7a, 0x39, 0xec, 0x23, 0x20, - 0xe1, 0xdb, 0x0a, 0xe7, 0xe6, 0x89, 0x2d, 0xad, 0x5c, 0x73, 0x41, 0x61, 0xb8, 0xa3, 0xaf, 0xf7, 0x62, 0x53, 0x11, - 0x7b, 0x06, 0xf3, 0xd0, 0x6c, 0x2c, 0xb3, 0xf9, 0x23, 0xdf, 0x9f, 0x87, 0x66, 0x20, 0xfd, 0x03, 0x16, 0xc4, 0x7f, - 0x0d, 0x15, 0xe2, 0x19, 0x17, 0xe4, 0x0f, 0xb4, 0x92, 0x86, 0x2f, 0x58, 0xb7, 0xd3, 0x95, 0x9f, 0x4d, 0x9f, 0xaa, - 0x05, 0x04, 0xe5, 0x81, 0x5c, 0x48, 0x73, 0x03, 0x6b, 0xbc, 0xc1, 0x8a, 0xf5, 0xc6, 0x0e, 0x49, 0x60, 0xeb, 0xe9, - 0x48, 0x26, 0x8d, 0x74, 0x8a, 0x07, 0xbe, 0xd5, 0xb1, 0xfd, 0xad, 0xce, 0x29, 0xbd, 0x29, 0x4f, 0x9b, 0xe6, 0xad, - 0x78, 0xe8, 0x59, 0x5b, 0x45, 0x98, 0x30, 0x78, 0x2a, 0x9c, 0xf0, 0x7a, 0x2f, 0x57, 0xd9, 0x35, 0x7c, 0x06, 0x3f, - 0xf4, 0x6c, 0x30, 0x17, 0x36, 0xd7, 0x22, 0x41, 0x07, 0x61, 0xbc, 0xf1, 0xf9, 0x11, 0x46, 0xa6, 0x4b, 0xe9, 0x15, - 0xfd, 0x68, 0x90, 0x28, 0xde, 0xae, 0xbf, 0xdd, 0x7d, 0x8f, 0xe0, 0xe0, 0xde, 0x82, 0x6c, 0x4c, 0x9b, 0xbd, 0x61, - 0x0f, 0x69, 0x51, 0xd5, 0x18, 0x23, 0xa4, 0x42, 0x1c, 0x43, 0xc4, 0xe5, 0xf6, 0x55, 0x5b, 0x1e, 0xdc, 0xf2, 0x4b, - 0x9e, 0x51, 0xf8, 0x28, 0xfe, 0xce, 0x7c, 0xd7, 0x47, 0xe8, 0x8a, 0xeb, 0x3c, 0x87, 0xf8, 0xda, 0x6f, 0xaf, 0x91, - 0x10, 0x25, 0xe1, 0x7f, 0x06, 0x0f, 0x30, 0x33, 0x5e, 0xac, 0x01, 0x7b, 0x5e, 0xdd, 0xc8, 0x49, 0x70, 0x5f, 0x30, - 0xf4, 0xb6, 0xf9, 0x42, 0x3f, 0x9e, 0x92, 0x78, 0x8b, 0xb6, 0x88, 0x5d, 0xa9, 0x83, 0x19, 0x3b, 0x71, 0xcd, 0x87, - 0xc9, 0xec, 0x3f, 0x46, 0x58, 0x00, 0x84, 0x82, 0x5a, 0x0b, 0x3f, 0x6d, 0x05, 0x70, 0xab, 0xff, 0x60, 0xa4, 0xc0, - 0x4d, 0xf4, 0xc4, 0xcf, 0x76, 0x4f, 0xb0, 0x09, 0x4e, 0xc4, 0x5e, 0x91, 0xb6, 0xe7, 0x40, 0xaf, 0x56, 0x35, 0x84, - 0xea, 0xd6, 0xe9, 0x20, 0x74, 0xb1, 0x28, 0x8c, 0xf5, 0x3a, 0x0a, 0x6c, 0x56, 0x2d, 0xab, 0x0e, 0x43, 0x6d, 0x57, - 0xa1, 0xf6, 0x24, 0x1b, 0x16, 0x25, 0x2a, 0x72, 0xe3, 0x78, 0x53, 0xac, 0x03, 0xea, 0xd7, 0x7e, 0x6d, 0x82, 0x5b, - 0x2f, 0x78, 0x74, 0x2c, 0xc8, 0xd5, 0x14, 0x31, 0x78, 0x81, 0xc8, 0xe0, 0x55, 0x59, 0xa0, 0x93, 0x5e, 0xb8, 0xef, - 0x9b, 0x4f, 0x75, 0x61, 0xe9, 0x6e, 0x1a, 0x3e, 0xfb, 0x79, 0xf4, 0xab, 0xe1, 0xeb, 0x25, 0x63, 0x64, 0x5c, 0x24, - 0x2d, 0x7a, 0xea, 0x1c, 0x97, 0x6b, 0x30, 0x7b, 0x68, 0x75, 0xcc, 0xb0, 0xfb, 0x74, 0xa5, 0xc5, 0x18, 0xbf, 0x13, - 0xc5, 0xb4, 0x07, 0xcb, 0x32, 0x13, 0xf7, 0xf4, 0x82, 0x00, 0x69, 0x2d, 0xf1, 0xa6, 0xd5, 0x5b, 0x6d, 0x7d, 0x36, - 0x2d, 0x83, 0xe8, 0x1b, 0x8b, 0x4c, 0xdd, 0x2c, 0x64, 0xb9, 0x4c, 0xb1, 0x46, 0xab, 0xb0, 0x2f, 0x97, 0x47, 0x37, - 0x7d, 0x5d, 0x1a, 0xff, 0x16, 0x55, 0x4f, 0x86, 0x44, 0xd2, 0x12, 0xa5, 0x52, 0x81, 0x93, 0x2e, 0xec, 0x62, 0x4d, - 0x47, 0x2d, 0xd7, 0x89, 0x33, 0xde, 0x8f, 0x97, 0x0e, 0xcb, 0x1f, 0x9f, 0x0b, 0x42, 0xad, 0xfc, 0x3f, 0x10, 0xfb, - 0xec, 0x70, 0x32, 0xa0, 0x9c, 0xc2, 0x19, 0xd9, 0xfd, 0x0f, 0xba, 0xda, 0x15, 0x40, 0xcd, 0x30, 0x7a, 0xb9, 0x54, - 0x38, 0x54, 0x94, 0x7e, 0x3a, 0xe9, 0xc6, 0x50, 0x58, 0x5f, 0xad, 0x85, 0xd7, 0x5e, 0x52, 0xd1, 0x25, 0xfe, 0x4a, - 0xfa, 0x98, 0x70, 0x2a, 0x65, 0x87, 0xfa, 0xaa, 0x21, 0x01, 0xa0, 0x43, 0xbc, 0x12, 0x01, 0x37, 0xf3, 0x16, 0x34, - 0x99, 0xc8, 0xb8, 0xf8, 0xe0, 0x02, 0xb8, 0x30, 0xde, 0x3e, 0xcd, 0x40, 0xb2, 0xd6, 0x12, 0x3b, 0x09, 0xdd, 0xf4, - 0x31, 0x61, 0x04, 0x48, 0xb0, 0xe3, 0x01, 0x34, 0x79, 0x27, 0xbc, 0xc7, 0x7a, 0x35, 0x31, 0x05, 0x41, 0x44, 0xf7, - 0x9e, 0x83, 0xdd, 0x5c, 0xcb, 0x6a, 0x85, 0x4d, 0x88, 0xcd, 0x8e, 0xaa, 0xef, 0xa7, 0x0a, 0xbc, 0x5e, 0x98, 0x54, - 0x6c, 0x14, 0xba, 0x4e, 0x1e, 0x68, 0x1c, 0x60, 0x3a, 0x4b, 0x0e, 0x35, 0x5c, 0xf9, 0x50, 0x96, 0x93, 0x94, 0xd0, - 0x52, 0x38, 0xe0, 0x0c, 0x24, 0x07, 0xff, 0x63, 0x41, 0x03, 0x59, 0x87, 0x9f, 0x18, 0xd7, 0xe0, 0x5f, 0x48, 0x6b, - 0x9a, 0x16, 0xd1, 0x6a, 0xaf, 0x61, 0x0d, 0x9a, 0x97, 0xc9, 0x97, 0x13, 0x03, 0xd8, 0xac, 0x16, 0xb2, 0xfa, 0xb1, - 0xe7, 0x9a, 0x3f, 0x52, 0x7e, 0xca, 0x42, 0xed, 0xa9, 0x9e, 0xb6, 0x42, 0xb2, 0xd3, 0xb4, 0xa8, 0x88, 0xe2, 0x7a, - 0xb2, 0x5d, 0x17, 0x2f, 0xbe, 0x88, 0x04, 0x7e, 0x31, 0x81, 0x18, 0x12, 0x40, 0x60, 0x70, 0x04, 0x35, 0x24, 0x74, - 0xd4, 0xd7, 0x9b, 0xc7, 0x57, 0x15, 0x04, 0xcd, 0x63, 0xa6, 0x80, 0x98, 0xae, 0x98, 0x9d, 0xbf, 0x04, 0x5a, 0xf1, - 0xfe, 0x0d, 0xd6, 0x55, 0xcd, 0x9f, 0x37, 0x69, 0xe3, 0x17, 0xd6, 0x7f, 0xd4, 0xb1, 0x2a, 0xb0, 0x21, 0x36, 0xa8, - 0x52, 0x24, 0xac, 0x32, 0x06, 0x88, 0x46, 0xcf, 0x5c, 0x45, 0x9a, 0xc2, 0xfe, 0xee, 0x3c, 0x1e, 0xd4, 0x3a, 0xb5, - 0xf9, 0xa6, 0xe7, 0x52, 0x62, 0x09, 0x97, 0x99, 0xe9, 0x73, 0x39, 0x00, 0x32, 0xd3, 0x83, 0xdc, 0x40, 0x83, 0xaf, - 0xc1, 0xab, 0x2b, 0xe6, 0x2c, 0x3d, 0xbb, 0x1f, 0x36, 0x7e, 0x7f, 0x95, 0x5e, 0xd1, 0x3b, 0x18, 0x99, 0x6f, 0xee, - 0xf5, 0xee, 0x5a, 0x5d, 0xbf, 0xb0, 0x98, 0x51, 0x97, 0xaa, 0xe5, 0xe9, 0xe7, 0xed, 0xbe, 0x2f, 0x1e, 0xac, 0xfd, - 0x29, 0x28, 0x63, 0x7b, 0x92, 0x77, 0xad, 0xe4, 0xc6, 0xbf, 0x40, 0xd3, 0xaa, 0xa0, 0x96, 0x91, 0x29, 0x6f, 0x6b, - 0xbf, 0xe5, 0xba, 0xbc, 0x3d, 0x91, 0x71, 0xc4, 0xb9, 0x63, 0xc8, 0xfb, 0xd2, 0x36, 0x3e, 0xf7, 0x1a, 0x02, 0x85, - 0x5f, 0x9e, 0x4e, 0x29, 0x68, 0x6b, 0xc2, 0x25, 0xe2, 0x0c, 0x2d, 0xaf, 0x4b, 0x37, 0xc5, 0x20, 0x72, 0xf4, 0x81, - 0xdd, 0xd2, 0x86, 0xe0, 0xdb, 0x22, 0xfc, 0x6c, 0x26, 0xd4, 0x93, 0xad, 0x40, 0xad, 0x88, 0x2a, 0x7b, 0x88, 0x16, - 0x02, 0xcb, 0x89, 0xe4, 0xa4, 0x37, 0x75, 0x26, 0x90, 0x60, 0xea, 0x15, 0x6f, 0xbb, 0x60, 0xc8, 0x62, 0x97, 0x2b, - 0x0c, 0x2c, 0xa2, 0x64, 0x2a, 0x7e, 0xbd, 0x3c, 0x95, 0x46, 0x0b, 0x0c, 0x01, 0x4c, 0x73, 0x2f, 0x2f, 0x1a, 0x03, - 0xee, 0xfe, 0xee, 0x46, 0x9a, 0x6e, 0x48, 0xe0, 0x9b, 0x67, 0xf3, 0x5e, 0x4a, 0x06, 0x7a, 0x6e, 0xf2, 0xeb, 0x49, - 0xda, 0x89, 0x9c, 0x93, 0xda, 0x9c, 0xe1, 0x10, 0xa0, 0xaa, 0xd9, 0x43, 0x9a, 0x56, 0xa5, 0xec, 0xc4, 0x25, 0x90, - 0xe5, 0x37, 0x11, 0xf8, 0xf2, 0xcb, 0x63, 0xec, 0x9d, 0x8a, 0xcc, 0x14, 0x61, 0x4f, 0x94, 0x4f, 0x1b, 0x56, 0x77, - 0xf3, 0xf0, 0x34, 0x47, 0xb0, 0xf3, 0x87, 0x69, 0xdc, 0xd7, 0x0d, 0xcf, 0x00, 0x30, 0x03, 0xe1, 0x13, 0x82, 0x4f, - 0x30, 0x44, 0x33, 0xdd, 0xdc, 0x76, 0x1f, 0x55, 0xa5, 0xaa, 0x78, 0x0a, 0x70, 0x7c, 0x82, 0xe1, 0x9d, 0xa9, 0xc7, - 0x66, 0x09, 0x36, 0xcf, 0x23, 0x30, 0x84, 0xdc, 0x34, 0xa7, 0x9a, 0x72, 0x03, 0xe4, 0xbb, 0x88, 0x61, 0x8a, 0x67, - 0xb1, 0x47, 0xc3, 0x07, 0xd4, 0x2b, 0x6f, 0xee, 0xbc, 0xc0, 0x6f, 0xb3, 0x88, 0x65, 0xcf, 0x93, 0x51, 0x06, 0x9f, - 0x88, 0x7c, 0x8b, 0x14, 0x32, 0xf7, 0x83, 0xa6, 0xb0, 0xda, 0xa6, 0xf5, 0x33, 0x20, 0x72, 0x73, 0x75, 0x63, 0xa2, - 0x35, 0x70, 0xa1, 0x37, 0x51, 0x5d, 0x40, 0x6b, 0x9b, 0xf5, 0xe1, 0x66, 0x57, 0x22, 0x19, 0x3c, 0x10, 0xe6, 0xdf, - 0x78, 0xf1, 0x60, 0xf2, 0x2d, 0xe4, 0xc9, 0xf0, 0x91, 0x87, 0xd3, 0xbd, 0xb5, 0xe7, 0xad, 0xfb, 0x96, 0xbb, 0x6a, - 0x4d, 0x9e, 0xd3, 0x22, 0x94, 0xd8, 0x49, 0x06, 0x70, 0x04, 0x1f, 0x9b, 0xb1, 0xee, 0x03, 0xd4, 0x89, 0x0c, 0x2e, - 0x54, 0x31, 0xe3, 0xcc, 0x38, 0xca, 0xf2, 0x2b, 0xae, 0x39, 0xb8, 0xfd, 0xbc, 0x72, 0x31, 0x10, 0xb0, 0xd0, 0x81, - 0x32, 0xf5, 0x47, 0x32, 0xb5, 0x35, 0x4d, 0x8e, 0xf9, 0x19, 0x2c, 0x10, 0x19, 0x05, 0x01, 0xc8, 0xc2, 0xd3, 0xb6, - 0x4a, 0xf7, 0xf1, 0xa0, 0x1b, 0x50, 0xde, 0x08, 0xcc, 0xc8, 0xa0, 0x43, 0x30, 0x63, 0x6d, 0x67, 0x22, 0x11, 0x61, - 0x12, 0xae, 0x2c, 0x6a, 0xf8, 0x17, 0x4f, 0x49, 0xf9, 0x98, 0x87, 0xbe, 0x20, 0x8c, 0x8b, 0x79, 0x45, 0xe1, 0x90, - 0x82, 0x74, 0x2e, 0xae, 0xbe, 0x65, 0x99, 0x9c, 0x53, 0x2f, 0x43, 0xa1, 0x8b, 0x84, 0x51, 0x66, 0x93, 0x7a, 0x22, - 0x03, 0x48, 0xc6, 0x2a, 0x33, 0x94, 0x2b, 0xbc, 0x1e, 0x55, 0x72, 0x51, 0xf3, 0x6f, 0xcc, 0xca, 0xb8, 0x1c, 0x5b, - 0xd6, 0x0d, 0xeb, 0x0c, 0x8e, 0x57, 0xaa, 0x65, 0xf2, 0x4d, 0x51, 0x9c, 0x78, 0xf1, 0x19, 0x03, 0xf1, 0x7e, 0x56, - 0x6f, 0xb3, 0x9b, 0x43, 0x5c, 0xee, 0xda, 0xc2, 0x95, 0x49, 0xc5, 0x20, 0x96, 0x30, 0x11, 0xb4, 0x28, 0x8d, 0x3f, - 0x72, 0x30, 0xc5, 0x29, 0x40, 0x1b, 0x0b, 0x3f, 0x19, 0x49, 0x55, 0xe5, 0xb0, 0x5c, 0x46, 0x6f, 0xa5, 0xa8, 0xb1, - 0x59, 0x5e, 0x46, 0x9b, 0x79, 0x12, 0x10, 0xe0, 0xea, 0x4a, 0x59, 0xcd, 0xae, 0x4f, 0x1d, 0xb6, 0x67, 0x5c, 0x59, - 0xca, 0x09, 0x53, 0x34, 0x6b, 0x2c, 0x25, 0xc2, 0xb8, 0xcd, 0xc5, 0xb6, 0x38, 0x7e, 0x57, 0xf3, 0x97, 0xd2, 0x6f, - 0xe0, 0x2e, 0x77, 0x4d, 0x01, 0x6e, 0x91, 0x47, 0xf4, 0x8e, 0x5c, 0x06, 0x7c, 0x67, 0x54, 0x6f, 0xd0, 0x80, 0x2d, - 0x5a, 0x6e, 0xcd, 0xc7, 0xb2, 0x3c, 0xf4, 0x55, 0x74, 0xe1, 0x62, 0x11, 0xd1, 0xea, 0x50, 0xeb, 0xfd, 0xde, 0xfe, - 0xd3, 0x5e, 0xb5, 0xd3, 0x80, 0x0e, 0x28, 0x7d, 0xad, 0xd3, 0xdb, 0x2e, 0xff, 0xab, 0x1f, 0x6e, 0x8b, 0x44, 0x9f, - 0x97, 0xd4, 0x0d, 0x74, 0x08, 0x72, 0x07, 0x82, 0xad, 0x74, 0x3d, 0x67, 0x8e, 0x83, 0x5e, 0x58, 0x12, 0x6a, 0xe1, - 0x75, 0x79, 0x1b, 0x04, 0x0f, 0xa6, 0x94, 0xc4, 0x1a, 0x8f, 0xaa, 0x39, 0x0c, 0xe8, 0xc3, 0x2d, 0xd6, 0x6a, 0x62, - 0xfa, 0x13, 0xa2, 0xca, 0x44, 0x7a, 0x60, 0x7b, 0xd1, 0xc4, 0x84, 0x87, 0xfd, 0xa0, 0x24, 0x25, 0x54, 0x07, 0x82, - 0x36, 0x50, 0x26, 0xd6, 0xf1, 0x65, 0x87, 0x82, 0xe7, 0x42, 0x0b, 0x6c, 0x62, 0xb0, 0xef, 0xb8, 0x18, 0x12, 0x15, - 0x3b, 0xa4, 0xd4, 0x63, 0xa4, 0x76, 0x87, 0x2d, 0x62, 0x7f, 0x52, 0x0d, 0x94, 0xfe, 0x6e, 0xdc, 0xf7, 0xad, 0x15, - 0x40, 0xa9, 0x6b, 0x7e, 0xdc, 0xf7, 0x28, 0xf6, 0x60, 0x11, 0xbf, 0x0e, 0xc1, 0x99, 0x6c, 0xd7, 0x54, 0xc4, 0x9a, - 0xcf, 0x92, 0x3d, 0x37, 0x6c, 0xf8, 0xfb, 0x8a, 0x40, 0xc6, 0x48, 0xd3, 0xa1, 0x8c, 0xcd, 0xf8, 0x59, 0x46, 0x31, - 0x45, 0xd8, 0x17, 0x7e, 0x27, 0x09, 0x11, 0x22, 0x64, 0x0c, 0xd3, 0x1c, 0x41, 0x3b, 0xf3, 0x79, 0x52, 0x0b, 0x54, - 0xd7, 0x24, 0xf4, 0x3d, 0xdd, 0x1d, 0x88, 0x07, 0x39, 0x7a, 0x54, 0x02, 0xa0, 0xff, 0x5b, 0x3c, 0x7b, 0x72, 0xce, - 0x18, 0xc1, 0x5a, 0x71, 0x22, 0x8d, 0x2b, 0x70, 0x9c, 0xe3, 0x93, 0x16, 0x12, 0xc4, 0x4b, 0x75, 0x27, 0xa1, 0x4f, - 0xda, 0x38, 0x35, 0x78, 0x82, 0x5c, 0x14, 0x2b, 0x15, 0x80, 0xda, 0x2d, 0x78, 0xb3, 0x84, 0x19, 0x33, 0xa4, 0x47, - 0xde, 0x83, 0x35, 0x0f, 0x75, 0x29, 0x97, 0xc7, 0x9c, 0x9c, 0x21, 0x6a, 0x2e, 0xf2, 0xa4, 0xc6, 0x5c, 0x41, 0x5f, - 0x83, 0xe2, 0x14, 0xda, 0x18, 0x13, 0xab, 0xcd, 0x53, 0x9f, 0xaa, 0xa1, 0x28, 0x3d, 0x9b, 0xe5, 0xc5, 0x3a, 0xe2, - 0x12, 0xd8, 0x85, 0x66, 0xf4, 0xc1, 0xaf, 0x64, 0x92, 0xc3, 0x41, 0x9a, 0x27, 0x82, 0x8e, 0xf2, 0xc1, 0xd0, 0xc9, - 0x8c, 0xf6, 0x2e, 0x3d, 0x62, 0x47, 0x0f, 0x25, 0xa7, 0x2f, 0x50, 0x7a, 0x08, 0x01, 0xfa, 0xab, 0xe1, 0x4d, 0xdb, - 0x5f, 0xd1, 0x49, 0xf1, 0x62, 0xc2, 0x3b, 0x49, 0x14, 0xe1, 0x21, 0x9c, 0x11, 0x85, 0x8c, 0x44, 0xfb, 0x60, 0x30, - 0xf3, 0xce, 0xb6, 0x35, 0xe5, 0x7d, 0x51, 0xa7, 0x4e, 0x73, 0xf0, 0xf4, 0xbd, 0x78, 0x2d, 0x37, 0x0f, 0x02, 0x7a, - 0xec, 0xcb, 0x96, 0x90, 0x9d, 0x27, 0x03, 0x08, 0x90, 0x2f, 0x76, 0xc8, 0x98, 0x20, 0x0d, 0x6b, 0x5a, 0x92, 0x35, - 0xfd, 0x68, 0x11, 0xfa, 0xa7, 0xea, 0xe3, 0x34, 0xcb, 0x84, 0x50, 0x5b, 0x18, 0x03, 0x22, 0xf4, 0x94, 0x93, 0x82, - 0x15, 0xb9, 0x0f, 0x5e, 0x52, 0x38, 0x1c, 0xac, 0xd7, 0xc5, 0xf0, 0xa4, 0x39, 0x1b, 0x02, 0xdb, 0x31, 0x01, 0x9d, - 0x66, 0x48, 0x14, 0x62, 0xc3, 0x7d, 0x8c, 0x66, 0x92, 0x0a, 0xc6, 0x34, 0x51, 0xf9, 0xd0, 0x3f, 0xa8, 0x8d, 0xb8, - 0x49, 0x3d, 0x8a, 0x87, 0x11, 0xf6, 0x1c, 0x87, 0xae, 0x13, 0xcb, 0x80, 0xa8, 0xb2, 0xa4, 0xb2, 0xe6, 0x7a, 0xd4, - 0x34, 0x23, 0x83, 0x2a, 0x91, 0xfa, 0x45, 0x5b, 0x07, 0x97, 0x06, 0xd4, 0xb3, 0xf8, 0x66, 0xe0, 0xb9, 0x25, 0xb4, - 0xdc, 0x9f, 0x23, 0x89, 0x27, 0x83, 0x51, 0x8f, 0xe6, 0x08, 0x2f, 0xdd, 0x1d, 0x02, 0xe0, 0xad, 0xf2, 0x76, 0xd5, - 0xf3, 0xef, 0x28, 0x63, 0x27, 0x6e, 0xaa, 0xad, 0x52, 0x92, 0x5a, 0x83, 0x12, 0xf3, 0xef, 0xf2, 0xc7, 0x38, 0x77, - 0x15, 0x0b, 0xee, 0xbd, 0xa7, 0x6b, 0x85, 0xfa, 0xd3, 0x27, 0xb2, 0x93, 0xc2, 0x8d, 0xd3, 0x1b, 0x44, 0xe6, 0xe1, - 0x23, 0x6a, 0xc1, 0x5c, 0xe0, 0xee, 0xb8, 0xa8, 0x7b, 0xf3, 0x37, 0x84, 0x9b, 0xa2, 0xa6, 0xd0, 0x85, 0x92, 0x8d, - 0x16, 0x5f, 0xc9, 0xcc, 0x00, 0xcd, 0xe5, 0x4a, 0x2d, 0x3c, 0x67, 0x3d, 0x50, 0xfb, 0x15, 0x89, 0x5b, 0xeb, 0xf5, - 0xb5, 0x5b, 0xdb, 0x43, 0xb8, 0x9a, 0x2c, 0xa8, 0x63, 0x24, 0x79, 0xcc, 0x1c, 0x5a, 0x2b, 0x32, 0x5d, 0x93, 0x84, - 0xe6, 0x92, 0x5a, 0xaf, 0x2e, 0x1a, 0x7e, 0xfe, 0xda, 0x44, 0x10, 0x13, 0x46, 0x56, 0x2b, 0xe8, 0x1d, 0xb6, 0x9b, - 0x5f, 0x2c, 0x5c, 0x6d, 0x52, 0xa6, 0xc2, 0x21, 0x50, 0x9b, 0x2c, 0x3f, 0xc7, 0xd2, 0x53, 0x14, 0x44, 0xea, 0xb4, - 0xd5, 0x55, 0x42, 0x42, 0xb0, 0x52, 0xa9, 0x7f, 0x1d, 0x98, 0x90, 0x23, 0x2a, 0x47, 0x64, 0xf7, 0xba, 0x9c, 0xf3, - 0x53, 0x03, 0xd2, 0xdd, 0x88, 0x48, 0xc8, 0xe9, 0x8d, 0x01, 0x5d, 0x16, 0x1a, 0xfb, 0xdb, 0x80, 0x2b, 0x7c, 0x88, - 0xd0, 0xe9, 0xd8, 0x95, 0x72, 0x5d, 0x84, 0xfb, 0xbe, 0x40, 0x8a, 0xaa, 0x22, 0x82, 0x05, 0xd5, 0x8e, 0x6c, 0xce, - 0x8e, 0xfc, 0xc6, 0x1a, 0x1c, 0xce, 0xcd, 0xf1, 0xae, 0x51, 0x84, 0xd2, 0xc5, 0xce, 0xe3, 0x40, 0x4f, 0x94, 0x24, - 0x7c, 0x77, 0x8c, 0xd0, 0x5a, 0xeb, 0xfc, 0xac, 0xfb, 0x01, 0xcf, 0x92, 0x70, 0xfe, 0x81, 0x4d, 0xde, 0x97, 0xe4, - 0xbc, 0xbc, 0xda, 0xd4, 0x6d, 0xc1, 0x08, 0x40, 0x7d, 0xe3, 0x79, 0x5b, 0x79, 0x70, 0x83, 0x91, 0x41, 0x9e, 0xcc, - 0x09, 0xc6, 0x33, 0x57, 0x83, 0x79, 0x76, 0xec, 0x2c, 0xef, 0xb1, 0x10, 0xc8, 0x53, 0x4d, 0x6d, 0x5a, 0x2b, 0xb1, - 0x45, 0x3b, 0x66, 0xbf, 0x65, 0x03, 0x9c, 0x00, 0xa7, 0xc3, 0xf1, 0xd2, 0x36, 0xf8, 0x40, 0x2e, 0xe9, 0xad, 0x65, - 0x14, 0x64, 0x17, 0xfe, 0x6d, 0xa8, 0x8f, 0x28, 0xaf, 0x40, 0xa8, 0x48, 0xea, 0xd8, 0x28, 0x29, 0x45, 0xa9, 0x11, - 0x5a, 0x66, 0x5b, 0x90, 0x15, 0x67, 0x7b, 0xc4, 0xa3, 0x66, 0x86, 0x87, 0x22, 0xb7, 0x45, 0x3a, 0x6b, 0xb8, 0x2f, - 0x05, 0x2a, 0x36, 0x85, 0x34, 0xd3, 0x1a, 0xd8, 0xc6, 0x3d, 0x59, 0x53, 0x7b, 0xb7, 0x11, 0x35, 0x83, 0x47, 0xf4, - 0x2d, 0x4d, 0x4d, 0xdf, 0xaf, 0x8d, 0xb4, 0x52, 0x0c, 0x94, 0x39, 0xc4, 0x74, 0x4d, 0x8d, 0x99, 0x54, 0xa9, 0xc5, - 0x7e, 0xdd, 0xe6, 0xd3, 0x6f, 0x17, 0xca, 0x21, 0x39, 0x70, 0x42, 0xc9, 0x11, 0x43, 0x76, 0x86, 0x21, 0xb8, 0x95, - 0xb3, 0x89, 0x64, 0xb9, 0x11, 0xb9, 0xcc, 0x3a, 0xa3, 0x3b, 0xfe, 0xc1, 0x04, 0x50, 0xe8, 0x8b, 0x05, 0x0a, 0xfa, - 0xb1, 0xda, 0xfa, 0x44, 0x1d, 0x49, 0x25, 0x29, 0x3e, 0x5d, 0xb8, 0x8a, 0xca, 0xa1, 0xe6, 0xea, 0x55, 0x51, 0x81, - 0x5a, 0x13, 0x3a, 0x70, 0x3d, 0x42, 0x60, 0x03, 0x61, 0xf4, 0x47, 0x53, 0x08, 0xcb, 0x7d, 0x15, 0x37, 0xed, 0x26, - 0xef, 0x9e, 0xce, 0xf6, 0x18, 0xa9, 0x41, 0x16, 0x5a, 0x56, 0x1c, 0xc3, 0xe9, 0x01, 0x4f, 0x06, 0x8f, 0x1d, 0x33, - 0x6c, 0x36, 0x4e, 0x8f, 0x31, 0x06, 0x58, 0xb2, 0xc2, 0x62, 0x9b, 0x4a, 0x6b, 0x45, 0x84, 0xd4, 0x36, 0xab, 0x97, - 0x36, 0x77, 0x8a, 0xfc, 0xf6, 0x67, 0x00, 0x98, 0x57, 0x4d, 0xa6, 0x75, 0x14, 0x53, 0xc4, 0x28, 0x69, 0xb3, 0x38, - 0x5e, 0x88, 0x95, 0x17, 0x1f, 0x0b, 0xdc, 0x1f, 0xa1, 0x72, 0x65, 0xb9, 0xe0, 0xea, 0x4c, 0xee, 0x87, 0x9b, 0xef, - 0x33, 0x27, 0x11, 0x2f, 0x98, 0xe8, 0x33, 0x66, 0xc3, 0xd5, 0x85, 0x77, 0xa4, 0x4e, 0xb3, 0x98, 0xdc, 0xfb, 0xe2, - 0x2d, 0x9f, 0xe7, 0x2e, 0xa0, 0xb2, 0x07, 0xb1, 0xdb, 0xaa, 0x8c, 0xf5, 0x3a, 0x23, 0x83, 0x84, 0x6f, 0x29, 0xd9, - 0x2b, 0x19, 0x3b, 0xf1, 0x19, 0x64, 0x7a, 0xb0, 0x0c, 0x0b, 0x4f, 0x19, 0xc9, 0xed, 0x33, 0x55, 0xd4, 0xae, 0xa7, - 0x54, 0xae, 0x8b, 0xee, 0xbc, 0xe6, 0xde, 0x56, 0xb8, 0x53, 0x33, 0x93, 0x4e, 0xbc, 0x2e, 0x40, 0x9d, 0x0f, 0x2e, - 0x2d, 0xd2, 0x39, 0x2f, 0x60, 0xd1, 0x0c, 0x85, 0xeb, 0xa9, 0x1a, 0x7d, 0xb6, 0xdc, 0x47, 0x16, 0xc3, 0xa6, 0x3b, - 0xbf, 0x2c, 0x7b, 0x34, 0xf9, 0x64, 0x81, 0x40, 0xec, 0x29, 0x3c, 0xbe, 0xa4, 0xc1, 0xad, 0xc5, 0xcf, 0xb4, 0xd5, - 0x56, 0x06, 0xaa, 0x4d, 0x52, 0x0b, 0xfc, 0x64, 0x39, 0xe2, 0xe4, 0x70, 0x6a, 0x79, 0xd7, 0xc0, 0x97, 0xf8, 0x05, - 0xf4, 0x87, 0xb0, 0x2a, 0x52, 0x97, 0x88, 0x6f, 0x09, 0x65, 0xe5, 0x98, 0xfb, 0x0d, 0xc8, 0x7a, 0x98, 0x2d, 0x14, - 0xc7, 0x9b, 0x70, 0x44, 0xa2, 0xb4, 0xfd, 0xdc, 0x1f, 0x1f, 0xf4, 0x2b, 0x7a, 0x0c, 0x86, 0xe3, 0x40, 0x85, 0xc8, - 0x99, 0x12, 0x22, 0x0a, 0xa7, 0x25, 0x5c, 0x86, 0xc6, 0x3c, 0x14, 0x04, 0x64, 0xd4, 0xff, 0x81, 0x70, 0x70, 0x31, - 0x6f, 0x9d, 0xa0, 0x52, 0x55, 0x5a, 0x58, 0x2e, 0x7b, 0xb1, 0x1f, 0x40, 0x95, 0x87, 0x3c, 0x60, 0x7d, 0xde, 0x71, - 0x9d, 0x33, 0x0b, 0x1e, 0x08, 0x46, 0x40, 0x12, 0x33, 0x5b, 0x47, 0xb7, 0x7a, 0xfa, 0x8b, 0xbb, 0x4e, 0x40, 0x3f, - 0x6e, 0x18, 0x7f, 0x84, 0x53, 0x51, 0x5a, 0xc8, 0x5f, 0xb5, 0x24, 0x9b, 0x30, 0xba, 0x0d, 0x8d, 0x75, 0x88, 0xc4, - 0xc5, 0x25, 0x47, 0xcf, 0x79, 0x51, 0xa0, 0x1c, 0xba, 0xee, 0x00, 0x8f, 0x85, 0x77, 0x57, 0x14, 0x68, 0x2e, 0xdc, - 0x35, 0x7d, 0x21, 0x27, 0xd6, 0x3a, 0x3c, 0x62, 0xad, 0x6d, 0x1b, 0xa2, 0x07, 0xcb, 0x29, 0x9e, 0xa1, 0xa1, 0x5c, - 0x2b, 0xd5, 0x92, 0x6c, 0x52, 0xcf, 0x80, 0x8c, 0x95, 0x7a, 0x82, 0x26, 0x65, 0xde, 0x21, 0x9e, 0x3a, 0x18, 0x3b, - 0x74, 0x93, 0x41, 0xf4, 0x5f, 0x47, 0xe6, 0x44, 0xe5, 0x9e, 0xf4, 0x63, 0xdb, 0xa8, 0xe0, 0x00, 0xe8, 0x68, 0x79, - 0xbf, 0xec, 0xbe, 0x77, 0xab, 0xb3, 0x14, 0x6d, 0x78, 0x55, 0x91, 0x84, 0x5a, 0x47, 0xfb, 0xbc, 0x86, 0xe7, 0xdb, - 0x11, 0x61, 0x44, 0xb7, 0x07, 0x66, 0x85, 0xb3, 0x6d, 0x52, 0x8c, 0x5d, 0xb5, 0xe0, 0x84, 0x79, 0x08, 0x88, 0x77, - 0x3d, 0xa9, 0x0e, 0x2b, 0x0d, 0xd1, 0x79, 0x1e, 0x5e, 0x2e, 0xae, 0x58, 0x98, 0xaa, 0x5e, 0x0a, 0x62, 0xbf, 0xf9, - 0xe0, 0x03, 0xf7, 0x79, 0x86, 0x61, 0xe3, 0xcd, 0x28, 0x4f, 0x8f, 0x31, 0x3b, 0x3f, 0xc4, 0x6e, 0xea, 0x48, 0x5f, - 0x71, 0x01, 0x7a, 0xbd, 0x27, 0xa7, 0xef, 0xd0, 0xf7, 0xa2, 0xe3, 0x8c, 0x2f, 0x0c, 0xd7, 0x8e, 0xf3, 0x05, 0x71, - 0x4a, 0x84, 0x28, 0xf5, 0x78, 0x51, 0x8f, 0x59, 0x22, 0x5e, 0x05, 0xc1, 0xb6, 0xe5, 0xcd, 0xf8, 0xef, 0xc2, 0x49, - 0xca, 0x77, 0xc7, 0x90, 0xc0, 0xe3, 0xc1, 0x9f, 0xa3, 0xe3, 0x02, 0x67, 0x22, 0x72, 0x18, 0x87, 0x3b, 0xb7, 0x55, - 0x4a, 0xef, 0xdb, 0xb0, 0x66, 0xea, 0xf5, 0xe7, 0x05, 0x21, 0xe3, 0x86, 0x1c, 0xb8, 0x83, 0x22, 0x9e, 0x96, 0xc0, - 0x5c, 0x9b, 0x42, 0x88, 0x7a, 0xfc, 0x37, 0xdc, 0x3c, 0x45, 0xf8, 0xa8, 0x11, 0x85, 0x89, 0xa6, 0xa6, 0xe4, 0xae, - 0xd8, 0x00, 0xac, 0xc4, 0x09, 0xed, 0x20, 0xf5, 0x43, 0x59, 0x79, 0x85, 0x81, 0xd5, 0xa2, 0xae, 0x04, 0x6a, 0x59, - 0x20, 0x8f, 0x0c, 0x4e, 0xec, 0xbd, 0x08, 0x8b, 0xae, 0x61, 0x14, 0xf4, 0x60, 0xaa, 0xb6, 0x5e, 0xc2, 0xeb, 0x6e, - 0x0b, 0xcb, 0x0f, 0xef, 0x57, 0x53, 0xcb, 0x5d, 0x95, 0x3f, 0x1e, 0x20, 0x67, 0xc9, 0xe9, 0x03, 0x80, 0x15, 0x0f, - 0x53, 0xc0, 0x56, 0xef, 0xcd, 0x61, 0x6b, 0x77, 0x89, 0xc6, 0x6d, 0xe6, 0x4f, 0x77, 0x48, 0x30, 0x4a, 0xfa, 0xd9, - 0xe7, 0x3f, 0xcf, 0x60, 0x71, 0xf4, 0x06, 0xc0, 0x43, 0xac, 0x3b, 0x59, 0xd5, 0xad, 0xec, 0x1e, 0xff, 0xf4, 0xa1, - 0x29, 0x12, 0xe9, 0x89, 0x69, 0xfc, 0xe2, 0xa8, 0x26, 0x7b, 0xab, 0x1d, 0x23, 0x67, 0x77, 0x24, 0xce, 0x4a, 0x09, - 0xc9, 0xe5, 0x88, 0x4a, 0x74, 0xdb, 0x23, 0x8a, 0xe0, 0xb5, 0x77, 0x96, 0x61, 0xa3, 0x5f, 0xc3, 0x08, 0x05, 0xa0, - 0x26, 0x60, 0xf8, 0xa0, 0xb2, 0xde, 0x09, 0x00, 0x8c, 0xd2, 0xaa, 0xa9, 0x53, 0x46, 0x17, 0xbb, 0xe9, 0xf2, 0xe2, - 0x41, 0xa6, 0xb4, 0x13, 0x35, 0x93, 0xdb, 0x13, 0x2a, 0x5b, 0x2d, 0x8c, 0x6d, 0xbf, 0x64, 0xc4, 0xa7, 0x81, 0x44, - 0x2b, 0x2c, 0x30, 0xa3, 0x83, 0x65, 0x29, 0xcb, 0x51, 0x22, 0xb1, 0x4c, 0x90, 0x5d, 0x79, 0x33, 0x8c, 0xbc, 0x0d, - 0xac, 0xc8, 0x8c, 0x48, 0x24, 0x5b, 0xd4, 0x74, 0x44, 0x0c, 0x8f, 0xda, 0x31, 0xab, 0xba, 0xb4, 0xb1, 0x62, 0xe1, - 0xe9, 0xe6, 0xd0, 0x93, 0x2b, 0xa4, 0xe8, 0x72, 0x1f, 0xa4, 0x50, 0x4c, 0x17, 0x6d, 0x5c, 0x9d, 0xdb, 0xec, 0x8b, - 0x28, 0xf3, 0x15, 0x99, 0x17, 0xb1, 0x98, 0xdd, 0x3f, 0xd9, 0xd8, 0x61, 0xb2, 0x3c, 0xce, 0xc9, 0x64, 0xe6, 0x40, - 0x35, 0x6d, 0xc8, 0xb5, 0xe4, 0xb5, 0x64, 0xc5, 0x49, 0x5c, 0xfc, 0xbb, 0xbc, 0x6c, 0xf3, 0x64, 0xaa, 0x10, 0x41, - 0x0f, 0xb3, 0x64, 0x81, 0x59, 0xaa, 0xa5, 0x83, 0x12, 0xce, 0x22, 0xb2, 0xa3, 0x81, 0xe9, 0x4d, 0x49, 0x9b, 0x7c, - 0xd0, 0x49, 0x77, 0x27, 0x6f, 0x0d, 0x09, 0xd7, 0x6b, 0x9c, 0xd8, 0x16, 0x73, 0x31, 0xe2, 0xa9, 0xef, 0xca, 0x24, - 0x5a, 0x91, 0x78, 0x90, 0x25, 0x31, 0x57, 0x9e, 0x8d, 0x45, 0x89, 0x2f, 0x72, 0x7a, 0x5a, 0x2f, 0x66, 0xa3, 0x45, - 0x1a, 0xfb, 0xc3, 0xc8, 0x2f, 0x8b, 0x9f, 0xdd, 0x8e, 0x1c, 0xf5, 0xf6, 0x84, 0xf2, 0xac, 0xa6, 0xb6, 0xae, 0x99, - 0x39, 0x66, 0x94, 0x69, 0xa4, 0x10, 0x4b, 0x48, 0x9f, 0x8c, 0x08, 0x5a, 0x9c, 0x0e, 0x6c, 0xd8, 0xfc, 0x4e, 0x05, - 0x9e, 0xa9, 0xdd, 0x5e, 0x0d, 0x0d, 0xcf, 0x2b, 0x24, 0x82, 0x0b, 0x1a, 0x6f, 0x70, 0xd4, 0x0c, 0xf5, 0x7f, 0x78, - 0x3a, 0x6f, 0xcd, 0x74, 0xf6, 0x44, 0x32, 0xb2, 0xb4, 0xf0, 0x0c, 0x70, 0x3e, 0xa9, 0x4a, 0x73, 0x7b, 0x3f, 0xc8, - 0x23, 0xeb, 0xfe, 0x49, 0x54, 0xbf, 0x22, 0xb0, 0x3b, 0x49, 0x4c, 0x08, 0xd0, 0xf0, 0xba, 0x9e, 0x0d, 0x13, 0x09, - 0xad, 0x04, 0xef, 0xbb, 0x0a, 0xfe, 0x4e, 0xca, 0x24, 0x5d, 0x9a, 0xd0, 0xe4, 0xa2, 0x5c, 0x0d, 0x76, 0xb2, 0x40, - 0xbe, 0x05, 0xd8, 0x40, 0x10, 0x08, 0xac, 0x30, 0xef, 0x98, 0x4a, 0x68, 0x07, 0xd2, 0x40, 0xe6, 0x04, 0x98, 0x64, - 0xe3, 0x5c, 0x19, 0x14, 0xd5, 0x46, 0x3e, 0xad, 0x72, 0x36, 0x24, 0x1a, 0x06, 0x99, 0xf5, 0xc7, 0xd0, 0xd9, 0x2b, - 0x26, 0xc9, 0xbc, 0xbf, 0x73, 0x34, 0x9e, 0x6c, 0xcf, 0x90, 0x28, 0xe4, 0x6a, 0x9f, 0x41, 0x3c, 0xa1, 0x19, 0x2e, - 0x2b, 0x51, 0x5f, 0xd6, 0xb5, 0xfa, 0x4f, 0xaa, 0xf7, 0x1d, 0x3c, 0x39, 0x90, 0x45, 0x6f, 0xe3, 0xc0, 0x72, 0xcb, - 0x16, 0x01, 0xe6, 0xf9, 0x1a, 0x68, 0x46, 0x09, 0x20, 0x43, 0x13, 0x60, 0xae, 0x31, 0x7b, 0x69, 0x68, 0x46, 0x28, - 0xfb, 0x22, 0xd7, 0x26, 0xa1, 0xe8, 0x61, 0xee, 0xcb, 0x2b, 0x71, 0x9b, 0xeb, 0x1d, 0xd2, 0xeb, 0xb6, 0x7a, 0x8f, - 0x5d, 0x8e, 0xc8, 0x72, 0x8a, 0xb8, 0x4d, 0xa8, 0x1e, 0xa0, 0x90, 0x55, 0x13, 0xa6, 0x75, 0xb0, 0x3b, 0xe3, 0x2f, - 0x49, 0x88, 0x30, 0x21, 0x31, 0xaa, 0x8f, 0xd0, 0xb1, 0x1a, 0xfb, 0x44, 0x8f, 0x25, 0x47, 0xa2, 0x37, 0x48, 0x1d, - 0xb9, 0x14, 0x3a, 0x8f, 0x0b, 0x75, 0x6d, 0xad, 0xb6, 0xe0, 0x12, 0x61, 0xc0, 0x89, 0x55, 0x0e, 0x87, 0xcb, 0xa9, - 0x50, 0xd9, 0x12, 0xf7, 0x36, 0x66, 0xd4, 0xcb, 0x9d, 0xb7, 0x59, 0x97, 0x7a, 0x6f, 0x12, 0x16, 0x91, 0xe5, 0xa1, - 0x62, 0x1c, 0x08, 0x05, 0x6b, 0xfb, 0x60, 0x79, 0x8d, 0x33, 0xf2, 0x2c, 0xc3, 0x66, 0x30, 0x7a, 0x1f, 0xa0, 0xac, - 0xa8, 0xc7, 0xe1, 0x02, 0x10, 0xeb, 0x43, 0xf2, 0xa2, 0xc9, 0x0c, 0x01, 0x16, 0xd9, 0xe2, 0x52, 0x93, 0x2c, 0x14, - 0x3a, 0xea, 0xaf, 0x7b, 0x40, 0xbb, 0x16, 0x12, 0x03, 0xe9, 0xf0, 0xa8, 0x93, 0xae, 0x66, 0x89, 0x65, 0x73, 0x0c, - 0x0d, 0x85, 0xc5, 0x69, 0x9e, 0xa7, 0x23, 0xdb, 0xda, 0x3b, 0xc0, 0x89, 0x8e, 0xae, 0x17, 0xe0, 0xb6, 0x83, 0x4b, - 0x21, 0xc7, 0x11, 0xdc, 0x34, 0x47, 0x79, 0x76, 0x2a, 0x6d, 0x0a, 0x46, 0x13, 0x37, 0x2b, 0xcd, 0x85, 0x2e, 0xa7, - 0xf0, 0x3c, 0xdd, 0xfa, 0x13, 0x15, 0xfd, 0xd3, 0x52, 0x3b, 0x83, 0x41, 0x95, 0xd3, 0xae, 0x94, 0xb1, 0xa4, 0x5d, - 0x73, 0xf4, 0x85, 0x40, 0x1e, 0x16, 0xfa, 0x7e, 0xa1, 0x71, 0xe7, 0xd4, 0x41, 0xf1, 0x8e, 0x71, 0x66, 0xa7, 0x07, - 0x0d, 0x7b, 0xa5, 0xf1, 0x68, 0x44, 0x29, 0x2b, 0xf5, 0x03, 0xe3, 0x5a, 0xde, 0x9e, 0x10, 0x6d, 0x32, 0x0a, 0x77, - 0x28, 0xcb, 0xe4, 0xdb, 0x1e, 0x07, 0x9a, 0xb6, 0x67, 0xdc, 0x76, 0x5b, 0xdf, 0xae, 0x93, 0x5b, 0x44, 0xe2, 0xf6, - 0x17, 0x5c, 0xc2, 0x33, 0xf8, 0xc6, 0x90, 0x8a, 0x3d, 0xeb, 0xc4, 0xe5, 0xcb, 0x28, 0xcb, 0xf9, 0x0a, 0x47, 0x57, - 0x4c, 0xc6, 0xc2, 0x0b, 0x2d, 0x22, 0xdc, 0x34, 0x50, 0xc7, 0x95, 0x24, 0xb1, 0x9b, 0x92, 0xf8, 0xb9, 0xe5, 0x9f, - 0xb7, 0xe6, 0x46, 0xc0, 0x54, 0x24, 0xd7, 0x21, 0xfa, 0xcc, 0xa9, 0x5a, 0xdd, 0x6b, 0x95, 0x05, 0xf5, 0x98, 0xa7, - 0x72, 0xc4, 0x9c, 0xba, 0xdd, 0x14, 0x59, 0x26, 0x3d, 0x6c, 0xae, 0x29, 0x4a, 0x14, 0x68, 0xab, 0x0b, 0xbd, 0xcc, - 0x9c, 0xb3, 0xd0, 0xd1, 0x89, 0x94, 0x6d, 0x8d, 0x66, 0x13, 0x73, 0x1c, 0xce, 0x7e, 0x12, 0xd9, 0x13, 0x5c, 0xf5, - 0x9e, 0xb7, 0xf6, 0x61, 0xb3, 0xf1, 0x75, 0xa8, 0xd5, 0x90, 0x1d, 0x10, 0x68, 0xe6, 0xce, 0x14, 0x28, 0xc2, 0xfe, - 0x2b, 0x3b, 0x12, 0xa5, 0x2c, 0xff, 0xd8, 0x69, 0x5d, 0xdf, 0x36, 0xaa, 0x8e, 0xc9, 0x5f, 0xd3, 0xbe, 0x86, 0xab, - 0x0e, 0x8a, 0x9c, 0xc3, 0xf1, 0x49, 0xbb, 0x33, 0xdd, 0x3c, 0x10, 0x9e, 0xb3, 0xc3, 0xa8, 0x2c, 0x67, 0x57, 0xd4, - 0x1b, 0xba, 0x0a, 0x18, 0xa8, 0x51, 0x32, 0x29, 0x7b, 0xa3, 0xb0, 0x8e, 0xfa, 0x9d, 0xb8, 0xd6, 0x57, 0x14, 0xdd, - 0xb2, 0xc6, 0xad, 0x4d, 0x76, 0xe0, 0x8f, 0x18, 0x2b, 0x77, 0x98, 0x21, 0x3f, 0x5c, 0x63, 0xd5, 0x22, 0xf5, 0x46, - 0xe3, 0x62, 0xdb, 0x6a, 0x3a, 0xd3, 0x40, 0xb7, 0xad, 0x99, 0x1b, 0x61, 0x07, 0xd5, 0x70, 0x5b, 0xb7, 0x95, 0xaa, - 0xb6, 0x9d, 0xc7, 0xaf, 0xf6, 0xd5, 0x89, 0x98, 0xd0, 0x86, 0xa1, 0xaf, 0x81, 0xe9, 0x5a, 0x54, 0x73, 0x31, 0xb0, - 0xa9, 0x5e, 0x2d, 0xf6, 0x5d, 0xc8, 0xee, 0xdd, 0x5f, 0x43, 0x12, 0xaa, 0xe2, 0xca, 0x2d, 0x2f, 0xb7, 0x9f, 0x74, - 0xb2, 0x4a, 0x65, 0x6a, 0x1f, 0xf9, 0x1d, 0x66, 0xca, 0x87, 0x99, 0xe2, 0x71, 0xa5, 0x63, 0x2d, 0x20, 0x0a, 0x43, - 0xe1, 0x55, 0x0a, 0x74, 0x6b, 0x16, 0xf1, 0x0f, 0x74, 0xec, 0xca, 0x98, 0x11, 0x32, 0x1a, 0x95, 0x33, 0x74, 0x43, - 0x42, 0x35, 0x34, 0xb1, 0x9c, 0xa4, 0x4b, 0x0d, 0xba, 0xda, 0xe1, 0x3a, 0xb2, 0x3c, 0x10, 0x02, 0x71, 0x22, 0x87, - 0x39, 0x53, 0x23, 0xda, 0xfd, 0x24, 0x30, 0x91, 0x66, 0x5d, 0xb5, 0x5f, 0x74, 0x38, 0xdd, 0x50, 0x7b, 0x4f, 0xbf, - 0x7c, 0x68, 0xb4, 0xa7, 0x5f, 0xae, 0xb4, 0x3e, 0x39, 0x31, 0xe5, 0xd4, 0x4a, 0xc7, 0x0d, 0x8c, 0xc3, 0x45, 0xe9, - 0xc0, 0xf7, 0x48, 0x35, 0xb8, 0x31, 0xdc, 0x8d, 0x4e, 0xe0, 0x8c, 0xdc, 0x36, 0x22, 0x2b, 0x37, 0x81, 0x99, 0x81, - 0x94, 0xd2, 0x8b, 0x63, 0xe0, 0xbe, 0xed, 0xfd, 0x28, 0xc9, 0x78, 0xd3, 0x64, 0xfc, 0x7a, 0x99, 0x15, 0x4a, 0xdf, - 0x33, 0xb3, 0xd0, 0x55, 0xfc, 0xce, 0x24, 0x77, 0xb5, 0xc6, 0x4e, 0xaa, 0xe5, 0x0c, 0x18, 0xe5, 0x6a, 0x85, 0xe5, - 0x8e, 0xf7, 0xe4, 0xb0, 0xb9, 0x9f, 0x65, 0x09, 0x69, 0xb2, 0x15, 0x55, 0x89, 0x31, 0x22, 0x85, 0xf6, 0x17, 0x67, - 0xe7, 0xfe, 0x68, 0xf1, 0x01, 0x1d, 0xf5, 0x1d, 0x33, 0xae, 0xc6, 0xad, 0xd8, 0x2e, 0x56, 0xec, 0x60, 0x1a, 0xae, - 0x0d, 0xa6, 0x79, 0x80, 0xd0, 0x3d, 0x73, 0x07, 0xf5, 0x0b, 0xfc, 0x8f, 0x7c, 0x5c, 0x55, 0x48, 0x87, 0x2e, 0x9b, - 0xa9, 0x28, 0x5f, 0xa2, 0x06, 0x05, 0x2c, 0x5a, 0xb7, 0x4b, 0x13, 0x30, 0x45, 0x16, 0xd2, 0x2d, 0xa4, 0x20, 0x4a, - 0x16, 0x82, 0x19, 0x54, 0x7c, 0xe5, 0x2f, 0x13, 0x5f, 0xeb, 0xab, 0x85, 0x5e, 0xd2, 0x13, 0xb6, 0x0a, 0xb9, 0xba, - 0x61, 0xb4, 0x98, 0x55, 0xa7, 0x1d, 0xa7, 0x89, 0x43, 0x83, 0x1a, 0x75, 0x44, 0xe8, 0x3a, 0x3e, 0xf8, 0x6c, 0x13, - 0x79, 0x83, 0xc9, 0x4f, 0x4e, 0x02, 0xfe, 0x5e, 0x9f, 0xbc, 0xc5, 0xd9, 0x43, 0xac, 0x4a, 0x33, 0x1e, 0x2f, 0x94, - 0x3d, 0x2a, 0x7b, 0x41, 0xad, 0xb1, 0x9f, 0x5d, 0x98, 0xd6, 0x46, 0x25, 0x85, 0xdc, 0x79, 0xb8, 0x90, 0xef, 0x9c, - 0xc2, 0xb9, 0x1b, 0x95, 0x88, 0xf2, 0x00, 0x66, 0xc2, 0xe6, 0xc4, 0x8d, 0x8a, 0x5b, 0x40, 0xe5, 0x4c, 0x4f, 0x9a, - 0xc4, 0x74, 0x56, 0x22, 0xc6, 0x8c, 0x4e, 0xe1, 0x7a, 0x1c, 0xa2, 0x31, 0x34, 0xc3, 0x9c, 0xde, 0xc7, 0xe8, 0x09, - 0x72, 0x80, 0xb3, 0x76, 0xad, 0x21, 0xc4, 0x4c, 0x2a, 0x7c, 0xef, 0x56, 0xc4, 0x96, 0xd9, 0x17, 0x82, 0xda, 0x36, - 0xef, 0xbb, 0x11, 0x51, 0x5e, 0x29, 0x7c, 0x9f, 0xfb, 0xcb, 0x2f, 0x18, 0xaf, 0x64, 0x68, 0x0d, 0xcf, 0x92, 0x9f, - 0xc3, 0xfc, 0xec, 0x37, 0x76, 0x60, 0x02, 0x12, 0xa7, 0x15, 0x8d, 0x7a, 0x4a, 0x96, 0xe6, 0x3a, 0xeb, 0x7d, 0x13, - 0xce, 0x28, 0x99, 0x06, 0x4c, 0xac, 0x65, 0x16, 0x40, 0x27, 0x52, 0x09, 0x9c, 0x25, 0x95, 0x75, 0x34, 0x93, 0x47, - 0x0b, 0xbd, 0x37, 0xf1, 0xf4, 0x45, 0x49, 0x7a, 0x05, 0xfe, 0xd8, 0x52, 0x63, 0x51, 0xa6, 0x6d, 0x5e, 0x04, 0xaa, - 0x66, 0x2d, 0x8f, 0x83, 0x5c, 0x7a, 0xbd, 0xac, 0x7a, 0xe5, 0x69, 0x2d, 0xd5, 0x05, 0xda, 0x4e, 0xc8, 0x31, 0x6a, - 0x51, 0x5e, 0x41, 0x1a, 0x8a, 0xf6, 0x40, 0xe9, 0x6b, 0x98, 0xd0, 0x03, 0x7e, 0xa9, 0x06, 0x65, 0x34, 0x78, 0x67, - 0xcd, 0x16, 0x17, 0x93, 0x23, 0x67, 0xcd, 0x00, 0x02, 0x6e, 0xd7, 0xdb, 0x52, 0x13, 0x21, 0x15, 0x6e, 0x30, 0x4c, - 0x8b, 0x44, 0xfd, 0x44, 0x73, 0x58, 0xbb, 0x42, 0x52, 0x87, 0x58, 0x87, 0x16, 0x26, 0xa0, 0x35, 0xe3, 0x62, 0x43, - 0x8b, 0xb2, 0x13, 0x39, 0xb0, 0x36, 0x8b, 0x24, 0xe3, 0xb0, 0x47, 0x33, 0x6d, 0x06, 0x72, 0x2d, 0xc1, 0x65, 0x89, - 0xe8, 0x2d, 0x8a, 0xee, 0x9e, 0xc8, 0xb0, 0xb9, 0xc9, 0x4a, 0xa6, 0xcc, 0xf4, 0x68, 0x08, 0xb4, 0x6b, 0x0f, 0x06, - 0xdb, 0xa1, 0x82, 0xbf, 0x84, 0x77, 0x49, 0xd2, 0xfd, 0x3e, 0x7b, 0xdc, 0x81, 0x0f, 0xe1, 0xd4, 0x69, 0xbf, 0x09, - 0xb0, 0xce, 0x81, 0x53, 0xac, 0x13, 0x63, 0x9c, 0x71, 0x54, 0xef, 0x66, 0xb4, 0xb1, 0x9f, 0x10, 0x43, 0xa0, 0x70, - 0xf8, 0xb6, 0x47, 0x2b, 0xaf, 0xda, 0xb1, 0x36, 0xd3, 0x4b, 0xda, 0x91, 0x8f, 0xc8, 0x11, 0x4c, 0x82, 0x48, 0x5a, - 0x26, 0x10, 0x9a, 0x31, 0x78, 0x0b, 0x57, 0xb0, 0x36, 0x67, 0x40, 0x4b, 0x5d, 0x2f, 0x14, 0x5a, 0xe0, 0xe9, 0x19, - 0x03, 0x93, 0xc2, 0xbc, 0x83, 0x4b, 0xda, 0x7f, 0x34, 0xc2, 0xac, 0xa1, 0x5a, 0xad, 0xed, 0x36, 0x2d, 0x1f, 0x12, - 0x05, 0xc2, 0xf6, 0x53, 0xbd, 0xe9, 0x7e, 0xe4, 0x67, 0xd7, 0x02, 0xd4, 0x55, 0x6c, 0xbb, 0xc6, 0x8b, 0x7a, 0xef, - 0x6d, 0x6b, 0xf4, 0xb1, 0xbf, 0xd2, 0xf0, 0x2d, 0xc4, 0xb0, 0x2c, 0x99, 0x30, 0x5d, 0x99, 0x0f, 0x7e, 0xce, 0x14, - 0xf7, 0x79, 0x1a, 0x93, 0xee, 0x0e, 0x25, 0x26, 0xf1, 0x75, 0x67, 0x77, 0xd8, 0xb6, 0x8c, 0xe8, 0x65, 0xfd, 0x56, - 0xaf, 0xb0, 0xd3, 0xe7, 0xdf, 0x41, 0x4c, 0xbd, 0xa2, 0x64, 0x3c, 0x4c, 0xb4, 0xc5, 0x43, 0x50, 0x18, 0xbf, 0xca, - 0x9c, 0x0c, 0x3e, 0xb9, 0xb7, 0x2d, 0x24, 0xc2, 0x6f, 0xe3, 0x55, 0x9c, 0xcc, 0x5a, 0x34, 0x9c, 0x76, 0x3d, 0x29, - 0x0e, 0x8c, 0x84, 0xd6, 0xcc, 0xb7, 0x49, 0x5a, 0x73, 0x29, 0x0c, 0xbf, 0x58, 0x88, 0x8d, 0x66, 0xe3, 0x28, 0x5a, - 0x0a, 0xa0, 0xa5, 0x3d, 0x72, 0xc9, 0x62, 0xe0, 0x61, 0xc1, 0x43, 0xf9, 0xd2, 0x12, 0x96, 0x3d, 0x7f, 0x9d, 0x4e, - 0xe4, 0x9b, 0x9b, 0x9c, 0x6e, 0xb7, 0x73, 0x75, 0xf9, 0xfc, 0x4b, 0x1a, 0x51, 0x56, 0xbf, 0xe8, 0x91, 0x44, 0x35, - 0xd6, 0xc7, 0xd6, 0xf3, 0x2f, 0xb9, 0x57, 0x27, 0x92, 0xd3, 0xce, 0x76, 0xc0, 0x70, 0x4d, 0x01, 0x5b, 0xa6, 0xed, - 0x61, 0x53, 0xf6, 0xf7, 0x5b, 0x17, 0x07, 0x75, 0x41, 0xe2, 0x13, 0xe6, 0x14, 0x49, 0x8a, 0xc7, 0x06, 0x1d, 0x08, - 0xb5, 0x0c, 0xa8, 0x47, 0xb0, 0x2f, 0x27, 0x76, 0xe4, 0x9b, 0xa7, 0xd1, 0x2f, 0xca, 0x74, 0xe8, 0x90, 0xa6, 0x43, - 0x1e, 0x02, 0x1b, 0xb7, 0xb9, 0xcb, 0x81, 0x22, 0x71, 0xa0, 0x22, 0x66, 0xda, 0x2f, 0x52, 0x7b, 0x39, 0x2f, 0xc2, - 0x9c, 0xa3, 0xea, 0xca, 0xe9, 0x53, 0x62, 0xdf, 0x85, 0x18, 0x7d, 0x88, 0x5b, 0x79, 0x67, 0x87, 0xbd, 0x91, 0x7e, - 0x88, 0x73, 0xf3, 0x25, 0x0e, 0x8c, 0xa8, 0xd2, 0x1c, 0xcd, 0x42, 0xa4, 0x14, 0xb9, 0xa6, 0x95, 0x7d, 0x47, 0x91, - 0xe9, 0x7a, 0x16, 0x7d, 0x79, 0x96, 0xc8, 0xec, 0x89, 0x30, 0x99, 0x43, 0xbd, 0x83, 0x97, 0x94, 0x68, 0xd6, 0xb6, - 0x5b, 0x07, 0x04, 0x76, 0x02, 0xe6, 0x69, 0x89, 0xbc, 0x4e, 0xc9, 0xc9, 0x7f, 0x7c, 0xfb, 0x2f, 0x2a, 0x79, 0x04, - 0x0f, 0x35, 0x75, 0x61, 0x19, 0x2d, 0x44, 0x1c, 0xc7, 0xf9, 0xdd, 0xba, 0x4e, 0x40, 0x8c, 0xf5, 0xe7, 0x67, 0x6b, - 0xcc, 0xd6, 0x41, 0xad, 0xa4, 0xa1, 0x48, 0xcc, 0xcd, 0x8e, 0x99, 0x95, 0xc9, 0x95, 0x71, 0xc5, 0x6e, 0x83, 0x7e, - 0x12, 0x59, 0x28, 0xd1, 0x8c, 0xe2, 0xe1, 0x14, 0x8b, 0xa4, 0xa4, 0x15, 0x16, 0xb5, 0xe4, 0x33, 0x43, 0x39, 0x4c, - 0x96, 0xa5, 0x6d, 0x67, 0x2e, 0x85, 0x64, 0x2d, 0x4b, 0x80, 0xec, 0x62, 0x89, 0x9a, 0xf3, 0x8a, 0x5c, 0x86, 0x15, - 0x91, 0x13, 0xc0, 0x38, 0x30, 0x85, 0x9f, 0xfc, 0x49, 0x68, 0x7f, 0x27, 0x0f, 0x3e, 0x85, 0xf0, 0x32, 0x4e, 0xd0, - 0x83, 0x71, 0x2b, 0x98, 0xc1, 0xc1, 0x10, 0xbd, 0x50, 0xc2, 0xba, 0xdc, 0x89, 0x17, 0x24, 0xcb, 0x52, 0x37, 0x40, - 0x68, 0xd6, 0xcd, 0x5a, 0xdd, 0xb7, 0xb0, 0x2a, 0x59, 0x42, 0x68, 0xc4, 0x4a, 0x2b, 0xb6, 0x62, 0x9b, 0x82, 0x8e, - 0x28, 0xc9, 0x09, 0x60, 0x66, 0x00, 0xce, 0x4e, 0x22, 0x2a, 0x35, 0xb0, 0x8e, 0x61, 0xc5, 0x62, 0xa6, 0x31, 0x29, - 0x80, 0xd5, 0xae, 0xf1, 0x51, 0x36, 0x4d, 0x17, 0x28, 0x54, 0x5f, 0x3b, 0x27, 0xe8, 0xa3, 0x4b, 0x2b, 0xf5, 0xd8, - 0x27, 0x60, 0xff, 0xe3, 0x0e, 0xea, 0x60, 0xd1, 0xa8, 0xfb, 0xd6, 0xbf, 0xc4, 0x90, 0xe7, 0x35, 0x62, 0xdc, 0xdc, - 0x1f, 0x38, 0xd5, 0x01, 0x9b, 0x64, 0x35, 0x1b, 0x49, 0x9c, 0x04, 0x3d, 0x87, 0xea, 0x4d, 0x28, 0xc1, 0x50, 0x5d, - 0xba, 0xca, 0x9e, 0x47, 0x46, 0xbc, 0x35, 0x96, 0x95, 0x2c, 0xf9, 0x19, 0xd0, 0x05, 0xe5, 0x29, 0x21, 0x38, 0xdb, - 0xce, 0x4a, 0xa2, 0x30, 0xd6, 0xa2, 0x38, 0xc6, 0x09, 0xbf, 0x23, 0x59, 0x19, 0x97, 0x4c, 0x51, 0x98, 0xf2, 0x39, - 0x38, 0x57, 0xe6, 0xc3, 0xdf, 0x9e, 0xfc, 0xf2, 0x9c, 0xae, 0x2e, 0x45, 0xec, 0xf3, 0xe3, 0x9c, 0x5e, 0x7f, 0x9b, - 0xfe, 0x25, 0xf3, 0x59, 0xf8, 0x27, 0xbc, 0xb3, 0x84, 0x9c, 0x77, 0x3f, 0x3e, 0x15, 0x2d, 0x0e, 0x8a, 0x85, 0xae, - 0x62, 0x8b, 0x5a, 0x70, 0xfe, 0xfc, 0xca, 0x66, 0xaa, 0x3c, 0x26, 0x68, 0xa6, 0x92, 0xb2, 0xfa, 0x4d, 0x91, 0x02, - 0x69, 0x1b, 0x95, 0x84, 0x8d, 0xff, 0x31, 0x05, 0xc5, 0xff, 0x47, 0x19, 0x0a, 0x0d, 0x59, 0xfb, 0xeb, 0x2d, 0x93, - 0xfc, 0x0a, 0x9e, 0xff, 0x31, 0x29, 0x50, 0xab, 0x9f, 0x08, 0x50, 0x49, 0x5b, 0x49, 0xa5, 0x0f, 0x0e, 0x3c, 0xd6, - 0xd1, 0xe4, 0x8c, 0x69, 0x18, 0xcf, 0x3c, 0x61, 0x3f, 0x03, 0x86, 0xb6, 0x59, 0x97, 0xbc, 0xdb, 0x36, 0xf1, 0x1f, - 0x28, 0xbc, 0x29, 0x53, 0x1b, 0x8d, 0x41, 0x72, 0xaa, 0x00, 0x69, 0x8e, 0xb3, 0x55, 0xe8, 0x8a, 0x36, 0x9c, 0x73, - 0xb3, 0xa5, 0x05, 0x67, 0xc3, 0xd8, 0x6a, 0xf8, 0xf2, 0x17, 0xc4, 0x56, 0xd8, 0x35, 0xa9, 0x83, 0xaa, 0xac, 0x79, - 0x71, 0x13, 0xfe, 0x09, 0xdb, 0x4b, 0x0c, 0x66, 0xf2, 0x92, 0xe6, 0x93, 0xe9, 0x08, 0x69, 0x9e, 0x21, 0x67, 0x36, - 0xff, 0xa3, 0x98, 0xc9, 0xf2, 0x52, 0x46, 0x33, 0x5f, 0x26, 0xc6, 0xbf, 0xf9, 0x33, 0x09, 0xec, 0x57, 0xce, 0x87, - 0x51, 0x64, 0x62, 0x79, 0x6c, 0x1b, 0x2f, 0xc8, 0x7d, 0x0c, 0xdd, 0x68, 0xb1, 0xca, 0xb2, 0x8c, 0x7d, 0xa5, 0xcc, - 0xd2, 0x18, 0x83, 0xc3, 0xd3, 0xf5, 0x88, 0x2a, 0x74, 0xd6, 0x87, 0x3c, 0x97, 0xfe, 0x65, 0x95, 0x0a, 0xd3, 0x87, - 0x32, 0x53, 0x5a, 0x6f, 0x81, 0xd8, 0xeb, 0x89, 0xe2, 0xc3, 0x57, 0x12, 0x6d, 0x72, 0x24, 0xe7, 0x83, 0x53, 0x58, - 0x4d, 0xf2, 0xda, 0x23, 0x13, 0xf1, 0x0c, 0x3f, 0xd9, 0xf6, 0xf3, 0x5c, 0x49, 0xcf, 0x2f, 0x3e, 0xc3, 0x6e, 0x97, - 0xc6, 0xde, 0x4b, 0x7e, 0x27, 0x3f, 0x47, 0x1f, 0x06, 0x77, 0xe4, 0xa4, 0xa4, 0xb6, 0xbf, 0xf4, 0x39, 0xae, 0x03, - 0x65, 0xf7, 0x3f, 0xa8, 0xbe, 0x86, 0x2c, 0x2a, 0x1e, 0x4d, 0xd2, 0x15, 0xe6, 0x60, 0xa9, 0x1f, 0x66, 0x2e, 0xfc, - 0x45, 0x9a, 0xe0, 0x2c, 0xba, 0xd1, 0xcb, 0x83, 0x69, 0x3d, 0xf9, 0x47, 0x64, 0xe9, 0x4f, 0xb3, 0x6c, 0x72, 0x38, - 0x0d, 0x17, 0xfc, 0x48, 0x46, 0x3f, 0xde, 0xab, 0xdb, 0x93, 0x7a, 0xad, 0x97, 0x7b, 0x08, 0x98, 0x7e, 0xa4, 0x21, - 0x92, 0x37, 0xcb, 0x54, 0x61, 0x40, 0xf2, 0x06, 0x17, 0xb4, 0x06, 0x5d, 0x6a, 0x9a, 0xa5, 0x55, 0xe0, 0x8c, 0xee, - 0x09, 0x3a, 0xa8, 0xe0, 0x68, 0xb9, 0xf2, 0xf5, 0x59, 0xc4, 0xe2, 0xa4, 0x62, 0xbb, 0x2d, 0x8a, 0x68, 0xcf, 0xe0, - 0x38, 0x5a, 0x44, 0x45, 0x66, 0xf4, 0xbb, 0xd4, 0x56, 0x28, 0xfb, 0x82, 0x15, 0xdc, 0xd1, 0x17, 0xb2, 0x52, 0xae, - 0xa5, 0x21, 0xdf, 0x4a, 0xc9, 0x16, 0x1a, 0x50, 0x29, 0xc5, 0x96, 0xaa, 0x71, 0x19, 0x07, 0x57, 0xc6, 0xe6, 0x58, - 0xc2, 0x92, 0x56, 0xc5, 0xab, 0xc8, 0x90, 0x8e, 0xaf, 0x13, 0x41, 0xca, 0x65, 0x19, 0x38, 0x3c, 0x9c, 0xa3, 0x0c, - 0x79, 0xb2, 0x0d, 0x25, 0x79, 0x26, 0x60, 0x0e, 0x66, 0x5c, 0xab, 0x27, 0xd5, 0xaa, 0x01, 0x8d, 0x14, 0xd5, 0x55, - 0x4c, 0x67, 0xab, 0x03, 0xea, 0xf8, 0x15, 0x81, 0x59, 0x58, 0xc6, 0xf3, 0x28, 0xc4, 0x5d, 0x29, 0xc3, 0x2e, 0xdc, - 0x4e, 0x12, 0xac, 0xc7, 0xc9, 0x70, 0xb8, 0xa3, 0x8d, 0x9d, 0x8b, 0x5e, 0xe3, 0x47, 0x21, 0x5c, 0x4a, 0xf7, 0x18, - 0x19, 0x81, 0xc9, 0xc5, 0xce, 0xa5, 0xf3, 0x49, 0x13, 0xee, 0x64, 0x41, 0x00, 0x44, 0x1e, 0xf6, 0x7d, 0xb0, 0xb8, - 0x3c, 0xea, 0x2c, 0x60, 0x62, 0x9e, 0x2b, 0x3b, 0x2a, 0x6f, 0xe0, 0xab, 0x75, 0x28, 0x2b, 0x7b, 0x47, 0x5f, 0x26, - 0x31, 0x56, 0xda, 0x8c, 0xdf, 0x96, 0xe5, 0x51, 0x7a, 0x63, 0x59, 0x4d, 0x5b, 0x54, 0x0f, 0x1e, 0xdd, 0xe1, 0xda, - 0x11, 0x63, 0x63, 0x99, 0x75, 0x62, 0x11, 0x98, 0xff, 0x3e, 0xb3, 0x08, 0x1b, 0x55, 0x2d, 0xdf, 0x04, 0xd2, 0x11, - 0xa3, 0x59, 0xd4, 0xf0, 0x80, 0x4f, 0x47, 0xcb, 0x18, 0x16, 0x33, 0x82, 0x59, 0xf6, 0xa0, 0xe5, 0x6a, 0x08, 0xd2, - 0x8c, 0x47, 0x89, 0x20, 0xdd, 0x88, 0xa1, 0x19, 0xc9, 0x19, 0x01, 0x9b, 0xa4, 0x10, 0x83, 0x67, 0xc0, 0xfe, 0xd8, - 0x39, 0x22, 0x15, 0x1c, 0xd1, 0x03, 0xc2, 0xaa, 0x8a, 0xcb, 0x0f, 0x0b, 0x1b, 0x06, 0x62, 0x48, 0xc5, 0x8b, 0x59, - 0xf9, 0xb4, 0x00, 0x18, 0x59, 0xa3, 0x8a, 0x87, 0x64, 0x88, 0x8c, 0xbc, 0x69, 0x91, 0x51, 0x87, 0x64, 0x0c, 0xbf, - 0x11, 0x31, 0x90, 0x94, 0x9c, 0x41, 0x1e, 0x73, 0xb2, 0x55, 0x2e, 0x5f, 0xe6, 0x2e, 0xfd, 0xd3, 0xfe, 0x54, 0x8e, - 0xf7, 0xa9, 0xd4, 0xd0, 0xa6, 0x97, 0x71, 0x39, 0x17, 0x15, 0x07, 0xd7, 0xcb, 0x76, 0xd3, 0xd3, 0x8e, 0xe6, 0x0b, - 0xd7, 0xe6, 0x66, 0xbb, 0x30, 0xde, 0x1d, 0xab, 0xec, 0xc3, 0x27, 0x94, 0x71, 0x41, 0x33, 0x3c, 0xec, 0xd4, 0x6d, - 0x23, 0x63, 0x18, 0x41, 0xff, 0x36, 0xbe, 0x9e, 0xc8, 0x2e, 0x5d, 0xe6, 0x82, 0xe4, 0x30, 0x6f, 0xf0, 0x6d, 0x61, - 0xfc, 0x25, 0xd9, 0x8d, 0xd6, 0xc9, 0xba, 0xa7, 0x35, 0xba, 0x7b, 0x69, 0xc3, 0x17, 0x1c, 0xa0, 0xf3, 0x4b, 0x1c, - 0xea, 0xd1, 0x14, 0x58, 0xee, 0xf3, 0xa6, 0x3e, 0x41, 0xa6, 0xf1, 0xb0, 0xb6, 0x03, 0x72, 0x8d, 0xe7, 0xba, 0x8d, - 0x1a, 0xf5, 0x1d, 0x5b, 0xa6, 0xb7, 0xc4, 0x56, 0xde, 0xdb, 0x6c, 0x83, 0x39, 0x50, 0xf5, 0xdf, 0x3e, 0x44, 0x22, - 0x18, 0x49, 0xd3, 0x3e, 0x47, 0xeb, 0x77, 0x2e, 0xcf, 0xfc, 0xeb, 0xcc, 0xd1, 0x86, 0x95, 0x61, 0x46, 0x83, 0x19, - 0x5f, 0xe9, 0xce, 0xd0, 0xcc, 0x6b, 0xe6, 0x1e, 0xb8, 0xdd, 0x4b, 0xef, 0xc6, 0x9a, 0x35, 0xfa, 0x61, 0xba, 0x53, - 0x92, 0x59, 0xe0, 0x74, 0xfc, 0x9b, 0xa0, 0xa7, 0x82, 0xf4, 0xa3, 0x3a, 0xb0, 0xf8, 0x8e, 0x93, 0x98, 0x90, 0x0c, - 0x39, 0x58, 0x90, 0xab, 0xe6, 0xbd, 0xa7, 0xdb, 0x5e, 0x9b, 0xb2, 0x46, 0x5c, 0x3a, 0x5d, 0x7d, 0x79, 0xbd, 0xf0, - 0x02, 0xed, 0xf1, 0xde, 0x8f, 0x36, 0xde, 0xd0, 0xc9, 0xe3, 0x0d, 0x54, 0x44, 0xfc, 0x86, 0xdc, 0xd0, 0x18, 0x5f, - 0x85, 0x29, 0x03, 0xc7, 0x7c, 0xef, 0xae, 0xbd, 0x69, 0xee, 0xf1, 0x8b, 0xb9, 0x56, 0x67, 0x4e, 0xb4, 0x57, 0x66, - 0xbd, 0x32, 0x71, 0xb1, 0xa0, 0x24, 0x1f, 0x1e, 0x10, 0x5c, 0xc7, 0x3f, 0xad, 0x56, 0xe1, 0xae, 0xc7, 0x0f, 0x72, - 0xb0, 0x14, 0x03, 0xd3, 0x0d, 0x5c, 0x07, 0x62, 0x1d, 0xc6, 0x16, 0x69, 0x60, 0xa9, 0x1f, 0xca, 0x88, 0x51, 0x30, - 0x7e, 0x7e, 0xbc, 0x8c, 0x7a, 0xc7, 0x7f, 0x58, 0x02, 0x58, 0xb7, 0x11, 0x8e, 0x40, 0x33, 0x2b, 0x4e, 0x39, 0x1f, - 0x17, 0xfa, 0x08, 0xae, 0x6c, 0xca, 0xbe, 0x61, 0xe0, 0x90, 0x15, 0x98, 0xf6, 0x47, 0x43, 0xe5, 0xf7, 0x4f, 0xe4, - 0xc7, 0xb5, 0xbb, 0xdf, 0x6b, 0xd3, 0xc6, 0x0c, 0x47, 0x8f, 0x90, 0x89, 0x0e, 0xe6, 0x40, 0x87, 0x47, 0xc3, 0x62, - 0xca, 0x8e, 0x9b, 0xda, 0xb3, 0x1a, 0x6f, 0xc9, 0xf1, 0x18, 0x7e, 0xad, 0xa2, 0xd9, 0x78, 0x90, 0x6e, 0xab, 0x5c, - 0xcf, 0x76, 0x94, 0x6f, 0x7e, 0xe8, 0x34, 0xd9, 0xc2, 0x37, 0xfa, 0xd7, 0x39, 0xb4, 0x68, 0xbe, 0x46, 0xb4, 0xc8, - 0x1a, 0xea, 0x03, 0xf0, 0xe3, 0x42, 0x63, 0xcd, 0x63, 0x28, 0x08, 0x9b, 0x9b, 0xd6, 0xb5, 0x0d, 0x0d, 0x9a, 0x39, - 0x79, 0x27, 0x48, 0x51, 0x00, 0x89, 0x3b, 0x56, 0xa1, 0xa7, 0x73, 0x10, 0x18, 0x3c, 0xf6, 0x3e, 0xb5, 0x6e, 0x4c, - 0x51, 0x97, 0x7b, 0x4c, 0x34, 0x76, 0xb3, 0x6f, 0x8b, 0xf6, 0xe9, 0x57, 0xfa, 0x8f, 0xc8, 0x85, 0x08, 0x0c, 0x9e, - 0x1f, 0x00, 0xfb, 0x38, 0xb0, 0x15, 0xcd, 0x26, 0x95, 0x37, 0x7c, 0x6e, 0x5f, 0x7f, 0xee, 0xcb, 0xa7, 0xd9, 0x5c, - 0x20, 0xd1, 0xf7, 0xe7, 0xa6, 0x4e, 0xa6, 0x2a, 0xd7, 0x72, 0x07, 0xbb, 0x38, 0x9a, 0x86, 0x18, 0x2d, 0x00, 0x1a, - 0x65, 0x20, 0xf8, 0x09, 0x3e, 0x52, 0x67, 0xfc, 0xf3, 0x79, 0x97, 0xe7, 0x74, 0xff, 0xe1, 0x2d, 0x99, 0xde, 0xd2, - 0x1c, 0xf0, 0x6d, 0xc8, 0xff, 0xed, 0xbf, 0xd1, 0xad, 0x63, 0xac, 0x08, 0xcc, 0x0e, 0xae, 0xcd, 0xa2, 0x5c, 0x7a, - 0x5b, 0x9b, 0xb8, 0xf2, 0x71, 0xf6, 0x03, 0xdc, 0xe6, 0xbe, 0x11, 0x18, 0x4d, 0xe1, 0x63, 0x16, 0x93, 0xb6, 0xca, - 0x75, 0xd3, 0x13, 0x66, 0xdb, 0xe8, 0x12, 0xa9, 0x21, 0xb8, 0xde, 0xc7, 0xb2, 0xd8, 0x78, 0x32, 0x92, 0xd5, 0xf6, - 0xc5, 0x53, 0x01, 0x2e, 0x34, 0x96, 0x7f, 0xa2, 0xce, 0xdb, 0x3d, 0x6a, 0x93, 0xd3, 0xfe, 0x87, 0xd6, 0xee, 0xb9, - 0x54, 0x74, 0x6d, 0x8f, 0x4d, 0x9f, 0x5a, 0x0b, 0x86, 0x60, 0xdf, 0x92, 0x15, 0x7b, 0x01, 0xd0, 0x0e, 0xf0, 0x42, - 0xb5, 0x89, 0x6e, 0xab, 0xfe, 0xb1, 0x07, 0xa4, 0x31, 0xbe, 0xc7, 0x24, 0x55, 0x6e, 0x64, 0x42, 0xcd, 0x22, 0x41, - 0xd1, 0x71, 0x7c, 0x7c, 0x47, 0x5b, 0xad, 0x87, 0x17, 0x62, 0x55, 0x0a, 0x63, 0xcb, 0xdc, 0x9b, 0x32, 0xc8, 0x69, - 0xaa, 0x0f, 0x49, 0x0b, 0xb7, 0x0d, 0x5d, 0x0a, 0x1f, 0x8b, 0x47, 0xad, 0x76, 0x20, 0x27, 0x1b, 0x08, 0xe1, 0x88, - 0xce, 0x5f, 0x4a, 0x9d, 0x02, 0xbc, 0x0e, 0xdc, 0x15, 0xc7, 0xb0, 0x6c, 0xc7, 0xdd, 0xa8, 0xd5, 0x16, 0xfe, 0xec, - 0x00, 0xd4, 0xb0, 0xae, 0xda, 0xed, 0x1d, 0xf5, 0xba, 0x4c, 0x61, 0x94, 0x0a, 0x09, 0x08, 0x87, 0xcb, 0xd9, 0xa4, - 0x20, 0x94, 0x04, 0x8c, 0x55, 0x51, 0xfd, 0xa1, 0xcc, 0x6d, 0xb7, 0x1b, 0x35, 0xe7, 0x91, 0x78, 0x18, 0xa8, 0x58, - 0x8f, 0x69, 0x6d, 0xe6, 0xe0, 0x80, 0x42, 0xd4, 0x6c, 0x7a, 0x2c, 0x7f, 0x58, 0x8f, 0xe4, 0x52, 0xf0, 0x48, 0xc4, - 0xe2, 0x6d, 0x8f, 0xd1, 0xe4, 0x8f, 0x67, 0xc8, 0xec, 0x2d, 0x17, 0x3f, 0xcc, 0xe1, 0x76, 0x62, 0x97, 0x01, 0x4f, - 0x30, 0x31, 0x35, 0xea, 0xc9, 0x56, 0xf4, 0x14, 0x90, 0x0e, 0xb3, 0x82, 0x01, 0xc2, 0x29, 0xf5, 0xcb, 0x68, 0xcc, - 0x9b, 0xcb, 0x95, 0x5b, 0x89, 0x46, 0xb4, 0x94, 0x85, 0xb6, 0xdc, 0x96, 0x1f, 0x26, 0x94, 0xac, 0xb8, 0xa6, 0xb6, - 0x99, 0xad, 0xa2, 0x45, 0x2b, 0x08, 0x7f, 0x5c, 0xcd, 0x8c, 0xa8, 0xbf, 0x90, 0x6e, 0xd6, 0x74, 0x77, 0x06, 0x69, - 0x35, 0xa7, 0x76, 0x76, 0x8e, 0xe6, 0x82, 0x06, 0xea, 0x35, 0x82, 0x8c, 0xc5, 0xa5, 0x26, 0xe5, 0xac, 0x73, 0xa1, - 0xc6, 0x1b, 0x86, 0xaf, 0x9b, 0xa4, 0x5e, 0x94, 0x36, 0xae, 0x6e, 0x74, 0xea, 0x4b, 0xd0, 0xc1, 0xa0, 0x83, 0x84, - 0x94, 0x5a, 0x85, 0x8a, 0xec, 0xd3, 0xc5, 0xba, 0x70, 0x9a, 0x90, 0x74, 0xba, 0xe2, 0xe5, 0xa4, 0x78, 0xcf, 0x08, - 0x71, 0xf4, 0x03, 0x52, 0x26, 0x8f, 0x50, 0x93, 0xbc, 0xf6, 0x01, 0x65, 0xf2, 0x34, 0x6a, 0x71, 0xd8, 0xd0, 0x06, - 0x11, 0x0f, 0x06, 0xc7, 0xe3, 0x08, 0x52, 0xc1, 0x7a, 0x4a, 0x46, 0x97, 0x00, 0x49, 0x2f, 0xc9, 0xd3, 0x03, 0x0b, - 0xa6, 0xe6, 0x4e, 0x29, 0x28, 0x9e, 0x0c, 0x30, 0xb4, 0x95, 0x46, 0x65, 0xc9, 0x0c, 0x45, 0x0f, 0x74, 0xeb, 0xf7, - 0x14, 0x0a, 0x18, 0x23, 0xce, 0x1e, 0xfb, 0xdc, 0x04, 0x10, 0x14, 0x87, 0x35, 0x08, 0xdd, 0x67, 0x04, 0x1b, 0x79, - 0x46, 0xc1, 0x22, 0xcf, 0x07, 0xe4, 0xa8, 0xec, 0x65, 0x35, 0xf7, 0x5f, 0xce, 0x90, 0x0d, 0x0c, 0x1e, 0xd5, 0x93, - 0x4e, 0xae, 0xf5, 0xeb, 0x70, 0x82, 0x9c, 0xd1, 0xa7, 0xac, 0x9e, 0xb4, 0x73, 0x53, 0x4f, 0xd1, 0xac, 0x50, 0x7f, - 0xe6, 0x1e, 0x5e, 0xe1, 0x5b, 0x39, 0x33, 0xca, 0x22, 0x15, 0xf1, 0xc2, 0x0f, 0x60, 0xe3, 0xe7, 0x59, 0xc7, 0xe0, - 0xf0, 0xc4, 0xd9, 0xea, 0x84, 0x38, 0xc4, 0x35, 0x39, 0xf8, 0xb8, 0x45, 0x8c, 0x1a, 0x34, 0x26, 0xb7, 0xa8, 0xd6, - 0x94, 0x78, 0x0b, 0xf5, 0xa9, 0xc1, 0x50, 0x1b, 0x27, 0x5d, 0x59, 0x09, 0x26, 0x34, 0xbc, 0xe4, 0x53, 0x25, 0xeb, - 0x28, 0x56, 0xf8, 0xe5, 0x0a, 0x30, 0x1b, 0x98, 0xe6, 0xae, 0x13, 0x0c, 0x56, 0x9a, 0x53, 0x33, 0xf2, 0xea, 0xdc, - 0x21, 0x94, 0xba, 0xd1, 0x0b, 0x98, 0x00, 0x86, 0x43, 0x46, 0x1b, 0xf4, 0xf2, 0xc2, 0x97, 0x0b, 0x52, 0xb5, 0x23, - 0x87, 0x0c, 0x16, 0x39, 0x91, 0x06, 0x87, 0xf8, 0x9f, 0x09, 0x41, 0xd2, 0x66, 0x07, 0xe2, 0xcd, 0xb1, 0x9b, 0x3a, - 0x56, 0x3d, 0x07, 0xf9, 0xdd, 0x0d, 0xf6, 0x5a, 0xf1, 0xda, 0x34, 0xa9, 0xa1, 0x57, 0xa3, 0x71, 0x28, 0x48, 0xcb, - 0x8b, 0xd9, 0x95, 0x27, 0x4d, 0xa2, 0xdb, 0xd2, 0x55, 0x83, 0x1e, 0xc2, 0x3b, 0xf3, 0x90, 0xdf, 0xf0, 0xbe, 0x9e, - 0xcc, 0x05, 0x45, 0x87, 0x70, 0x0d, 0xb9, 0x89, 0x44, 0xfd, 0x44, 0x57, 0x6c, 0x41, 0x59, 0xec, 0x67, 0xa8, 0x03, - 0xbc, 0xb4, 0x38, 0x41, 0x61, 0x8f, 0xd4, 0xb8, 0xe0, 0xb6, 0x27, 0x0c, 0x53, 0xeb, 0xb2, 0x70, 0xd9, 0xe9, 0xb6, - 0x68, 0x72, 0x2d, 0x50, 0x0c, 0x02, 0xcd, 0x79, 0xfe, 0x7a, 0x7b, 0xea, 0x1a, 0xcf, 0xe0, 0x74, 0xec, 0x60, 0x74, - 0x32, 0xe3, 0x2a, 0x61, 0x83, 0xa8, 0xc3, 0x5d, 0xba, 0x69, 0x20, 0x97, 0x3d, 0xa8, 0x6e, 0x9e, 0xf7, 0xa7, 0xb3, - 0x6b, 0xe3, 0xad, 0x06, 0xd0, 0x1e, 0x00, 0xca, 0x8b, 0x5d, 0xfa, 0xc0, 0x89, 0x9b, 0x76, 0xf7, 0x25, 0xd6, 0x1b, - 0xa8, 0x91, 0x88, 0x20, 0x0a, 0x48, 0x98, 0xfa, 0xe7, 0x4e, 0xd9, 0xf4, 0xf1, 0x1d, 0xaf, 0x3a, 0x51, 0xa8, 0x90, - 0x34, 0x70, 0x8d, 0xa3, 0x87, 0x43, 0x1b, 0x73, 0xc0, 0x1a, 0xe3, 0x44, 0xb8, 0xdf, 0x62, 0xdf, 0xb5, 0x56, 0x1c, - 0xd7, 0x65, 0xb8, 0xe8, 0x3b, 0x45, 0x35, 0x07, 0xc3, 0xab, 0xc3, 0xe3, 0x3c, 0xf8, 0x15, 0xaa, 0xa8, 0xe4, 0xdb, - 0x2e, 0x47, 0x1e, 0x57, 0xa0, 0xcb, 0xf9, 0xb6, 0xbd, 0xbf, 0xc1, 0x30, 0x80, 0x28, 0xf0, 0x41, 0x15, 0xbb, 0x54, - 0x39, 0xb1, 0x3e, 0x70, 0xd6, 0x08, 0x32, 0xaf, 0x22, 0xc4, 0x2b, 0x2e, 0xf9, 0x7d, 0x07, 0x80, 0x5d, 0xb9, 0xca, - 0xb2, 0xae, 0x2b, 0xff, 0x6f, 0x86, 0x11, 0x42, 0xc6, 0xd0, 0xb1, 0x6f, 0xb7, 0xe4, 0x34, 0x06, 0xf5, 0x74, 0xdc, - 0xec, 0x4d, 0x3c, 0x37, 0x0e, 0x5c, 0x00, 0x14, 0xb1, 0x7c, 0xcd, 0x13, 0xde, 0x45, 0x9c, 0x05, 0x88, 0x0d, 0x92, - 0xcf, 0x60, 0xca, 0x71, 0xbf, 0xbe, 0x96, 0x2c, 0xab, 0x38, 0x73, 0x50, 0x1f, 0x9c, 0xfb, 0xa7, 0xe6, 0xf0, 0xb2, - 0x4d, 0x31, 0x0e, 0xc7, 0x8f, 0x3f, 0xd0, 0x55, 0x0c, 0xac, 0x54, 0x7b, 0x20, 0x2d, 0x98, 0xf7, 0x5a, 0xa1, 0x61, - 0xa1, 0xf5, 0xa1, 0x4f, 0x4d, 0xe6, 0x7d, 0xfc, 0x78, 0x55, 0x3d, 0xd0, 0x01, 0x3a, 0xb9, 0x43, 0x69, 0x7f, 0x68, - 0xa9, 0x6f, 0x56, 0xbf, 0x44, 0x05, 0x76, 0x99, 0x83, 0xdd, 0x1e, 0xc7, 0x39, 0x9b, 0x15, 0xd9, 0xd1, 0x2f, 0x44, - 0x97, 0x09, 0x3b, 0x7c, 0x9c, 0x9a, 0xe6, 0x0f, 0xb0, 0x2b, 0x5f, 0x6e, 0xfe, 0x44, 0x09, 0x4c, 0xd4, 0xd9, 0x60, - 0x1f, 0x01, 0xd0, 0x7d, 0xf0, 0x79, 0x82, 0xe4, 0xe3, 0xfa, 0x71, 0xf7, 0x5f, 0xfb, 0x03, 0xd4, 0x79, 0x57, 0x62, - 0xd9, 0x40, 0x9c, 0xb8, 0x42, 0x02, 0xda, 0x14, 0x42, 0x7f, 0x2a, 0xe5, 0x65, 0x1c, 0x8a, 0x67, 0x4d, 0x07, 0x95, - 0xbb, 0xb9, 0x4a, 0x26, 0xa0, 0xc1, 0x9b, 0x64, 0x96, 0xfd, 0x98, 0x0e, 0x7b, 0xa9, 0x69, 0xea, 0x27, 0x73, 0x5d, - 0x59, 0xad, 0xa6, 0x7c, 0xbb, 0x7d, 0x57, 0x7e, 0xba, 0xe9, 0x09, 0xd2, 0x78, 0xcf, 0x03, 0xb7, 0x75, 0xdf, 0xc8, - 0x1a, 0x0c, 0xf0, 0xcd, 0xc2, 0xa8, 0xca, 0xe9, 0x08, 0x85, 0xa8, 0x98, 0x07, 0x7f, 0x01, 0x62, 0x3c, 0xac, 0xc6, - 0xf1, 0x93, 0x4e, 0x27, 0xc0, 0x32, 0xfb, 0xf2, 0x66, 0x63, 0x1d, 0xb1, 0x27, 0x30, 0xbc, 0xa8, 0xcc, 0x15, 0x2f, - 0xd1, 0x31, 0x70, 0xdb, 0xbb, 0xb2, 0x4a, 0xa6, 0xcb, 0xe7, 0xbe, 0x0d, 0x0a, 0x5f, 0x1f, 0x90, 0x20, 0x05, 0x2a, - 0x05, 0xf6, 0xc1, 0xe6, 0xfb, 0x08, 0x68, 0x1e, 0xe7, 0xaa, 0x9e, 0xae, 0xdb, 0xab, 0x2d, 0xda, 0x6f, 0xe1, 0x88, - 0xad, 0xad, 0x82, 0x3d, 0xec, 0xe5, 0xbc, 0x77, 0x7a, 0xf3, 0xe0, 0x17, 0xa6, 0x61, 0x16, 0x12, 0xef, 0x36, 0xea, - 0x1b, 0xd6, 0x6b, 0xb6, 0xf4, 0x99, 0xcc, 0x9a, 0x78, 0x98, 0xac, 0xa7, 0x91, 0x87, 0x93, 0x53, 0x79, 0x8e, 0xcd, - 0x63, 0x61, 0x81, 0x37, 0x74, 0xf5, 0xf4, 0x9a, 0x29, 0x3e, 0x9a, 0x8a, 0xe4, 0x25, 0x3e, 0xb9, 0x8a, 0x16, 0x80, - 0x63, 0xa2, 0x72, 0x7a, 0xed, 0x02, 0x27, 0xd8, 0xeb, 0x45, 0x09, 0x0d, 0x8e, 0x91, 0x63, 0x5b, 0x82, 0xa7, 0xa3, - 0x33, 0x31, 0x6b, 0x5c, 0x40, 0xfa, 0x9a, 0xac, 0xbf, 0xae, 0x42, 0x9a, 0x91, 0x49, 0x06, 0x1f, 0x3d, 0x4b, 0x53, - 0x37, 0x2f, 0x37, 0x80, 0xc0, 0x51, 0xf1, 0xbe, 0x0b, 0x64, 0x79, 0xc3, 0x90, 0x3c, 0xc9, 0xc1, 0x4a, 0xb7, 0x27, - 0xb8, 0x09, 0xc1, 0xff, 0xf9, 0xdd, 0xc2, 0x4a, 0xa6, 0x22, 0x97, 0x63, 0x14, 0xa2, 0xd8, 0x3d, 0xe7, 0x06, 0x73, - 0x53, 0xc9, 0x55, 0x02, 0xb5, 0xfc, 0x83, 0xed, 0xcf, 0x6a, 0x48, 0x72, 0xe6, 0x0b, 0xc8, 0x8b, 0xd9, 0x45, 0x28, - 0x70, 0x56, 0x6f, 0x51, 0xc4, 0x06, 0x82, 0x3d, 0xe6, 0x5a, 0xd3, 0xc3, 0x1c, 0x48, 0x66, 0x35, 0xc0, 0x68, 0x4b, - 0x04, 0xa9, 0x17, 0xec, 0xec, 0x52, 0xd1, 0x7d, 0x5d, 0x50, 0xa4, 0xbb, 0x2c, 0x11, 0x53, 0x69, 0x25, 0xc7, 0xe7, - 0x2d, 0xf6, 0xd7, 0x9a, 0xaa, 0xa5, 0xbe, 0xca, 0xce, 0x31, 0xa6, 0xa7, 0xe3, 0x4f, 0x1b, 0x3f, 0x12, 0x7e, 0x9f, - 0x2b, 0x66, 0x30, 0x1b, 0x86, 0xd1, 0x2e, 0x61, 0xd2, 0x50, 0x7d, 0xa6, 0x38, 0x6e, 0x2c, 0x37, 0x5e, 0x6e, 0x5f, - 0x74, 0xc5, 0x56, 0xe9, 0x9f, 0xbb, 0x05, 0xbe, 0x26, 0xdd, 0x6b, 0x32, 0x2f, 0x48, 0x6c, 0xf0, 0x44, 0xf7, 0x60, - 0x9d, 0xa8, 0xae, 0xfd, 0xcb, 0xf3, 0xd3, 0x84, 0x10, 0xb3, 0x6d, 0x2b, 0xf2, 0xca, 0x0a, 0x50, 0x0e, 0x69, 0x37, - 0x01, 0xf5, 0xa5, 0x1b, 0xce, 0x83, 0xba, 0xb1, 0x81, 0x97, 0x90, 0x5a, 0x03, 0xc5, 0x2e, 0x8c, 0x7d, 0x75, 0x3a, - 0x0a, 0x69, 0x72, 0x26, 0x7b, 0x48, 0x28, 0x26, 0x0c, 0xd0, 0x3f, 0x2d, 0x8e, 0x66, 0x54, 0xd0, 0x7a, 0x77, 0x45, - 0x75, 0x2c, 0x3b, 0xd7, 0x40, 0x94, 0x99, 0x8d, 0x66, 0xda, 0x41, 0x86, 0x37, 0x0e, 0x91, 0xef, 0x32, 0xd3, 0xd1, - 0x81, 0x1d, 0x53, 0xee, 0xa4, 0x0e, 0x1b, 0x57, 0xd9, 0x91, 0x04, 0xf6, 0xbd, 0xcc, 0x89, 0x50, 0xf8, 0x66, 0xb6, - 0x3c, 0x90, 0xaf, 0x75, 0xe5, 0x7f, 0xcd, 0xa8, 0xcf, 0x0a, 0x77, 0xb4, 0x2d, 0x57, 0x33, 0x0e, 0x63, 0xc3, 0x81, - 0xcc, 0xc7, 0x07, 0x26, 0x78, 0xe5, 0xa9, 0x2a, 0xfb, 0x4d, 0xd8, 0x65, 0x0f, 0xec, 0xd9, 0xe4, 0x28, 0x2d, 0x1d, - 0xb5, 0xff, 0xb5, 0xcb, 0xa2, 0x43, 0xd1, 0xb0, 0x68, 0x5d, 0x24, 0x88, 0x5a, 0x6d, 0xf1, 0xc3, 0x3c, 0x22, 0x41, - 0xed, 0x8b, 0xc5, 0x4b, 0x7b, 0xe0, 0xa3, 0x29, 0x06, 0xbe, 0xcf, 0x58, 0x3c, 0x89, 0xbe, 0x3f, 0xc2, 0x49, 0x19, - 0x28, 0x1d, 0x3a, 0x03, 0xd2, 0xc4, 0x2a, 0x1e, 0x93, 0x3c, 0x67, 0xb1, 0xc2, 0x5e, 0xf2, 0x3a, 0x2a, 0x83, 0x16, - 0xc9, 0x3f, 0x47, 0x7c, 0xd0, 0xe0, 0x18, 0x3c, 0x8a, 0xbc, 0xf4, 0x4b, 0x70, 0xcb, 0x7d, 0x7f, 0xc0, 0x08, 0x26, - 0x54, 0x6f, 0xd2, 0x62, 0xf4, 0x42, 0x44, 0xe6, 0x23, 0x34, 0x1e, 0xbf, 0x6f, 0x0d, 0x5e, 0x50, 0xfa, 0xd2, 0xce, - 0x40, 0x72, 0x13, 0xe8, 0xd2, 0x6e, 0x6a, 0x9c, 0x06, 0x72, 0x22, 0x53, 0xd7, 0x76, 0xdc, 0x77, 0xc3, 0x63, 0x41, - 0x5b, 0x82, 0x8c, 0xe9, 0x2e, 0x34, 0x73, 0x14, 0x18, 0xfe, 0xbd, 0xd5, 0x38, 0x02, 0x06, 0xec, 0x1a, 0xeb, 0xe1, - 0x97, 0x62, 0xdc, 0xa4, 0x4a, 0x3f, 0x5c, 0xe1, 0x9c, 0x5d, 0xd2, 0xe9, 0xcd, 0xef, 0x07, 0x4a, 0x20, 0x2e, 0xde, - 0x88, 0x55, 0xdf, 0x06, 0xf3, 0xcb, 0xa0, 0x00, 0x8c, 0xa9, 0x34, 0x64, 0xfa, 0xbf, 0x58, 0x17, 0xf4, 0x4e, 0x0c, - 0xd6, 0x0c, 0x0e, 0x0c, 0x22, 0x3e, 0xee, 0xe0, 0x1e, 0x7f, 0x1d, 0xfe, 0x37, 0x25, 0xa8, 0x2b, 0x77, 0x3f, 0x51, - 0xd6, 0x7c, 0x9f, 0x94, 0x22, 0xd3, 0x97, 0xef, 0x5e, 0xb6, 0x42, 0x1d, 0xd4, 0xd8, 0xe6, 0x16, 0x35, 0xaf, 0x2d, - 0x7e, 0x3d, 0x8d, 0xc5, 0xdc, 0xe4, 0x37, 0xbd, 0x5d, 0x75, 0xf5, 0xd4, 0xa8, 0x51, 0x4f, 0x08, 0x46, 0x6f, 0x6e, - 0x86, 0xdd, 0x1a, 0x3f, 0xcf, 0x4a, 0x40, 0x23, 0x9b, 0xbd, 0x7a, 0x03, 0x05, 0xb9, 0xae, 0xd6, 0xcf, 0x63, 0x59, - 0x65, 0x5c, 0x7c, 0x47, 0x00, 0x5e, 0x1a, 0x1f, 0x12, 0x55, 0xaa, 0x65, 0x65, 0x88, 0x9a, 0x04, 0x10, 0x1c, 0xfe, - 0xa0, 0x7b, 0x73, 0x69, 0x3f, 0xc5, 0x6d, 0x56, 0xe4, 0xb5, 0x15, 0x41, 0x07, 0x19, 0x6a, 0xba, 0x32, 0xb8, 0x81, - 0x0e, 0x0f, 0xa7, 0xe8, 0x7f, 0x15, 0x7f, 0x58, 0xb1, 0x7f, 0xd2, 0x4d, 0x09, 0xe5, 0x53, 0x33, 0x3b, 0xf1, 0x64, - 0xcf, 0x14, 0xa9, 0x59, 0x84, 0x9a, 0x55, 0x6b, 0x06, 0xcb, 0x86, 0xda, 0x7d, 0x0d, 0x09, 0x5b, 0x04, 0x29, 0xa6, - 0x60, 0xdc, 0xd8, 0x9d, 0x11, 0x70, 0xc4, 0x39, 0x83, 0x72, 0xe8, 0x14, 0x65, 0x7e, 0x33, 0x5c, 0x36, 0x4e, 0xdd, - 0xf4, 0x06, 0x05, 0x7e, 0x18, 0xf0, 0xb9, 0xbc, 0xb5, 0x20, 0xcf, 0x1e, 0x65, 0xc5, 0x74, 0x16, 0xfb, 0x56, 0x02, - 0x31, 0x51, 0xb4, 0x03, 0x5b, 0x5e, 0xf1, 0xf2, 0x74, 0x66, 0xb5, 0x4f, 0x3a, 0xd7, 0x1d, 0xc2, 0xfd, 0x21, 0x71, - 0x1d, 0x84, 0x5e, 0xa7, 0x1c, 0x36, 0x79, 0x3d, 0x29, 0x61, 0xb7, 0x28, 0xbb, 0x2e, 0x16, 0xd3, 0x19, 0x0a, 0xbd, - 0x05, 0xf6, 0xbb, 0xdf, 0x7a, 0xfe, 0xa4, 0x72, 0x8c, 0xeb, 0xc3, 0xe5, 0x24, 0x86, 0xf1, 0xb5, 0xd4, 0x10, 0x2d, - 0x5b, 0x4a, 0xf7, 0x58, 0xdb, 0xb0, 0x80, 0xad, 0xd9, 0xfb, 0x47, 0x22, 0xa5, 0x89, 0x32, 0x15, 0xa7, 0x7d, 0xa1, - 0x32, 0x6e, 0xac, 0x3b, 0xab, 0x77, 0xb5, 0x16, 0x1f, 0xad, 0xce, 0x46, 0x1b, 0xa7, 0x12, 0xec, 0xbd, 0xa1, 0xbb, - 0xe8, 0x0b, 0xa6, 0x6c, 0xa1, 0xef, 0xe0, 0xdd, 0x06, 0x6d, 0x31, 0x3e, 0x63, 0x68, 0x9a, 0xdd, 0x79, 0xe0, 0xc5, - 0x67, 0x59, 0x74, 0xb9, 0x68, 0x3e, 0xcd, 0x1c, 0x69, 0xd4, 0xfd, 0x7f, 0x79, 0x6b, 0xa5, 0x0c, 0x77, 0x79, 0x42, - 0x86, 0x9d, 0xdc, 0xaf, 0x4b, 0x56, 0x01, 0xf9, 0x18, 0x5b, 0xe9, 0x79, 0x65, 0x97, 0x44, 0xa1, 0xa3, 0x38, 0xd3, - 0x7f, 0xf8, 0xca, 0x5d, 0xed, 0x3b, 0x6d, 0xfa, 0xd1, 0x65, 0xc9, 0x5f, 0x59, 0x4e, 0x8a, 0x36, 0x4f, 0x88, 0x4c, - 0xfe, 0x4f, 0x24, 0x25, 0x47, 0x06, 0xe2, 0xd1, 0x01, 0x14, 0x30, 0x53, 0x27, 0x93, 0xd3, 0x62, 0x70, 0x02, 0x22, - 0x4b, 0x34, 0x87, 0x33, 0x80, 0x49, 0x5a, 0x80, 0x09, 0xcf, 0x6b, 0xb5, 0xef, 0x31, 0x35, 0x8f, 0xbf, 0xcc, 0xa3, - 0x19, 0x8a, 0x33, 0x87, 0x16, 0x4d, 0x40, 0x32, 0x92, 0x30, 0xac, 0xb5, 0xed, 0x9c, 0x9f, 0x6c, 0x27, 0x78, 0x42, - 0xbd, 0x3f, 0xe0, 0x96, 0x43, 0x70, 0xb9, 0x13, 0xa5, 0xa8, 0xee, 0x93, 0x2f, 0x5b, 0xbd, 0x39, 0xe4, 0x3a, 0xeb, - 0xa1, 0x1e, 0x19, 0x28, 0x6e, 0xdb, 0xd9, 0x24, 0xfd, 0xf5, 0x8a, 0x7f, 0xfc, 0x65, 0xa2, 0x8b, 0x8a, 0x66, 0x0d, - 0x1a, 0x28, 0x00, 0xb7, 0x31, 0xe7, 0x7b, 0x1d, 0xb7, 0xb6, 0x83, 0xb9, 0x0d, 0x70, 0xb7, 0x51, 0x28, 0x06, 0x73, - 0x3f, 0x4f, 0x18, 0x10, 0xcc, 0x6b, 0x4f, 0x14, 0x20, 0xd2, 0x83, 0xfb, 0xe4, 0x54, 0x72, 0x99, 0x8d, 0x20, 0x58, - 0xc3, 0x2c, 0xe8, 0x76, 0xd7, 0xac, 0xcb, 0x8c, 0x3f, 0xf9, 0x21, 0xc3, 0x35, 0xd0, 0x3f, 0x99, 0x28, 0xe9, 0xdc, - 0x90, 0x50, 0xd1, 0x83, 0x78, 0x99, 0x43, 0xe5, 0x79, 0xcf, 0x50, 0x4f, 0xaf, 0x3f, 0xfa, 0xfb, 0xd6, 0xcc, 0xa1, - 0xbc, 0x64, 0x4d, 0xfe, 0xee, 0x31, 0xaf, 0x67, 0x79, 0x45, 0x67, 0xbe, 0x9a, 0x75, 0x56, 0x5c, 0x64, 0x9c, 0x1d, - 0x91, 0x0a, 0x4e, 0xad, 0x68, 0x7d, 0xe2, 0x29, 0x36, 0x8d, 0xdf, 0x1b, 0xa4, 0xce, 0x1e, 0x99, 0x7b, 0x76, 0x50, - 0x51, 0x5a, 0x42, 0x81, 0xf5, 0x22, 0x6a, 0xe0, 0xdb, 0x23, 0x9b, 0x31, 0xd3, 0xe7, 0xa4, 0xc0, 0x8b, 0x96, 0x60, - 0xb3, 0xbc, 0xd4, 0x41, 0x13, 0x2f, 0x4b, 0xe6, 0x8a, 0x13, 0xfe, 0x74, 0x99, 0x29, 0xf6, 0x43, 0x46, 0xea, 0x60, - 0xcf, 0x8b, 0x15, 0x7b, 0x96, 0xcb, 0xa7, 0xcb, 0x87, 0x68, 0x93, 0x7b, 0x8f, 0x88, 0x19, 0xaf, 0x1f, 0x2f, 0xda, - 0xa4, 0x04, 0x94, 0xc8, 0xc8, 0x86, 0x71, 0x1b, 0x09, 0x35, 0x8a, 0xf2, 0xd1, 0x15, 0x28, 0x39, 0xd6, 0xa9, 0x08, - 0x00, 0xf8, 0x63, 0x3a, 0x14, 0x36, 0xf0, 0x60, 0x3e, 0x91, 0x80, 0x32, 0xf2, 0xf4, 0x9d, 0xc9, 0x90, 0x10, 0x1d, - 0x35, 0x33, 0x7c, 0x4f, 0x18, 0xab, 0x67, 0x1e, 0x1d, 0x1f, 0x45, 0x1d, 0x6e, 0x84, 0x81, 0xc4, 0xb2, 0x6c, 0xb2, - 0x9b, 0xb7, 0x6e, 0x2b, 0x7c, 0x57, 0xac, 0x40, 0x9a, 0x02, 0x34, 0x2f, 0xe3, 0x46, 0xc0, 0x69, 0x18, 0xb3, 0x2f, - 0x03, 0xd4, 0x58, 0xc1, 0x58, 0x7e, 0xb5, 0xb2, 0xe1, 0xd9, 0x24, 0xef, 0x7e, 0x74, 0x99, 0x0b, 0x84, 0xbc, 0x58, - 0x60, 0x5b, 0x12, 0x75, 0xe2, 0x37, 0x83, 0xdf, 0xd3, 0xef, 0xd5, 0xf4, 0xd1, 0xc6, 0x88, 0x36, 0x3a, 0xcb, 0x4d, - 0x0f, 0x7a, 0xb4, 0x5b, 0xb0, 0x6a, 0x21, 0x52, 0xcd, 0xf1, 0x30, 0x03, 0x1b, 0xd1, 0x97, 0xd8, 0x60, 0xf5, 0x83, - 0x8d, 0x02, 0xc9, 0xc2, 0x90, 0x6d, 0x9b, 0x3d, 0x36, 0x30, 0x04, 0xe5, 0x59, 0x35, 0x05, 0x58, 0x23, 0xb6, 0xab, - 0x14, 0x46, 0x93, 0x7f, 0xd5, 0x16, 0xfd, 0x27, 0xff, 0x53, 0xac, 0xf7, 0x4c, 0x80, 0x64, 0x7b, 0x38, 0x9f, 0x9d, - 0xa6, 0x05, 0x33, 0x78, 0x14, 0x84, 0xf6, 0x60, 0x4a, 0xcd, 0x49, 0x24, 0x06, 0x25, 0x17, 0x22, 0xfb, 0x93, 0xea, - 0x2d, 0xc7, 0x67, 0x1e, 0x2a, 0xbf, 0xb9, 0x93, 0xe2, 0xa4, 0xd3, 0xea, 0x52, 0x19, 0xc1, 0x5d, 0x81, 0x13, 0x94, - 0x60, 0x36, 0xa0, 0x7f, 0xf2, 0xdb, 0x4d, 0x48, 0xa2, 0x4f, 0x5d, 0x60, 0x28, 0x63, 0xf6, 0x8c, 0xc8, 0xcc, 0xc2, - 0x23, 0x5a, 0x85, 0x28, 0xc6, 0x05, 0x72, 0xc0, 0x6c, 0x3f, 0x1b, 0x59, 0xb0, 0xd5, 0xb0, 0x9f, 0xfb, 0x46, 0xb4, - 0x0f, 0x61, 0x32, 0x62, 0x73, 0xe2, 0x2d, 0xc9, 0x03, 0x68, 0x88, 0x1e, 0xe6, 0x42, 0xe3, 0x82, 0x97, 0xae, 0x52, - 0xa3, 0x14, 0xe8, 0x26, 0x1e, 0xf5, 0x76, 0x68, 0xd4, 0x6a, 0x79, 0x33, 0x46, 0x17, 0xc0, 0x21, 0xaf, 0xf7, 0x4f, - 0xf0, 0xd4, 0x63, 0x86, 0xd8, 0x8b, 0x37, 0x1c, 0x58, 0xad, 0x71, 0xb1, 0x9d, 0x13, 0x37, 0x45, 0xc1, 0xc5, 0x99, - 0x4a, 0x7f, 0xb7, 0x85, 0xff, 0xad, 0xbc, 0xbb, 0x2a, 0xb2, 0x26, 0x28, 0x3f, 0x08, 0xce, 0xdc, 0xf3, 0x02, 0x3e, - 0x59, 0xe9, 0x74, 0xf8, 0x8d, 0xd2, 0x7c, 0x70, 0xf3, 0x84, 0xd1, 0x16, 0x6e, 0xaf, 0x30, 0x57, 0xe1, 0x0a, 0x96, - 0x11, 0xda, 0x67, 0xdc, 0x7a, 0xfc, 0xb9, 0x68, 0x8c, 0x29, 0x47, 0xe7, 0x1c, 0xe4, 0x67, 0x84, 0x04, 0xd3, 0xc0, - 0x26, 0x3d, 0xda, 0x61, 0x99, 0x16, 0x48, 0x09, 0x42, 0x4e, 0x2a, 0xba, 0x1f, 0xc3, 0x50, 0x89, 0xcd, 0x24, 0x24, - 0xad, 0x2a, 0x76, 0xe8, 0xc4, 0x29, 0x37, 0x1b, 0xa6, 0x58, 0x23, 0x7c, 0xba, 0xe9, 0x67, 0x88, 0x92, 0xc8, 0x7b, - 0x2e, 0x6e, 0x46, 0x1d, 0xbc, 0x22, 0x53, 0xc5, 0xd2, 0x57, 0x9e, 0x70, 0xeb, 0xaf, 0xb5, 0x0f, 0x90, 0xef, 0x10, - 0x0a, 0x7a, 0x5c, 0xe5, 0x5f, 0xce, 0x61, 0x56, 0xf2, 0x12, 0xae, 0xf0, 0x53, 0x1c, 0xca, 0x5c, 0x54, 0xd0, 0xe3, - 0xb9, 0x08, 0xf1, 0x96, 0xc3, 0x5b, 0x05, 0x9f, 0x44, 0x5f, 0x24, 0xc2, 0x7d, 0xcb, 0xce, 0xa6, 0xcf, 0x4a, 0x78, - 0xfd, 0xb9, 0x39, 0x29, 0x05, 0xd7, 0x81, 0x46, 0xcf, 0x61, 0xe0, 0x65, 0xd0, 0x62, 0xec, 0xd4, 0xc0, 0x3d, 0x91, - 0xec, 0x5b, 0x7f, 0x60, 0x49, 0xf5, 0xd3, 0x0f, 0x1a, 0x10, 0xcf, 0xd4, 0x7f, 0x3b, 0x30, 0xf1, 0x58, 0xfe, 0x91, - 0xe7, 0x3f, 0x93, 0x44, 0xd5, 0xc5, 0x03, 0x6c, 0x9d, 0x64, 0x0b, 0x05, 0x14, 0x1d, 0x1e, 0x10, 0xb0, 0x68, 0x6f, - 0x57, 0x69, 0x99, 0x9d, 0x30, 0x87, 0x3c, 0xdd, 0x55, 0xaf, 0xb3, 0x04, 0xa7, 0xaf, 0xd6, 0xb3, 0x15, 0xe8, 0xb4, - 0xb0, 0x00, 0x94, 0x38, 0xb3, 0x44, 0x75, 0xc6, 0xc1, 0xa9, 0xc5, 0x67, 0xfc, 0xaf, 0x57, 0x2a, 0x61, 0xec, 0xc1, - 0xc3, 0x41, 0x75, 0xa1, 0x82, 0xfc, 0xec, 0x85, 0xa6, 0x34, 0x0c, 0x20, 0xe1, 0x9c, 0xc6, 0x21, 0x59, 0xc6, 0x16, - 0x8f, 0xbc, 0x32, 0x15, 0x3a, 0x81, 0x75, 0xa7, 0x4f, 0xa7, 0x83, 0x60, 0x5c, 0x62, 0x85, 0xc1, 0x6b, 0x2e, 0x0c, - 0x47, 0x5a, 0x2e, 0xa7, 0xf8, 0x2b, 0x4d, 0xd4, 0xb5, 0xc8, 0x26, 0xf3, 0x1a, 0x57, 0x0d, 0xc4, 0x99, 0x76, 0x41, - 0x86, 0xe5, 0x53, 0xe4, 0xd6, 0x62, 0xb9, 0xf6, 0x5b, 0x9f, 0x57, 0x18, 0x86, 0xca, 0xcd, 0xaf, 0xf7, 0xf4, 0xcd, - 0x1d, 0x89, 0x53, 0x2f, 0xde, 0xa2, 0x40, 0xd3, 0x89, 0x5e, 0x0c, 0x35, 0xc2, 0xd3, 0x71, 0x17, 0x91, 0x61, 0x34, - 0xe0, 0xf4, 0x6d, 0x55, 0x33, 0x66, 0xd2, 0x0e, 0xa0, 0x9f, 0x0b, 0xea, 0x1c, 0x00, 0x9a, 0x22, 0x94, 0x1d, 0x08, - 0x57, 0xa1, 0x5a, 0xaf, 0x97, 0x95, 0x36, 0x36, 0x96, 0x07, 0x0a, 0x21, 0x30, 0x2b, 0x5e, 0x52, 0x28, 0xb9, 0x42, - 0x20, 0x2f, 0xb6, 0xa9, 0x4a, 0x65, 0xa6, 0x65, 0xb3, 0x76, 0xd7, 0x15, 0xed, 0x00, 0xa2, 0x26, 0x6d, 0x64, 0x32, - 0x81, 0x0d, 0x15, 0xd2, 0x14, 0x17, 0x49, 0xad, 0x04, 0x5c, 0xf3, 0x61, 0x0a, 0xa6, 0x11, 0x38, 0x3b, 0x80, 0x16, - 0xcc, 0xe1, 0x5e, 0x33, 0x64, 0x9a, 0x3c, 0xa7, 0x7d, 0x46, 0x8f, 0xb6, 0x5a, 0x63, 0xab, 0x5a, 0xb5, 0x8b, 0xfb, - 0xc9, 0x3a, 0x60, 0x62, 0xc0, 0x6a, 0x7b, 0xfc, 0x6f, 0x85, 0x74, 0xe6, 0x63, 0x21, 0x95, 0xfe, 0x6f, 0x46, 0xe7, - 0x62, 0xde, 0x3c, 0x3f, 0x8c, 0x5c, 0x61, 0x4c, 0x85, 0x3c, 0xc6, 0x49, 0x78, 0xb1, 0x1d, 0x5e, 0x34, 0x06, 0xb5, - 0x1f, 0x30, 0x18, 0x72, 0xaa, 0x63, 0xef, 0x7d, 0x10, 0x92, 0x7d, 0x31, 0xb7, 0x68, 0xac, 0x4e, 0x69, 0x51, 0xac, - 0xfb, 0x00, 0x32, 0x28, 0x8a, 0xfd, 0xff, 0xb8, 0x75, 0x91, 0x85, 0xe6, 0x0f, 0xe4, 0x25, 0x2e, 0x79, 0x98, 0xfe, - 0xf8, 0x5d, 0x50, 0xac, 0x4f, 0x1b, 0xf1, 0x12, 0xcd, 0x95, 0x83, 0x7f, 0xd3, 0x65, 0x8b, 0xea, 0x2e, 0xe5, 0xe1, - 0xde, 0x81, 0x31, 0x8d, 0x6f, 0x6e, 0xbe, 0x8c, 0x0b, 0x6b, 0x9c, 0xbb, 0x19, 0xef, 0x70, 0x13, 0xbb, 0xde, 0x56, - 0x56, 0x6c, 0x17, 0x99, 0xa2, 0xa2, 0xa9, 0xd1, 0x47, 0x33, 0x30, 0x76, 0x68, 0x40, 0xfb, 0xb7, 0x18, 0x32, 0x58, - 0x3c, 0xac, 0xcd, 0x85, 0x68, 0x79, 0x9d, 0xcb, 0x1d, 0x05, 0xe7, 0x64, 0xc4, 0x91, 0x04, 0x69, 0xd2, 0x7d, 0xc7, - 0xc9, 0x83, 0x3a, 0xa8, 0x1a, 0x71, 0xa7, 0x9a, 0xec, 0x57, 0xc2, 0xff, 0x21, 0x1f, 0xd7, 0x9d, 0xb6, 0x72, 0x0e, - 0x08, 0xf1, 0x59, 0xe7, 0xcd, 0x09, 0x91, 0x51, 0xdb, 0x46, 0x6d, 0x25, 0xcd, 0xc8, 0xaf, 0x10, 0x89, 0xfa, 0x57, - 0x8c, 0x02, 0x53, 0x7c, 0x06, 0x30, 0xb0, 0x4d, 0x82, 0xd5, 0x6f, 0xd6, 0x0d, 0xd9, 0x52, 0x40, 0xe3, 0x97, 0xb3, - 0x6d, 0x3e, 0xb1, 0x71, 0x3b, 0xfa, 0x05, 0x51, 0xdb, 0x5a, 0xd1, 0x04, 0xd7, 0xdd, 0x0b, 0xab, 0x37, 0xe2, 0xf7, - 0xd4, 0xdb, 0x23, 0xc8, 0x0d, 0xe4, 0x93, 0x74, 0xbf, 0x73, 0xa6, 0x0f, 0xd8, 0x83, 0x31, 0x8e, 0x31, 0xd8, 0x15, - 0xf3, 0xcc, 0xe8, 0x4d, 0x55, 0xd9, 0x04, 0x7a, 0x77, 0xcb, 0x51, 0x71, 0x8f, 0xdf, 0xd2, 0x2f, 0xde, 0x30, 0xc3, - 0xe8, 0x3e, 0x5f, 0x40, 0xd9, 0xa2, 0x1d, 0x57, 0x1a, 0xc9, 0x65, 0xb4, 0x4d, 0xe5, 0x88, 0x12, 0x58, 0x50, 0x92, - 0x1a, 0x5d, 0xde, 0xdc, 0xb2, 0x79, 0x71, 0x1d, 0x4d, 0x28, 0xb7, 0xfe, 0x74, 0xe4, 0x73, 0x3d, 0x38, 0x2a, 0x6f, - 0x43, 0x04, 0xa6, 0x89, 0x36, 0x2c, 0xe0, 0x30, 0xd3, 0xe6, 0xa5, 0x08, 0x02, 0xf0, 0x6e, 0xf0, 0x67, 0x9b, 0x81, - 0x22, 0x17, 0x10, 0x79, 0xe7, 0x2d, 0x58, 0xa0, 0x1b, 0x3c, 0x05, 0xfa, 0x38, 0x36, 0xfc, 0x77, 0xc1, 0xca, 0xd8, - 0x90, 0x2c, 0x61, 0x7c, 0xaf, 0x73, 0x22, 0x39, 0x49, 0x5d, 0x24, 0xad, 0x9f, 0xc2, 0x33, 0xb5, 0x8d, 0x5b, 0xf3, - 0x17, 0xe9, 0x27, 0xd1, 0x50, 0x79, 0x01, 0xf3, 0x35, 0xaa, 0xb3, 0xcb, 0xfc, 0x85, 0x79, 0x4e, 0x7a, 0x66, 0x5e, - 0xa3, 0xd5, 0x1a, 0xf0, 0xc0, 0xd2, 0x8a, 0xb0, 0x94, 0x59, 0x32, 0xe7, 0x32, 0x00, 0xf0, 0xb5, 0xf1, 0x79, 0x6d, - 0x08, 0xf1, 0x89, 0x5d, 0xdf, 0x15, 0x84, 0xca, 0x54, 0xd3, 0xae, 0x33, 0xf7, 0xc9, 0x2a, 0x84, 0xa5, 0xda, 0x76, - 0xc5, 0x6d, 0xa6, 0xb9, 0xad, 0x0d, 0xcf, 0x3d, 0x5f, 0x37, 0x05, 0xa6, 0xe8, 0x0c, 0xfa, 0x3b, 0xdb, 0x88, 0x53, - 0x04, 0x21, 0x62, 0x06, 0x1f, 0xb0, 0x36, 0x82, 0x6c, 0xca, 0x89, 0xfe, 0x6c, 0x17, 0xd4, 0x34, 0xbd, 0x4c, 0x55, - 0x85, 0xcb, 0x39, 0x26, 0x13, 0x9b, 0xb3, 0x01, 0x8b, 0x39, 0x78, 0xf0, 0xf0, 0x36, 0xb7, 0x65, 0xd9, 0x1b, 0x11, - 0xac, 0x06, 0x2d, 0x9c, 0x3b, 0x58, 0x2a, 0xf4, 0x9d, 0xcc, 0x7a, 0x57, 0x07, 0x37, 0xb3, 0xdf, 0xa4, 0xdd, 0x1f, - 0x39, 0xfa, 0xaa, 0xd2, 0xb8, 0x03, 0xdb, 0x58, 0x02, 0x1b, 0x1e, 0x23, 0x52, 0x0e, 0x89, 0xea, 0x53, 0x1f, 0x54, - 0x8f, 0x6a, 0x4c, 0x72, 0x1c, 0x48, 0x87, 0x89, 0x2b, 0x12, 0x7b, 0x93, 0x16, 0x62, 0x57, 0x2a, 0xa4, 0xa7, 0xb3, - 0x90, 0xaf, 0x25, 0x37, 0x5d, 0x27, 0x89, 0x6c, 0x51, 0xfb, 0x90, 0x57, 0x2d, 0xa9, 0x53, 0x83, 0xf2, 0x78, 0xcc, - 0xd1, 0x8f, 0x77, 0x5b, 0xf9, 0x4a, 0x6d, 0x1d, 0xe7, 0x24, 0xf8, 0x1c, 0xc7, 0x8b, 0x86, 0x7f, 0x2e, 0xca, 0x1b, - 0x2d, 0x3c, 0x8f, 0x2b, 0x3f, 0xec, 0xe4, 0xf5, 0x2b, 0x34, 0x4c, 0xc3, 0x51, 0xeb, 0xb6, 0xbc, 0xe2, 0x70, 0xef, - 0x76, 0x62, 0xb1, 0x84, 0xf5, 0x31, 0x2e, 0x97, 0x3c, 0x8d, 0xaa, 0xa5, 0xa3, 0x3f, 0xdd, 0x01, 0xb7, 0xe4, 0x9d, - 0x00, 0x98, 0xe8, 0xd0, 0x47, 0x58, 0xd0, 0x5e, 0x46, 0x8c, 0x10, 0x7b, 0xc1, 0xe4, 0x30, 0x64, 0xef, 0xfe, 0x0f, - 0xbb, 0x1e, 0x86, 0x6c, 0x49, 0xb2, 0xbb, 0x37, 0x23, 0x7c, 0xa1, 0x9e, 0x1e, 0x58, 0x8d, 0xc3, 0x35, 0x79, 0xb1, - 0x0d, 0x51, 0xec, 0x25, 0xdc, 0x30, 0x6a, 0x4b, 0x31, 0xb7, 0x60, 0x8d, 0x71, 0x48, 0xb1, 0x35, 0xca, 0xa8, 0x61, - 0x73, 0x68, 0x73, 0x28, 0xed, 0xbd, 0xe2, 0xbb, 0xfc, 0x1d, 0xe2, 0x83, 0x6f, 0x6d, 0x8f, 0xa2, 0xee, 0x9d, 0x7b, - 0xcb, 0xbc, 0x48, 0x57, 0xb2, 0xfe, 0xb9, 0x9d, 0xd8, 0x50, 0xdc, 0x4d, 0x37, 0x63, 0x3d, 0x71, 0x90, 0x5d, 0x9a, - 0x7c, 0x20, 0xa8, 0xa2, 0x64, 0xa5, 0xd5, 0xff, 0xec, 0xf6, 0xdf, 0x72, 0x1e, 0x9a, 0x68, 0x74, 0x6c, 0x3b, 0xb4, - 0x46, 0xef, 0xe1, 0xd7, 0xf8, 0x18, 0xab, 0x05, 0x24, 0x87, 0xb9, 0x4e, 0x94, 0xba, 0x19, 0x11, 0x3a, 0x71, 0xe3, - 0x05, 0xa2, 0xde, 0x76, 0x3d, 0xd3, 0xb9, 0xf4, 0xfe, 0x2e, 0x03, 0x34, 0x35, 0x84, 0xe0, 0x21, 0x24, 0xe7, 0x37, - 0xe1, 0xcd, 0xe8, 0x44, 0x7c, 0xc3, 0x74, 0x39, 0x43, 0xee, 0xe1, 0x0b, 0xb4, 0xee, 0x24, 0x58, 0x38, 0xdc, 0x10, - 0x52, 0xa4, 0x82, 0x00, 0xd9, 0x3e, 0x06, 0xb0, 0x30, 0xc9, 0x5e, 0x34, 0x19, 0x0d, 0x88, 0x6c, 0xd6, 0xb6, 0x84, - 0x39, 0x36, 0x53, 0x80, 0x16, 0x6c, 0xcd, 0x2f, 0x81, 0xb3, 0xa1, 0x2d, 0xde, 0xd2, 0xff, 0xe4, 0x35, 0x11, 0x60, - 0x4c, 0x53, 0x9b, 0x66, 0xd6, 0x2b, 0xab, 0x85, 0xa3, 0x28, 0x59, 0x2c, 0x90, 0x03, 0xd7, 0x0d, 0xa5, 0xb1, 0x35, - 0x56, 0x97, 0x34, 0xa0, 0xe5, 0xa2, 0xba, 0x20, 0x10, 0x12, 0x43, 0xcc, 0xab, 0x86, 0x42, 0x4a, 0x12, 0xaa, 0xb9, - 0x75, 0x27, 0xb6, 0x09, 0x0a, 0xb3, 0xe3, 0xce, 0xe4, 0xa1, 0x9f, 0xe1, 0xf8, 0xe3, 0x8d, 0xd9, 0x41, 0xa0, 0x70, - 0xc5, 0x4b, 0x19, 0x0d, 0x2a, 0xcb, 0x66, 0x3d, 0xf4, 0xca, 0xcd, 0x02, 0xda, 0x9d, 0xca, 0x32, 0xa3, 0xda, 0xa9, - 0x9e, 0x09, 0x4e, 0x6f, 0x0d, 0xd0, 0x88, 0x48, 0x80, 0x09, 0xfc, 0xa8, 0xbf, 0x34, 0x2a, 0x16, 0x18, 0x6b, 0x2b, - 0x8f, 0x7a, 0x7d, 0x8f, 0x33, 0x99, 0xce, 0x03, 0x6c, 0x9c, 0xb3, 0x68, 0x55, 0x23, 0x9e, 0x90, 0xa0, 0x4f, 0x72, - 0xb2, 0x73, 0x56, 0x2d, 0xe3, 0xeb, 0xe4, 0x82, 0x2f, 0xd8, 0x1d, 0x7f, 0xad, 0x11, 0x94, 0xe3, 0x5f, 0x5c, 0xbc, - 0xc5, 0x6b, 0xe1, 0x14, 0xd7, 0x23, 0xe6, 0x8b, 0x32, 0x2f, 0x7f, 0x78, 0x61, 0xe6, 0xf4, 0xef, 0xaf, 0x30, 0x01, - 0x55, 0xfe, 0x62, 0x89, 0x04, 0x52, 0x79, 0x78, 0xeb, 0x8d, 0xe0, 0x4a, 0x66, 0x14, 0x8d, 0x59, 0x3b, 0x6e, 0x09, - 0x3b, 0x58, 0x14, 0x47, 0x10, 0x2a, 0xfe, 0xf9, 0x0c, 0x20, 0x71, 0x16, 0xb4, 0xcc, 0x68, 0xd0, 0x88, 0xf6, 0xc0, - 0x9d, 0x15, 0x36, 0xe6, 0x85, 0x5c, 0x97, 0x6f, 0x1f, 0x56, 0x70, 0x90, 0x25, 0x24, 0xc1, 0xc3, 0x7a, 0xfb, 0xa6, - 0xca, 0x74, 0xe9, 0x61, 0xea, 0x75, 0xc7, 0xef, 0x99, 0x09, 0x08, 0x69, 0xf6, 0x10, 0xd9, 0xdc, 0x8d, 0xc4, 0xf4, - 0xc6, 0x53, 0xdb, 0x8e, 0x98, 0x8f, 0xed, 0x44, 0xe4, 0x4a, 0x1d, 0xdb, 0xe6, 0x21, 0x32, 0xc2, 0x0a, 0x23, 0x09, - 0x2e, 0xbf, 0x8c, 0xc8, 0x4d, 0x16, 0x34, 0xf6, 0x31, 0xba, 0x94, 0xc5, 0x24, 0xfb, 0x08, 0xfe, 0x52, 0xd6, 0xfa, - 0x97, 0xa8, 0x75, 0xf6, 0x04, 0x7e, 0xc5, 0xd0, 0xde, 0x43, 0x68, 0xac, 0xb3, 0xe0, 0x5d, 0x0b, 0x1e, 0x29, 0xa0, - 0xdc, 0x87, 0x89, 0x84, 0x50, 0x5c, 0x1f, 0x87, 0x5d, 0xb9, 0x6b, 0x89, 0x11, 0xe1, 0xa3, 0xa4, 0x57, 0x6a, 0x93, - 0x31, 0x5c, 0x81, 0x00, 0x2e, 0xcf, 0xf5, 0x78, 0x3e, 0xc3, 0x6c, 0xaf, 0x34, 0x92, 0xd0, 0x77, 0xc3, 0x8c, 0x97, - 0x9b, 0x6e, 0x51, 0x59, 0xb4, 0x79, 0x2b, 0x85, 0xbd, 0x2e, 0x10, 0x99, 0x11, 0x22, 0xe6, 0x96, 0xdf, 0x14, 0xa4, - 0x93, 0xed, 0x7c, 0x83, 0x3e, 0x36, 0x30, 0x9c, 0xc1, 0x4a, 0x57, 0xb5, 0xb5, 0x73, 0x2b, 0xb1, 0xfe, 0x9d, 0x15, - 0x13, 0xf8, 0xf9, 0x62, 0x41, 0x42, 0x40, 0xc2, 0x42, 0xcf, 0x3c, 0x98, 0xf5, 0x70, 0x92, 0x4e, 0x79, 0xf6, 0x12, - 0x13, 0x2e, 0x64, 0xe8, 0x70, 0xfc, 0xa0, 0xa5, 0xb9, 0xa0, 0x39, 0x7e, 0x3e, 0xd3, 0x52, 0xf9, 0x5a, 0x49, 0x93, - 0x2c, 0x58, 0xe5, 0x85, 0xd3, 0xe5, 0x23, 0x43, 0x14, 0x9f, 0x6a, 0xd7, 0x7d, 0x87, 0x9b, 0xcf, 0xa4, 0x68, 0x24, - 0x95, 0x76, 0x22, 0x50, 0x69, 0xc8, 0xe4, 0xed, 0x5e, 0x00, 0x62, 0x1b, 0xa2, 0x2f, 0x9a, 0x8d, 0xcc, 0x54, 0xa6, - 0xa3, 0xab, 0xe5, 0x21, 0x1c, 0xdb, 0xc3, 0x9b, 0xa1, 0x61, 0x08, 0x78, 0x7d, 0x5a, 0xb3, 0x7f, 0x1d, 0x75, 0xa8, - 0x68, 0x62, 0x54, 0xc4, 0xcd, 0x05, 0x93, 0x25, 0x2b, 0xa6, 0x21, 0x41, 0x38, 0x69, 0xc0, 0xe9, 0x6c, 0xc6, 0xd8, - 0x20, 0x79, 0x81, 0x49, 0x26, 0xf6, 0x04, 0x5a, 0x9a, 0x80, 0x79, 0x45, 0xd9, 0x79, 0xb4, 0x19, 0xdb, 0x19, 0xa1, - 0x9c, 0x39, 0x89, 0x8a, 0xf8, 0x67, 0xee, 0x49, 0x2b, 0xe0, 0x3e, 0x63, 0xba, 0xeb, 0x35, 0x9e, 0x71, 0x04, 0x45, - 0xbf, 0x6d, 0x9b, 0xff, 0x65, 0x18, 0x84, 0xa7, 0xcb, 0x76, 0x0e, 0x50, 0x41, 0x96, 0x10, 0xf0, 0x27, 0x2f, 0xe8, - 0x4b, 0xc0, 0x43, 0x0c, 0xf8, 0x81, 0xbd, 0x7a, 0x6d, 0x05, 0x3a, 0xb8, 0xfa, 0xea, 0xec, 0xf7, 0xdf, 0x32, 0x38, - 0xfc, 0x07, 0x57, 0xda, 0xf7, 0x8f, 0x4f, 0x09, 0x9b, 0x93, 0xa7, 0x78, 0x3a, 0x3a, 0xc7, 0xe1, 0xb6, 0x1e, 0xe5, - 0x74, 0x3b, 0x25, 0x14, 0x5e, 0xf8, 0x40, 0xfc, 0x31, 0x8b, 0xbb, 0x81, 0xa6, 0xf2, 0x71, 0xce, 0x1f, 0xe4, 0x27, - 0xc7, 0x27, 0xe9, 0x3e, 0xcd, 0x73, 0x38, 0xe6, 0x82, 0x6d, 0x0c, 0x83, 0xab, 0xce, 0xce, 0x2e, 0xe5, 0x66, 0x58, - 0x4a, 0x7a, 0xab, 0xdb, 0xbd, 0x8e, 0x51, 0xe9, 0xff, 0x2b, 0x7b, 0x4b, 0x47, 0x38, 0x8c, 0x7f, 0xf8, 0x0c, 0x05, - 0x41, 0xee, 0x14, 0xeb, 0xf4, 0xa2, 0x70, 0x8d, 0x3b, 0x94, 0x6f, 0xad, 0xb6, 0xbe, 0xaa, 0x52, 0x8f, 0xcc, 0x45, - 0x8c, 0xf3, 0x15, 0xf1, 0xb2, 0x9a, 0xbc, 0x6e, 0xd0, 0x6f, 0x4f, 0x94, 0xf9, 0xcf, 0xaf, 0x21, 0xc1, 0x76, 0x74, - 0xbf, 0x86, 0xfb, 0x1d, 0x71, 0x0d, 0x6b, 0xce, 0x91, 0x17, 0x9c, 0x71, 0x5d, 0x3d, 0x6d, 0x93, 0x75, 0x2d, 0x1c, - 0xdb, 0x2e, 0x07, 0x5e, 0xeb, 0x52, 0xe7, 0x10, 0xa5, 0x95, 0x71, 0xcf, 0xe9, 0x5d, 0x97, 0xdf, 0x99, 0xea, 0x18, - 0x76, 0x03, 0x9c, 0x8a, 0x60, 0x40, 0x81, 0x79, 0x1f, 0xd4, 0x9d, 0x0c, 0x21, 0x27, 0xf6, 0xac, 0x81, 0x5c, 0x82, - 0x28, 0x9a, 0x2f, 0x41, 0x00, 0x5a, 0xda, 0x81, 0x97, 0xb5, 0x8a, 0x46, 0x96, 0xac, 0x81, 0xb3, 0xd7, 0xff, 0x23, - 0x06, 0x43, 0x9c, 0x7c, 0x93, 0x80, 0x38, 0xc9, 0x14, 0x89, 0x39, 0x8d, 0x45, 0x9f, 0xb3, 0x8f, 0x72, 0x09, 0xd2, - 0xec, 0x67, 0x60, 0x80, 0x60, 0x1a, 0x8e, 0x63, 0x41, 0xa1, 0x64, 0xbe, 0x2a, 0xfa, 0x69, 0xb3, 0xf8, 0xfc, 0x09, - 0xc6, 0xf6, 0x6f, 0x74, 0xdb, 0xa8, 0xfc, 0x5e, 0x53, 0xc9, 0xed, 0xaf, 0x3c, 0x9f, 0xfe, 0xb6, 0x3a, 0x3c, 0xfd, - 0x44, 0xfd, 0xf8, 0x75, 0xd3, 0x02, 0xef, 0xe4, 0xee, 0xa5, 0x0c, 0x35, 0x3f, 0x5f, 0x67, 0x40, 0x58, 0x18, 0x80, - 0xfa, 0xd1, 0xf1, 0xa1, 0xa4, 0xdd, 0xd6, 0xb3, 0x41, 0x34, 0xb1, 0x8f, 0x71, 0x8b, 0xea, 0xe5, 0xbc, 0xc0, 0x66, - 0x35, 0xae, 0xa1, 0x7b, 0x5e, 0x68, 0xcd, 0x33, 0x61, 0x96, 0x0a, 0x4a, 0xe1, 0x64, 0x0a, 0xb8, 0x01, 0x5c, 0x57, - 0x4e, 0x9b, 0x85, 0x17, 0xbd, 0x09, 0x4f, 0x12, 0xcc, 0xe8, 0xc0, 0x45, 0xd3, 0x57, 0x4f, 0xed, 0x8b, 0x8e, 0xe1, - 0xcf, 0x44, 0x5d, 0x8d, 0x21, 0xa9, 0x51, 0x8e, 0x49, 0x8b, 0x95, 0x56, 0x68, 0x2d, 0xaf, 0x96, 0xba, 0xdb, 0x39, - 0x42, 0xaf, 0xbc, 0xa0, 0x0c, 0xc0, 0x03, 0x98, 0xf5, 0x92, 0xde, 0xd2, 0x2a, 0xb2, 0x29, 0xfb, 0x84, 0x5c, 0x9b, - 0xc7, 0x13, 0x9c, 0x96, 0x3e, 0xaa, 0x5b, 0xa4, 0x49, 0x6c, 0x85, 0x6b, 0x38, 0x37, 0x59, 0x55, 0xf5, 0xa2, 0xf9, - 0xda, 0x0f, 0x30, 0xa7, 0x05, 0xfb, 0x37, 0xf6, 0x45, 0xd3, 0x72, 0x12, 0x68, 0xbb, 0x68, 0x64, 0x0b, 0xca, 0x00, - 0x88, 0xd2, 0x3d, 0xbd, 0x01, 0x07, 0xa2, 0x5d, 0xd3, 0x89, 0xf8, 0x36, 0xb1, 0x1d, 0xce, 0x4d, 0x56, 0xa8, 0x85, - 0x0b, 0x73, 0x34, 0x9b, 0x2e, 0x9c, 0xa8, 0xbd, 0x4b, 0x7b, 0x9e, 0x0d, 0x34, 0x6e, 0xf3, 0x40, 0x21, 0x7d, 0x2f, - 0xf0, 0xa8, 0x41, 0xdc, 0x50, 0xa1, 0x17, 0x21, 0x53, 0x81, 0x6b, 0x0a, 0xb6, 0x21, 0x33, 0xd3, 0x38, 0x00, 0xc8, - 0xde, 0x45, 0xdc, 0x80, 0x83, 0x2b, 0x35, 0x86, 0x8e, 0xad, 0xd7, 0xe4, 0x95, 0x64, 0x82, 0xa0, 0xf2, 0x66, 0x89, - 0xcd, 0x58, 0x72, 0x10, 0x95, 0x6f, 0x70, 0xb3, 0x73, 0x27, 0x64, 0xf6, 0x3b, 0x9d, 0x21, 0x4c, 0x59, 0x59, 0xed, - 0x90, 0x9b, 0x11, 0x2f, 0x14, 0x98, 0x5a, 0xb4, 0x20, 0x22, 0x19, 0xb1, 0xaa, 0x1b, 0xbf, 0xf3, 0x76, 0x94, 0x9b, - 0x89, 0x6d, 0xb1, 0x5e, 0xf1, 0x8c, 0x60, 0xbd, 0x83, 0xb5, 0x73, 0xf4, 0x6a, 0x67, 0x64, 0xae, 0xf0, 0x62, 0x98, - 0xdc, 0xae, 0xe7, 0x83, 0x61, 0x44, 0x7d, 0xf9, 0x3f, 0xdb, 0x98, 0x55, 0xe5, 0x34, 0x1a, 0x43, 0x42, 0x24, 0xc3, - 0x9b, 0x00, 0xc4, 0xf3, 0xac, 0xc9, 0x18, 0xcd, 0xc4, 0x6a, 0xdb, 0x3a, 0x4d, 0xb3, 0x9f, 0x4f, 0x39, 0xfd, 0xde, - 0x48, 0x38, 0xc0, 0xf3, 0xaa, 0x73, 0x23, 0xbb, 0x7e, 0xa0, 0x8b, 0x39, 0xf4, 0x65, 0x26, 0x57, 0xf5, 0x8d, 0xec, - 0x54, 0x23, 0xcc, 0xcc, 0xa0, 0xef, 0x06, 0x25, 0x0f, 0x00, 0xd0, 0x1f, 0xe7, 0xe5, 0xd5, 0xff, 0x35, 0x9a, 0x3b, - 0x61, 0x04, 0x1b, 0x2b, 0x96, 0xe6, 0x38, 0x5e, 0x0e, 0xed, 0x40, 0x45, 0xcf, 0x89, 0xda, 0xd3, 0x88, 0xa4, 0x4b, - 0x6a, 0x0c, 0xe3, 0x89, 0x59, 0x1a, 0x1c, 0xd6, 0x50, 0x82, 0xfd, 0x32, 0xfa, 0xed, 0xda, 0xfb, 0x06, 0x52, 0xfc, - 0x1b, 0xd7, 0xd5, 0xf1, 0xec, 0xa8, 0x32, 0x93, 0x5a, 0xe6, 0x89, 0xdb, 0xe2, 0xaa, 0xae, 0x9a, 0xf9, 0xb4, 0x5d, - 0x32, 0x4d, 0x3b, 0x8f, 0xd9, 0x65, 0xfc, 0x19, 0x4d, 0x24, 0x23, 0x3f, 0xac, 0xc3, 0x00, 0x0d, 0x0c, 0xb4, 0x97, - 0xf8, 0xe9, 0x49, 0xa6, 0xab, 0xb7, 0xba, 0x49, 0xd0, 0xba, 0x5c, 0xa7, 0x1f, 0x48, 0xbd, 0xa0, 0x65, 0xd8, 0x59, - 0x33, 0x78, 0xe6, 0x84, 0xe8, 0x02, 0xe7, 0x27, 0xe6, 0x21, 0x67, 0xd4, 0x34, 0xa0, 0x5f, 0xe7, 0xe5, 0x55, 0x97, - 0xbb, 0xc8, 0xc0, 0xcd, 0x04, 0x76, 0xc8, 0x6e, 0x68, 0x7d, 0xac, 0x89, 0xa1, 0x07, 0xe9, 0xc2, 0xb4, 0x35, 0x8f, - 0x83, 0xd0, 0x14, 0xca, 0xc2, 0x95, 0x29, 0xd9, 0x28, 0x7c, 0x4f, 0x8e, 0xae, 0xe1, 0x82, 0x96, 0xd0, 0xde, 0xfd, - 0xdb, 0x05, 0x74, 0xf7, 0x98, 0x40, 0x95, 0x78, 0x92, 0x16, 0xca, 0xcd, 0x42, 0x79, 0x4e, 0x81, 0x15, 0x2c, 0x32, - 0xcf, 0xaa, 0xe9, 0x48, 0xb3, 0xd6, 0x8f, 0x4e, 0xe7, 0xba, 0xd5, 0x1a, 0xf6, 0x31, 0x65, 0x41, 0xf1, 0x8e, 0x16, - 0xe6, 0x5f, 0x89, 0x92, 0x23, 0x0d, 0xfe, 0x2f, 0x12, 0xab, 0xa6, 0x19, 0x7c, 0x85, 0xf9, 0x7f, 0x54, 0xb7, 0x26, - 0xde, 0x27, 0x70, 0x05, 0xc2, 0x5d, 0xa9, 0xb6, 0x33, 0xee, 0x18, 0x75, 0xb4, 0x0e, 0x3c, 0x75, 0x62, 0xc6, 0xc3, - 0xe3, 0x62, 0x8b, 0xe1, 0xb7, 0xa7, 0x37, 0xe0, 0xee, 0xb3, 0x63, 0xdd, 0xdd, 0xeb, 0x20, 0xa4, 0x57, 0x66, 0x91, - 0xee, 0xaf, 0x5a, 0x4d, 0x35, 0x21, 0xd6, 0xb5, 0x32, 0xf7, 0xc4, 0x98, 0x0d, 0x86, 0x33, 0x62, 0x7c, 0x76, 0x70, - 0xb3, 0x35, 0x72, 0x77, 0xa4, 0x24, 0x8a, 0x1d, 0x5d, 0x4a, 0x78, 0x02, 0x43, 0x36, 0xac, 0xca, 0xcd, 0xaf, 0xb5, - 0x7a, 0xb5, 0xaf, 0x3e, 0xfb, 0x12, 0x93, 0xf4, 0x8b, 0x1f, 0x52, 0xd8, 0xf1, 0x44, 0x64, 0xab, 0xc3, 0x58, 0x07, - 0x74, 0x1f, 0x6a, 0xfd, 0xf2, 0xba, 0xa1, 0xda, 0x0f, 0xf8, 0x6e, 0x9d, 0x95, 0xe5, 0x57, 0x8b, 0xdf, 0xd6, 0xb7, - 0x07, 0xee, 0x25, 0x83, 0xe2, 0x17, 0xf8, 0x2a, 0x22, 0x03, 0xee, 0x97, 0xd5, 0x9a, 0x4c, 0x8a, 0xe3, 0x27, 0x74, - 0x8c, 0x65, 0x8a, 0xf2, 0x48, 0xd3, 0x76, 0xb7, 0xde, 0xa8, 0xd1, 0xb1, 0xe1, 0x93, 0x9d, 0xa9, 0xcb, 0x07, 0x64, - 0x64, 0x08, 0xdb, 0xff, 0x54, 0x5e, 0x9c, 0x0e, 0x88, 0x36, 0xd8, 0xbf, 0x65, 0x86, 0xd0, 0x3a, 0x6c, 0x26, 0xb5, - 0x1a, 0xc2, 0xb1, 0x1f, 0x56, 0x57, 0xff, 0xbf, 0xf8, 0x52, 0x1a, 0x0d, 0x44, 0x6f, 0xd5, 0x5b, 0x02, 0x25, 0xb0, - 0x5e, 0xed, 0x52, 0xea, 0xaf, 0x4e, 0x61, 0x13, 0xe3, 0xb2, 0xe4, 0x75, 0xed, 0xce, 0xd0, 0xfa, 0x49, 0xab, 0x0d, - 0xb9, 0x7f, 0xda, 0xd0, 0xe3, 0x10, 0x23, 0x29, 0x6b, 0x13, 0x63, 0x86, 0x86, 0x10, 0xb3, 0x45, 0x19, 0x83, 0xbb, - 0xfe, 0x89, 0x44, 0x6d, 0x9c, 0x44, 0x68, 0x38, 0xcf, 0xdb, 0x60, 0xed, 0xd5, 0xdd, 0xd2, 0x14, 0x37, 0xc3, 0x95, - 0xa9, 0x4b, 0xc0, 0x7c, 0x62, 0xf0, 0xc5, 0x0e, 0x16, 0x14, 0xf0, 0x12, 0x74, 0x93, 0x71, 0xd3, 0x10, 0x7d, 0xb0, - 0xf1, 0xe6, 0xcf, 0x3d, 0xc7, 0xfc, 0xcc, 0xb7, 0x83, 0x35, 0xa8, 0x9d, 0x00, 0x27, 0x3a, 0xd0, 0xf5, 0x59, 0xb5, - 0xa4, 0xfa, 0xe6, 0xf0, 0xaf, 0x4d, 0xe5, 0x77, 0xc7, 0x86, 0x6f, 0xb5, 0xb9, 0x00, 0xbc, 0x9e, 0x19, 0x76, 0x08, - 0xb4, 0x06, 0x75, 0x4e, 0x61, 0xdc, 0x5d, 0x40, 0xad, 0x7b, 0x8d, 0xeb, 0x9b, 0x22, 0x42, 0x18, 0xb8, 0x2c, 0xa8, - 0xec, 0xf6, 0x1b, 0xcc, 0x5b, 0xdf, 0x17, 0xa8, 0x01, 0xc2, 0x43, 0x19, 0xda, 0x16, 0x19, 0x77, 0xee, 0x0d, 0x36, - 0x4b, 0x58, 0xe7, 0x52, 0x4e, 0xb9, 0xa6, 0x74, 0x1d, 0xaa, 0x8f, 0x9b, 0xa2, 0x97, 0x18, 0x90, 0x23, 0x88, 0xa5, - 0x9e, 0x01, 0xab, 0x86, 0x8b, 0xf4, 0x32, 0x4d, 0xd2, 0x29, 0x5f, 0x06, 0x88, 0xad, 0xeb, 0x44, 0xa3, 0xfb, 0x6c, - 0x29, 0x0f, 0x3d, 0x88, 0x21, 0x24, 0x24, 0x92, 0x52, 0x50, 0x3f, 0x90, 0x49, 0xb9, 0xfc, 0x0f, 0x2b, 0xf1, 0x2a, - 0x4f, 0xc7, 0x5f, 0x9e, 0x4e, 0x56, 0xd5, 0x83, 0x0f, 0x84, 0x1f, 0xe8, 0xbe, 0x75, 0xbc, 0x56, 0x6b, 0xcf, 0x57, - 0x75, 0x93, 0x1c, 0xfd, 0xc4, 0xbe, 0xe4, 0x1f, 0xb4, 0xa5, 0xce, 0x4d, 0x78, 0x16, 0x57, 0xc2, 0x9a, 0xe9, 0xf2, - 0xe5, 0x3d, 0x54, 0x79, 0x24, 0x69, 0x3c, 0x4d, 0x59, 0x6d, 0x1a, 0xef, 0x66, 0x8a, 0x40, 0x1b, 0x75, 0xf4, 0x0a, - 0x4e, 0x39, 0x70, 0x51, 0x87, 0x45, 0x27, 0xcb, 0x3f, 0x0b, 0x96, 0x85, 0x6e, 0x7f, 0x4b, 0x66, 0x1f, 0x27, 0x5f, - 0x6f, 0xa8, 0x5c, 0x38, 0x91, 0x43, 0x13, 0x4b, 0x5b, 0x6d, 0xc7, 0xe0, 0x4c, 0xdd, 0x79, 0x5c, 0x92, 0xe8, 0x3a, - 0x96, 0xe5, 0x79, 0x45, 0xac, 0xe3, 0xd4, 0x7b, 0x3d, 0x88, 0x90, 0x35, 0x2b, 0x7c, 0xd9, 0x7b, 0xfd, 0xd5, 0xad, - 0xd0, 0x99, 0x82, 0xac, 0x65, 0xcf, 0xa2, 0x18, 0xde, 0x85, 0xbc, 0x8a, 0xe8, 0xcb, 0xa5, 0x90, 0x15, 0x42, 0x59, - 0xc0, 0x56, 0xe9, 0x8f, 0xa3, 0x90, 0x3c, 0x3c, 0x4e, 0xf1, 0x62, 0xe6, 0x1c, 0x29, 0x77, 0x09, 0x61, 0x77, 0xc8, - 0xf2, 0x24, 0x92, 0x7a, 0xed, 0x46, 0xb0, 0x29, 0x31, 0xc5, 0xa6, 0x28, 0x72, 0x83, 0x5d, 0x10, 0x1c, 0x75, 0xab, - 0x6f, 0x34, 0x6d, 0x24, 0x0c, 0x12, 0xf9, 0xce, 0x08, 0xe9, 0x53, 0xdf, 0xdc, 0xbd, 0xe9, 0x07, 0x53, 0xc6, 0x20, - 0x02, 0x1e, 0x45, 0xcb, 0x00, 0xda, 0x9e, 0xaf, 0xd2, 0x2e, 0x19, 0x0f, 0x33, 0x18, 0x71, 0x5b, 0x01, 0xb9, 0x2e, - 0x1a, 0xb7, 0xe1, 0x97, 0xf0, 0x24, 0x51, 0x3c, 0x4d, 0x0b, 0x45, 0x23, 0x52, 0x79, 0x36, 0x24, 0x6b, 0x9e, 0x04, - 0x0b, 0x52, 0x4f, 0x1a, 0xcc, 0x86, 0xc1, 0x62, 0x34, 0x92, 0xb0, 0x4f, 0x4d, 0x86, 0xb1, 0x32, 0xec, 0x1c, 0xfd, - 0x4b, 0x9b, 0xd3, 0x16, 0x6b, 0x53, 0x0b, 0xb5, 0x99, 0xd1, 0x83, 0x19, 0x6f, 0x8c, 0xd4, 0xb0, 0x6a, 0x86, 0xf1, - 0x45, 0xa6, 0x76, 0x3a, 0x65, 0x14, 0x25, 0xc6, 0x69, 0x30, 0x77, 0x0c, 0x39, 0x54, 0x3f, 0x60, 0xb3, 0x82, 0xdc, - 0x55, 0x9d, 0xcd, 0xbd, 0x66, 0xdc, 0x5e, 0xd7, 0x8c, 0x3e, 0xf5, 0x4f, 0xb7, 0xfe, 0x73, 0x99, 0xae, 0xdb, 0xb1, - 0xca, 0x5f, 0xfa, 0x79, 0x37, 0x7d, 0x68, 0x31, 0x6f, 0xca, 0xce, 0x30, 0xc3, 0xeb, 0xcf, 0xa7, 0xc5, 0x83, 0xa2, - 0x81, 0xcd, 0x97, 0x6a, 0xe3, 0x70, 0xfd, 0xfb, 0x81, 0xad, 0xb7, 0xbb, 0xb9, 0x93, 0xa4, 0x21, 0xb6, 0x1c, 0x21, - 0x37, 0x82, 0x63, 0x02, 0xfe, 0xe3, 0x04, 0xf9, 0xdf, 0x3b, 0xf4, 0x6d, 0x7b, 0x10, 0x3e, 0xc6, 0xeb, 0x1e, 0x46, - 0x01, 0x73, 0xd6, 0xb2, 0x5e, 0x7d, 0x1a, 0x57, 0x45, 0xfa, 0x2b, 0x82, 0xfa, 0x8d, 0x23, 0xf8, 0x47, 0x57, 0x25, - 0xbf, 0xd3, 0x65, 0xd4, 0xbe, 0xfb, 0xdc, 0x0f, 0xd6, 0xa8, 0x32, 0x8e, 0xee, 0xcd, 0x69, 0x4b, 0x4a, 0x7b, 0x52, - 0xbe, 0xd5, 0x1e, 0x9e, 0xb6, 0x42, 0x9a, 0xb3, 0x79, 0x4f, 0x2e, 0xe7, 0x51, 0x82, 0x6d, 0x39, 0x8e, 0x70, 0x07, - 0xf9, 0xfa, 0x94, 0x51, 0x3a, 0x7a, 0x97, 0xe5, 0xed, 0xde, 0x04, 0x36, 0xf3, 0xf4, 0x04, 0xcc, 0x68, 0xda, 0x95, - 0x7e, 0xbf, 0x15, 0x27, 0xe6, 0xc3, 0xf6, 0x2e, 0xfb, 0x35, 0xae, 0xb4, 0x00, 0x8f, 0x7b, 0x5f, 0xb5, 0xfd, 0x6b, - 0xdb, 0x43, 0xdc, 0x8c, 0x14, 0x83, 0xb7, 0xf9, 0x2a, 0x4b, 0xa2, 0x02, 0x59, 0xf0, 0x1a, 0xf9, 0x20, 0xb6, 0x05, - 0x20, 0x67, 0xb4, 0x46, 0x2d, 0xfd, 0x8e, 0x25, 0xf1, 0x7c, 0x5b, 0x81, 0x9a, 0xf3, 0xec, 0xac, 0xa2, 0x55, 0x77, - 0xc2, 0x57, 0xa7, 0x9c, 0xa5, 0xd9, 0x85, 0xe8, 0x7a, 0xf8, 0xcc, 0x52, 0x54, 0xb2, 0x6c, 0x78, 0x37, 0xc6, 0xaf, - 0xd8, 0x2b, 0xcf, 0x50, 0xf2, 0xae, 0x94, 0x86, 0x42, 0x41, 0xb6, 0x06, 0xf5, 0xad, 0xb3, 0x97, 0x58, 0xdc, 0x68, - 0x79, 0x94, 0xab, 0xf0, 0xc5, 0xdc, 0xc7, 0xed, 0x71, 0x54, 0x15, 0x73, 0x0e, 0x61, 0x4f, 0x02, 0x3a, 0x69, 0x90, - 0x03, 0xa4, 0xd5, 0x65, 0x11, 0x36, 0x48, 0xa1, 0x5e, 0x8e, 0x7b, 0x94, 0x2b, 0xda, 0x8e, 0x05, 0x64, 0x2c, 0xba, - 0xcb, 0x8c, 0x4c, 0xe7, 0xb1, 0x13, 0xdd, 0x87, 0x2e, 0x17, 0x28, 0x30, 0x58, 0x9f, 0xb5, 0xe4, 0x92, 0xc7, 0x8a, - 0xa3, 0xec, 0x4a, 0x0c, 0x94, 0x67, 0x43, 0xd6, 0x6b, 0x7c, 0xc5, 0x02, 0xac, 0xe9, 0x76, 0x8e, 0x85, 0x0a, 0x96, - 0x7d, 0xff, 0x0b, 0x9f, 0x96, 0x8c, 0x9c, 0xca, 0x24, 0x96, 0xa5, 0x0f, 0x73, 0xe3, 0x86, 0xe0, 0x09, 0x41, 0x33, - 0x49, 0xe6, 0x29, 0xa7, 0x14, 0x4a, 0xeb, 0x7f, 0xae, 0x3c, 0x42, 0xd5, 0x6c, 0xdd, 0xf4, 0x96, 0x71, 0x77, 0x09, - 0x8d, 0xff, 0x21, 0x3a, 0x56, 0x71, 0xc1, 0xfb, 0xf3, 0x44, 0x92, 0x9c, 0x0a, 0x65, 0x2d, 0x9b, 0x17, 0x5b, 0xc8, - 0xa0, 0xe3, 0x96, 0x72, 0x08, 0xe4, 0x00, 0x60, 0x7a, 0xd5, 0x86, 0xba, 0xc6, 0x3e, 0x77, 0xbd, 0x21, 0x21, 0x56, - 0x04, 0xbb, 0xa1, 0x13, 0x24, 0xd4, 0x54, 0x21, 0xf1, 0x59, 0xaf, 0xf2, 0x6e, 0x14, 0x85, 0x1e, 0xf0, 0x8f, 0x7f, - 0x93, 0x88, 0xf3, 0x37, 0x58, 0xaa, 0xdf, 0xb0, 0x4a, 0x1b, 0xfa, 0xe4, 0x5f, 0x24, 0x5e, 0x75, 0xfe, 0x29, 0x66, - 0x9a, 0x6d, 0x87, 0xee, 0x67, 0x7e, 0x3e, 0xe1, 0x51, 0xf6, 0xc2, 0x21, 0x63, 0x0d, 0x19, 0x3a, 0x86, 0x2e, 0x12, - 0x6c, 0xf2, 0x97, 0x14, 0xfa, 0x64, 0x5a, 0xfa, 0x8a, 0xdf, 0x69, 0xdd, 0x9d, 0xad, 0x42, 0x21, 0x16, 0xcc, 0x50, - 0x4a, 0xa3, 0xee, 0x98, 0xea, 0x98, 0x59, 0x98, 0xe3, 0x90, 0x24, 0xa2, 0x45, 0x0e, 0x67, 0xb8, 0xbf, 0x01, 0x08, - 0x81, 0x06, 0x2b, 0x11, 0x2a, 0xca, 0xc5, 0x1e, 0xc1, 0x13, 0x6e, 0xb6, 0xb9, 0xdf, 0xc9, 0x3c, 0x9c, 0x48, 0xa3, - 0x5c, 0xc1, 0x02, 0x30, 0xd5, 0xb3, 0x1b, 0x49, 0xc9, 0xe1, 0x5e, 0xb4, 0xc6, 0xf9, 0x0c, 0x25, 0x94, 0xc5, 0xce, - 0x83, 0x60, 0x5d, 0x65, 0x53, 0xd9, 0x19, 0xcc, 0xaa, 0xee, 0x1c, 0xa8, 0xe2, 0x02, 0x89, 0xba, 0x31, 0x26, 0x53, - 0xcc, 0xb2, 0x19, 0x7e, 0x02, 0x31, 0x6f, 0xc8, 0x54, 0x70, 0xf7, 0x5a, 0x9d, 0x2d, 0xef, 0x1a, 0x26, 0x94, 0xa1, - 0x81, 0xd5, 0x49, 0x8c, 0x1a, 0x96, 0x70, 0x71, 0xc1, 0x67, 0xd0, 0x9f, 0x06, 0x42, 0x33, 0x3a, 0xbd, 0x19, 0xa3, - 0x7e, 0xcb, 0xc6, 0x93, 0xef, 0x15, 0xe7, 0xbd, 0xee, 0xf0, 0x4a, 0x25, 0x54, 0x25, 0x5f, 0x46, 0x88, 0xe8, 0x56, - 0x5f, 0x2a, 0x9e, 0x53, 0xf7, 0xde, 0x2f, 0x24, 0x9e, 0xf4, 0x99, 0x91, 0xc7, 0xfb, 0x5d, 0x28, 0x28, 0x80, 0xde, - 0xb2, 0x08, 0x99, 0x7e, 0x50, 0x56, 0xd5, 0x1d, 0x9e, 0x5c, 0xda, 0x95, 0x50, 0xf1, 0xba, 0x7e, 0xb3, 0x3c, 0x81, - 0x2a, 0x4c, 0x66, 0x28, 0xe6, 0xd8, 0x54, 0x8e, 0xc6, 0x1b, 0x4c, 0x23, 0x18, 0xe7, 0x39, 0xa1, 0x02, 0xfd, 0x50, - 0x25, 0x9a, 0x3a, 0x33, 0x73, 0xc6, 0xf2, 0xba, 0x0f, 0x7b, 0x3e, 0x77, 0x8a, 0xd9, 0x85, 0x57, 0xfb, 0x96, 0x3a, - 0x6e, 0x9f, 0x05, 0x97, 0xe5, 0xee, 0x16, 0x85, 0xec, 0x29, 0x95, 0xc4, 0x38, 0x80, 0x75, 0x1e, 0x5d, 0xd9, 0x9a, - 0x2e, 0x65, 0xb0, 0xfb, 0x13, 0xa4, 0x00, 0x8e, 0x96, 0x0c, 0x24, 0x60, 0x37, 0xf2, 0x6b, 0xd7, 0x64, 0xe6, 0x9b, - 0x8f, 0x03, 0x0b, 0x82, 0xc8, 0x04, 0xce, 0x10, 0x31, 0x91, 0x86, 0xf0, 0xf3, 0x3e, 0xce, 0xbe, 0xda, 0x4c, 0x34, - 0x51, 0x7b, 0x23, 0xe4, 0xf3, 0xf0, 0x1a, 0x76, 0xf3, 0xc0, 0x94, 0xf7, 0x5b, 0x3a, 0x45, 0x1c, 0x34, 0x89, 0xa9, - 0xd5, 0x33, 0xf6, 0x5b, 0xe6, 0x72, 0xc3, 0x2f, 0xc4, 0x14, 0x77, 0x77, 0x71, 0x2a, 0x0c, 0x2c, 0x99, 0xf0, 0xcb, - 0x83, 0xa9, 0x89, 0x29, 0x7b, 0x88, 0xef, 0xfb, 0xf0, 0xe1, 0x71, 0x63, 0xf6, 0xc9, 0x5d, 0x71, 0x9d, 0x58, 0xaa, - 0xb0, 0xaf, 0xe9, 0xeb, 0x21, 0x63, 0x4e, 0x44, 0xd2, 0x52, 0x99, 0xae, 0x0f, 0x36, 0xfe, 0xac, 0x62, 0xc9, 0xca, - 0x11, 0xb6, 0x46, 0x80, 0xf4, 0x4b, 0x83, 0xa6, 0xe1, 0x90, 0x7a, 0x18, 0xfa, 0x40, 0x8a, 0x39, 0xc1, 0xc0, 0xd1, - 0x25, 0x71, 0x6d, 0xeb, 0x70, 0x58, 0x24, 0x3d, 0x96, 0x68, 0xe9, 0xe7, 0x6e, 0x73, 0x7e, 0xb6, 0x07, 0xc7, 0xc2, - 0x65, 0xe5, 0x65, 0x65, 0x5e, 0x78, 0xc6, 0xc9, 0x62, 0xaf, 0x5a, 0x35, 0x7e, 0xe7, 0xf7, 0x7d, 0x2d, 0x99, 0x83, - 0x91, 0x1b, 0x99, 0x2b, 0x5a, 0x78, 0x30, 0xef, 0xe4, 0x15, 0x34, 0x6e, 0xb6, 0x12, 0x87, 0x12, 0xda, 0x7a, 0x70, - 0xea, 0xfd, 0x99, 0x02, 0x57, 0x10, 0x28, 0xbc, 0x7e, 0x3f, 0x1e, 0x6f, 0xc8, 0x68, 0x73, 0x85, 0x0c, 0x7a, 0x6e, - 0xf5, 0x02, 0xd5, 0x79, 0xdf, 0x7c, 0x3e, 0x67, 0x6f, 0xcc, 0xb3, 0xee, 0x63, 0x48, 0x7d, 0x64, 0x88, 0x1a, 0xb2, - 0xbc, 0x16, 0x0a, 0x93, 0x05, 0xf4, 0x38, 0xaa, 0x2a, 0x44, 0x56, 0x87, 0xb2, 0x71, 0x33, 0x54, 0xd8, 0x4f, 0xaf, - 0x7f, 0x80, 0x11, 0x72, 0x94, 0x52, 0x68, 0x4f, 0x4c, 0x55, 0x46, 0x08, 0x81, 0xb1, 0x21, 0x1a, 0x96, 0x91, 0x29, - 0x6c, 0xb3, 0x8a, 0x76, 0x9c, 0xae, 0xec, 0xd6, 0x37, 0xab, 0x14, 0x73, 0xde, 0x0d, 0x9e, 0x25, 0x68, 0xf7, 0xf6, - 0xb6, 0xc7, 0x31, 0xf4, 0x53, 0xf1, 0x3f, 0x82, 0x1d, 0x9d, 0xc3, 0x12, 0x15, 0x9c, 0x12, 0xfb, 0x9c, 0xf9, 0xab, - 0x63, 0x25, 0x8e, 0x7b, 0xda, 0xe2, 0xde, 0x8e, 0x1d, 0x33, 0x2b, 0x3f, 0x36, 0x59, 0x72, 0x2d, 0x43, 0x12, 0xd5, - 0x35, 0x97, 0x8e, 0x41, 0x53, 0x22, 0x37, 0x6f, 0x66, 0x96, 0xf6, 0x06, 0xcc, 0x8f, 0xf6, 0x41, 0xfb, 0x25, 0x21, - 0xc2, 0x6a, 0xa9, 0x99, 0x8b, 0x2f, 0x71, 0xca, 0x38, 0xc9, 0x7d, 0x03, 0xe6, 0xef, 0xc4, 0xf5, 0xef, 0xa2, 0x07, - 0x87, 0x39, 0x02, 0x18, 0x88, 0xb7, 0x52, 0x6d, 0xe5, 0x4d, 0x44, 0x69, 0x05, 0x86, 0x5d, 0x9b, 0xca, 0x86, 0xa3, - 0x21, 0x7f, 0xc3, 0x23, 0xfb, 0x32, 0x5f, 0x6f, 0x6c, 0xa1, 0x38, 0xf1, 0x2e, 0xff, 0xfc, 0xd3, 0x87, 0xe7, 0xc7, - 0x9c, 0x0b, 0x76, 0x73, 0xe3, 0xbc, 0x6a, 0x13, 0xc8, 0xb6, 0x5d, 0x0c, 0x12, 0x9c, 0x42, 0x23, 0x27, 0x40, 0xfa, - 0xe1, 0xc2, 0x22, 0xc4, 0xcf, 0xdf, 0x3d, 0xd9, 0xf5, 0xf6, 0x3a, 0x6c, 0x46, 0xb3, 0xbd, 0x23, 0x1a, 0x41, 0x4e, - 0x57, 0xc7, 0xec, 0xfb, 0xe4, 0x60, 0xfc, 0x4b, 0xe2, 0x7e, 0xa6, 0xca, 0xcf, 0x35, 0xd7, 0x37, 0x55, 0x7e, 0xea, - 0xe0, 0xc6, 0x27, 0xb0, 0x6a, 0x53, 0x72, 0x13, 0xe6, 0xca, 0xad, 0x3e, 0x79, 0x4c, 0x0c, 0xa6, 0xd5, 0x3f, 0x7d, - 0x7f, 0x1a, 0x06, 0x06, 0x17, 0xbb, 0x3b, 0x4f, 0xbe, 0xce, 0xf4, 0xc7, 0x79, 0xdf, 0xb1, 0xfb, 0x3a, 0xf8, 0x71, - 0x5c, 0x5d, 0xd6, 0x23, 0x49, 0x23, 0x07, 0xc4, 0x7b, 0xca, 0xa8, 0x61, 0x2f, 0x77, 0x95, 0x87, 0x55, 0xfd, 0x7d, - 0xd6, 0xbb, 0x44, 0xef, 0x8e, 0x9d, 0x65, 0xad, 0x26, 0x94, 0x17, 0x98, 0xd3, 0x79, 0x4c, 0xb3, 0x42, 0x47, 0x85, - 0x9a, 0x89, 0xf6, 0x32, 0xb2, 0x4a, 0x7f, 0xf3, 0x4b, 0xda, 0xaf, 0x16, 0xc1, 0xb0, 0xac, 0xc2, 0xe5, 0x3c, 0x6a, - 0xb0, 0x59, 0xbb, 0x36, 0x7f, 0xfd, 0xef, 0x69, 0xc3, 0xce, 0x04, 0x51, 0x7d, 0x52, 0x2b, 0x79, 0xd6, 0x77, 0xb8, - 0xea, 0xf6, 0x7c, 0xbe, 0x91, 0x79, 0xaf, 0x9e, 0x2f, 0x9a, 0x8f, 0xb7, 0x5f, 0xbb, 0x07, 0xe0, 0x97, 0x5d, 0x59, - 0xab, 0x37, 0x2b, 0x8b, 0x21, 0xf5, 0x9e, 0xf5, 0x7e, 0x21, 0x53, 0x02, 0x03, 0x52, 0x5f, 0xf8, 0xbc, 0x76, 0x1d, - 0xf4, 0x3a, 0x2a, 0xdd, 0x7e, 0x59, 0xb4, 0x16, 0x85, 0x94, 0x27, 0x92, 0x52, 0x92, 0x4d, 0x5c, 0xc5, 0xcc, 0x30, - 0xcd, 0x3b, 0xbf, 0xa9, 0x27, 0xfd, 0x55, 0x6d, 0xf6, 0xf5, 0xd6, 0x66, 0x6f, 0x08, 0xaf, 0x79, 0x8a, 0xb0, 0x7a, - 0xb7, 0x4e, 0x39, 0x5e, 0xbd, 0xed, 0xf4, 0x2f, 0x5a, 0xfb, 0xf4, 0xbd, 0x5b, 0xc3, 0xd8, 0xa8, 0x9c, 0x15, 0xca, - 0x6f, 0x72, 0x4a, 0xc3, 0x35, 0xa3, 0x0d, 0x1b, 0x61, 0x8a, 0x7d, 0xb9, 0x7a, 0xb7, 0x3a, 0x61, 0x85, 0x48, 0xef, - 0xc1, 0x33, 0xc2, 0xe3, 0xcd, 0x1f, 0x24, 0x54, 0xfd, 0x82, 0x8c, 0xe5, 0x8d, 0xba, 0xb5, 0x68, 0x3c, 0xda, 0x46, - 0xce, 0x24, 0xcc, 0x37, 0xe8, 0xa6, 0xc9, 0x6c, 0x6d, 0xc2, 0xa9, 0x23, 0xb7, 0x49, 0xb1, 0x19, 0xa9, 0x6a, 0xef, - 0x32, 0x98, 0xd2, 0x7d, 0xd2, 0x3e, 0xb1, 0xa7, 0xd4, 0x63, 0xd9, 0x19, 0x62, 0x5a, 0x10, 0xa0, 0xa6, 0x5c, 0xb5, - 0x57, 0x88, 0x65, 0x70, 0x4a, 0x5b, 0x4f, 0xb6, 0xcf, 0x30, 0x5b, 0x34, 0x93, 0x10, 0x9c, 0x15, 0x5a, 0x36, 0xdd, - 0xa4, 0xad, 0x04, 0x2f, 0x23, 0xd5, 0x68, 0xb4, 0x99, 0xe0, 0xb1, 0xf3, 0x5e, 0x34, 0xf3, 0x43, 0x87, 0xb4, 0xb0, - 0x16, 0x25, 0xfc, 0xc2, 0x91, 0x9c, 0xa5, 0x8d, 0xe0, 0xb4, 0x86, 0xee, 0xde, 0x35, 0xaf, 0xb7, 0xf7, 0x23, 0x1f, - 0xd8, 0x78, 0xd3, 0x88, 0x34, 0xc7, 0x7a, 0xc3, 0xbe, 0x09, 0xc6, 0x04, 0x1c, 0x78, 0xe6, 0xe5, 0x2f, 0x9e, 0x00, - 0xe7, 0x07, 0xd8, 0x90, 0x5e, 0xe6, 0xab, 0x8a, 0x60, 0x25, 0xaa, 0x34, 0xe3, 0xc2, 0xec, 0x31, 0xe8, 0xbb, 0x6d, - 0xe9, 0x37, 0xe3, 0xcf, 0x4c, 0x1c, 0xa5, 0x70, 0xf2, 0x9c, 0x6e, 0x2c, 0xdc, 0x43, 0x02, 0xbe, 0x21, 0xab, 0x9e, - 0x78, 0x93, 0xd3, 0xb8, 0xc1, 0xf5, 0x9b, 0x57, 0xb3, 0x13, 0x3e, 0x28, 0xcd, 0x0a, 0x10, 0xb2, 0xeb, 0x50, 0xd9, - 0xf0, 0x32, 0x53, 0x55, 0x7b, 0xad, 0x9c, 0xdc, 0x2f, 0xc4, 0x88, 0x82, 0x52, 0x31, 0x1f, 0x1f, 0xc8, 0x28, 0x8d, - 0xe2, 0xa2, 0xe4, 0xde, 0x43, 0x8a, 0x5d, 0x73, 0xde, 0xd0, 0x29, 0x3f, 0xa7, 0x81, 0xb6, 0x7e, 0x37, 0x14, 0x5e, - 0xfd, 0xee, 0x1e, 0x8d, 0x1d, 0xdc, 0x7a, 0x7a, 0xeb, 0x64, 0xbd, 0xb1, 0xb5, 0xf9, 0x08, 0x39, 0x35, 0x20, 0x7e, - 0x63, 0xc2, 0x1f, 0x7d, 0x7b, 0xa9, 0x29, 0xac, 0xa1, 0xb1, 0x8f, 0x6c, 0x6e, 0xc4, 0x56, 0x78, 0xe3, 0xd4, 0x0a, - 0x5f, 0x82, 0x28, 0x16, 0xe3, 0x17, 0x3f, 0x6b, 0x34, 0xb8, 0xa6, 0x12, 0x1a, 0x0e, 0x09, 0xee, 0x45, 0x91, 0xa7, - 0x9f, 0xba, 0xf8, 0x59, 0x5c, 0xbc, 0x98, 0xaf, 0x86, 0xc4, 0xcc, 0xd3, 0xb6, 0xd2, 0x62, 0xd9, 0xb4, 0x15, 0x3f, - 0x5b, 0x13, 0x0d, 0x77, 0xd1, 0x1a, 0x9f, 0xd5, 0xd8, 0x56, 0x55, 0xaa, 0x1f, 0xca, 0xef, 0x7b, 0x1b, 0x9b, 0x4c, - 0x9d, 0x81, 0x0e, 0x92, 0x86, 0xa4, 0x97, 0x8a, 0x6e, 0x81, 0x8c, 0x3d, 0x3d, 0x26, 0x0d, 0x4b, 0xc4, 0x58, 0x05, - 0xa1, 0x9c, 0x61, 0xd6, 0x8e, 0x72, 0xf3, 0xb0, 0xde, 0x42, 0xaf, 0xd8, 0x6d, 0x4c, 0x7a, 0xea, 0x8d, 0x65, 0x79, - 0xd6, 0xaa, 0xfb, 0x1c, 0x05, 0x14, 0xff, 0x1c, 0xee, 0xc0, 0x1f, 0x6e, 0x0d, 0x9a, 0xbd, 0x51, 0xb9, 0xd8, 0xd4, - 0xeb, 0x10, 0x6f, 0xd2, 0x1d, 0x8f, 0x25, 0x64, 0x21, 0xa2, 0xf1, 0x4d, 0x37, 0x05, 0x0c, 0xcd, 0x54, 0x46, 0x1d, - 0x4b, 0xe3, 0x28, 0xa8, 0x88, 0x15, 0xd9, 0x3b, 0x47, 0xe4, 0x55, 0x41, 0x85, 0x20, 0xad, 0x59, 0x36, 0x09, 0x99, - 0x7f, 0x1a, 0x64, 0x40, 0x49, 0x61, 0x13, 0xfd, 0x69, 0x13, 0x27, 0x85, 0x04, 0xdc, 0xad, 0xec, 0xa2, 0x8b, 0xad, - 0xa9, 0x15, 0xfa, 0x0c, 0x46, 0x5b, 0x70, 0x14, 0xb2, 0x2a, 0x44, 0x0b, 0xcd, 0x7c, 0xc3, 0xbf, 0x45, 0x9e, 0x02, - 0x12, 0x44, 0x41, 0x13, 0x0e, 0x65, 0x37, 0xdd, 0x41, 0x8a, 0x74, 0xf4, 0x10, 0xc1, 0x07, 0xa4, 0x84, 0x0a, 0xd0, - 0x79, 0x1e, 0xd7, 0xdd, 0x4b, 0x4d, 0x23, 0x2a, 0x23, 0x1b, 0x7c, 0x4f, 0x07, 0x45, 0xae, 0x57, 0xac, 0xf4, 0xff, - 0x1f, 0x79, 0x2c, 0xe5, 0x05, 0xec, 0x50, 0xc0, 0x9b, 0x0f, 0xd8, 0x42, 0x8a, 0x43, 0xad, 0x9e, 0x2f, 0x28, 0x51, - 0x1c, 0x49, 0x34, 0xbd, 0xaf, 0x68, 0xa7, 0x47, 0x8c, 0x32, 0xf1, 0xe1, 0x24, 0x50, 0xb7, 0xcd, 0xad, 0xba, 0x64, - 0xb8, 0xba, 0xca, 0xda, 0x7f, 0x3a, 0xec, 0xab, 0xa9, 0x82, 0x0b, 0x3b, 0xbd, 0xb8, 0x83, 0x60, 0x0a, 0x85, 0x1e, - 0x3b, 0x7f, 0x87, 0x89, 0xca, 0xea, 0x2f, 0x24, 0x52, 0xac, 0x5a, 0x2e, 0x43, 0x03, 0x1c, 0xc4, 0x4d, 0x81, 0xda, - 0x11, 0x0c, 0x7a, 0xc6, 0x2e, 0x41, 0x1a, 0xcb, 0x72, 0x49, 0x65, 0x38, 0x69, 0xa5, 0xd5, 0xe7, 0x93, 0x23, 0xe4, - 0x31, 0xde, 0x49, 0xad, 0x12, 0x15, 0x9c, 0x3d, 0x96, 0x65, 0x6d, 0xd4, 0x73, 0xd8, 0x8c, 0xce, 0xb2, 0x8a, 0x5a, - 0xe7, 0xda, 0x6a, 0xa7, 0x14, 0x4a, 0x75, 0x2c, 0x08, 0x36, 0x2d, 0x1c, 0x0f, 0xd2, 0xc2, 0x0e, 0xf4, 0x74, 0x42, - 0x8d, 0x4b, 0x9a, 0x1d, 0x52, 0x91, 0x77, 0x8b, 0x8e, 0xd0, 0x4c, 0xa7, 0x1b, 0x74, 0x53, 0x1e, 0x2b, 0x82, 0x3a, - 0x98, 0xd9, 0x11, 0x86, 0x57, 0x87, 0x61, 0x3c, 0x47, 0x5f, 0x52, 0x36, 0xc4, 0xca, 0x15, 0xb7, 0xb3, 0x36, 0xa5, - 0x83, 0xb7, 0x0a, 0x3f, 0x34, 0x8f, 0xca, 0xc4, 0xe2, 0xa8, 0x58, 0xa1, 0xc4, 0x35, 0xcd, 0x68, 0x8b, 0xab, 0xa5, - 0x9b, 0x18, 0x23, 0xe4, 0x2b, 0xe6, 0xaf, 0x91, 0x32, 0xcc, 0x0d, 0x64, 0x0d, 0xd2, 0x45, 0x32, 0xc5, 0x2c, 0x4c, - 0x90, 0x71, 0xc0, 0x98, 0xf8, 0x3e, 0x5b, 0x5c, 0xfa, 0x33, 0x70, 0x85, 0x63, 0x36, 0xad, 0xa4, 0xfb, 0x10, 0x14, - 0xba, 0xef, 0xf1, 0xa0, 0x41, 0x3d, 0x76, 0x10, 0x3d, 0x53, 0x70, 0xf9, 0x5c, 0x62, 0xa3, 0x7e, 0x6f, 0xd8, 0xd9, - 0x11, 0x8a, 0xcd, 0x86, 0x04, 0x03, 0xcc, 0x27, 0x4a, 0xf7, 0x3e, 0xf8, 0xd0, 0xd2, 0x2f, 0x5f, 0xdf, 0x22, 0x84, - 0x0c, 0xe5, 0x4e, 0x94, 0x9a, 0x29, 0x81, 0x8a, 0xa6, 0xe6, 0xa0, 0x99, 0x0f, 0x4e, 0xdc, 0xed, 0xf0, 0x7a, 0x42, - 0x2f, 0x57, 0xbb, 0x75, 0x4f, 0xe5, 0xe5, 0x8a, 0x34, 0x42, 0xab, 0x4f, 0x1b, 0x95, 0x0f, 0xe6, 0xb1, 0xb8, 0x5e, - 0xe9, 0xae, 0x1f, 0xb8, 0x43, 0xab, 0xdd, 0xc5, 0x87, 0xd2, 0x32, 0x3e, 0xd4, 0x93, 0xac, 0xd7, 0x60, 0x11, 0x78, - 0xa8, 0xb1, 0x14, 0xcd, 0xf1, 0x26, 0xeb, 0xd9, 0x60, 0x53, 0xa3, 0xd9, 0x58, 0x4a, 0xcb, 0xdf, 0xdb, 0xb8, 0x5f, - 0x67, 0x53, 0x85, 0xd2, 0x87, 0x81, 0xf4, 0x3e, 0x81, 0x92, 0x39, 0x0a, 0xdd, 0xe9, 0x0c, 0x95, 0x8f, 0xe6, 0x09, - 0x30, 0x56, 0xf0, 0x8b, 0x4b, 0x1a, 0xd3, 0x59, 0x73, 0x9c, 0xaf, 0xe0, 0xd4, 0xe2, 0xa8, 0xb1, 0x75, 0xe9, 0x89, - 0x20, 0xbc, 0x5a, 0xdc, 0x12, 0xbd, 0x24, 0xe9, 0xa8, 0x23, 0x25, 0xfe, 0x53, 0x8c, 0x73, 0xaa, 0xa9, 0xa3, 0x9d, - 0x4d, 0xe3, 0x0d, 0x15, 0x9c, 0x01, 0x35, 0x39, 0x6c, 0xfb, 0x12, 0x0a, 0xe0, 0xff, 0x9d, 0xa6, 0x12, 0xf1, 0x32, - 0x11, 0x37, 0xab, 0x0a, 0x65, 0x40, 0x19, 0x01, 0x94, 0x5f, 0xab, 0x91, 0xd1, 0x37, 0x7e, 0x34, 0x51, 0x9f, 0xc7, - 0x98, 0x03, 0x1d, 0xb4, 0x34, 0xf9, 0x1b, 0x38, 0x22, 0xd9, 0x36, 0xc7, 0x66, 0x06, 0x55, 0x5b, 0x3c, 0x09, 0xbc, - 0x44, 0x34, 0x56, 0xb3, 0x7e, 0x8c, 0xdf, 0xa6, 0x73, 0x3f, 0x78, 0xeb, 0x00, 0xfc, 0xc2, 0x82, 0x6a, 0x67, 0xd6, - 0xea, 0x7b, 0x09, 0x1a, 0xf0, 0xa3, 0xd8, 0xe8, 0x2c, 0x75, 0x42, 0xcd, 0xc9, 0x0e, 0xbd, 0xa9, 0xc9, 0x39, 0x27, - 0xca, 0x9e, 0x4e, 0x66, 0x1c, 0x85, 0x43, 0xd4, 0x19, 0x71, 0xf2, 0xa9, 0xf7, 0xcd, 0x8c, 0x78, 0xf4, 0x89, 0x8b, - 0x84, 0x43, 0x70, 0x4e, 0x15, 0x5b, 0x36, 0x9b, 0x8b, 0xd8, 0xfc, 0x4c, 0x8a, 0x4d, 0xc6, 0x04, 0xab, 0x05, 0xbd, - 0xbf, 0x21, 0x12, 0xc2, 0xb4, 0x21, 0x24, 0x4b, 0x53, 0x93, 0x1a, 0x8f, 0x9b, 0xab, 0x60, 0x33, 0xba, 0xc4, 0xfc, - 0x73, 0x75, 0x41, 0xa1, 0xf0, 0x8a, 0x82, 0x9f, 0xd7, 0x70, 0xec, 0x35, 0xc2, 0xd8, 0x33, 0x24, 0xfa, 0xd0, 0x0e, - 0x9a, 0x19, 0xc9, 0x2d, 0xa6, 0xf6, 0x64, 0x47, 0xe0, 0x95, 0x97, 0x21, 0xdd, 0xb0, 0xdf, 0x04, 0x94, 0xc0, 0x6b, - 0xea, 0x9b, 0xe5, 0x50, 0xe6, 0x70, 0x39, 0xdd, 0xd5, 0x6f, 0x80, 0xc6, 0xce, 0x16, 0x1e, 0xa6, 0x68, 0x1d, 0xaa, - 0x7d, 0x48, 0x5d, 0x3d, 0xb3, 0x57, 0x31, 0x47, 0x39, 0x08, 0xea, 0xc6, 0x6c, 0x13, 0xfb, 0x3a, 0x75, 0x5d, 0x03, - 0xf5, 0x7b, 0xec, 0x67, 0xa0, 0xf5, 0x30, 0xd2, 0x6c, 0x1d, 0x4f, 0xe9, 0x2d, 0x12, 0x46, 0x5b, 0x4a, 0x24, 0x0d, - 0x93, 0x66, 0x4d, 0x6a, 0x00, 0xd3, 0x22, 0xcc, 0x41, 0xfd, 0x46, 0xef, 0xd8, 0x53, 0xc2, 0x74, 0x96, 0x6d, 0xd7, - 0xa8, 0x6c, 0x92, 0x3b, 0xce, 0x15, 0x3a, 0x09, 0x29, 0x15, 0x65, 0x5f, 0x32, 0x05, 0xa9, 0x3c, 0x26, 0x9c, 0xe3, - 0x6a, 0x40, 0x32, 0x4c, 0xa9, 0xa0, 0xf6, 0xd6, 0x59, 0x4a, 0x5d, 0x72, 0xe6, 0x08, 0x9f, 0x62, 0xf9, 0xb3, 0xaa, - 0x79, 0xd8, 0x54, 0x63, 0x38, 0xed, 0xd5, 0xcb, 0xc5, 0x82, 0x07, 0xf3, 0x27, 0x70, 0x01, 0x45, 0xbe, 0xa2, 0xa6, - 0x3c, 0x97, 0x87, 0x72, 0x12, 0x7d, 0x32, 0xfe, 0x3d, 0xd5, 0x2d, 0x88, 0x5c, 0xe6, 0x33, 0x44, 0x66, 0xfa, 0x8d, - 0xfb, 0xea, 0xc3, 0x72, 0xb0, 0xa9, 0x24, 0xa6, 0x7f, 0x3f, 0x79, 0xb7, 0x42, 0x19, 0x7e, 0xe8, 0x89, 0x6d, 0xd1, - 0x52, 0xd0, 0xb3, 0xc8, 0xa8, 0xc2, 0x1c, 0x91, 0x13, 0x25, 0x70, 0x96, 0x3d, 0x4a, 0xf0, 0x92, 0x1a, 0x3a, 0x42, - 0x5b, 0x10, 0x27, 0xac, 0xa8, 0x1c, 0xc9, 0xb3, 0xbf, 0x55, 0xf5, 0x92, 0xea, 0x94, 0xc7, 0x80, 0xd5, 0x5f, 0x7b, - 0xa8, 0xbe, 0xbe, 0xb7, 0x41, 0x04, 0x5b, 0xd0, 0xea, 0x71, 0xf8, 0x12, 0xc0, 0x41, 0x30, 0x59, 0x20, 0x53, 0x1e, - 0x53, 0x43, 0xf5, 0xaa, 0x6f, 0x4f, 0x8e, 0x42, 0xde, 0x80, 0x22, 0xdc, 0x12, 0x4f, 0xa7, 0xa7, 0x71, 0x29, 0x6e, - 0x3f, 0x95, 0xfe, 0x81, 0x2f, 0xc0, 0xae, 0x55, 0x0a, 0x1e, 0x60, 0x4a, 0xc2, 0x1b, 0x99, 0x0a, 0x6b, 0xf9, 0xa6, - 0xd3, 0x9b, 0x97, 0x3c, 0xc6, 0x43, 0xb8, 0xb7, 0x3b, 0x70, 0xd6, 0x57, 0xef, 0x35, 0x9a, 0xca, 0xc0, 0xc5, 0x14, - 0x6d, 0x38, 0x3a, 0xc0, 0xe5, 0x1c, 0x61, 0x59, 0xdd, 0x7d, 0x38, 0xa3, 0x54, 0x06, 0x91, 0x32, 0x3a, 0xec, 0xaa, - 0xb4, 0x98, 0xf4, 0xd8, 0x62, 0x16, 0xf2, 0x3e, 0xc5, 0x19, 0x61, 0x13, 0x51, 0x4c, 0x13, 0x7d, 0x58, 0x04, 0xe2, - 0x19, 0x18, 0xdd, 0xae, 0x5d, 0x3f, 0x90, 0xec, 0x0d, 0x43, 0x28, 0xbf, 0x54, 0xee, 0x52, 0xbb, 0xae, 0xba, 0x00, - 0x96, 0xef, 0xc2, 0x7c, 0x42, 0x90, 0xa7, 0xaf, 0x38, 0xac, 0xab, 0xdf, 0xca, 0xcc, 0x46, 0x6e, 0xac, 0x6e, 0x85, - 0x4e, 0x2e, 0xdc, 0xd6, 0x2b, 0x1d, 0xe8, 0x4c, 0x40, 0xc2, 0x07, 0xcf, 0xbe, 0x8f, 0xb6, 0x91, 0x4a, 0x32, 0x57, - 0xdc, 0x73, 0xde, 0x5b, 0x10, 0x56, 0x0f, 0x64, 0x3d, 0x22, 0x17, 0x24, 0xe8, 0x05, 0x1c, 0xcf, 0xe7, 0xd1, 0xa9, - 0x79, 0xc5, 0xde, 0x28, 0x9f, 0x18, 0x96, 0xb8, 0x99, 0x9b, 0x4f, 0x87, 0xa7, 0x88, 0xf4, 0x7d, 0x8c, 0x84, 0x83, - 0x30, 0x24, 0x55, 0xde, 0xbc, 0x91, 0x50, 0xc4, 0x53, 0xc9, 0xce, 0xb8, 0xdc, 0x9c, 0xd5, 0x88, 0xc5, 0xa5, 0x28, - 0xaf, 0x5e, 0x3b, 0x8a, 0xf2, 0x8e, 0xad, 0x5a, 0xd2, 0xce, 0xf6, 0x95, 0x32, 0xb6, 0x2a, 0x71, 0x44, 0x23, 0xa3, - 0x13, 0xb7, 0x7a, 0x51, 0x2a, 0x87, 0xac, 0x91, 0xb2, 0x81, 0x75, 0x65, 0x32, 0x0b, 0xca, 0xc3, 0xca, 0xf9, 0x22, - 0xee, 0xd8, 0x2e, 0x82, 0x56, 0xa1, 0xb0, 0x74, 0x50, 0x2f, 0x28, 0x7a, 0x3f, 0x00, 0x5b, 0x27, 0xf9, 0xdb, 0x52, - 0x74, 0xf1, 0x3d, 0x74, 0x95, 0x5d, 0xd0, 0x81, 0x30, 0x1e, 0x25, 0x69, 0x18, 0x18, 0xc8, 0x37, 0x0f, 0xb6, 0x23, - 0xd0, 0xe5, 0xf5, 0xf6, 0xa8, 0xa4, 0xd3, 0x29, 0xc8, 0x29, 0x03, 0xc0, 0x34, 0x51, 0x58, 0x5d, 0xad, 0x31, 0xfb, - 0xbb, 0xe3, 0xe2, 0x57, 0xc7, 0xae, 0x15, 0xcc, 0xf0, 0x41, 0xd8, 0xcd, 0xbd, 0xab, 0xad, 0xc1, 0x17, 0xa7, 0x8e, - 0x99, 0x58, 0x98, 0x95, 0x96, 0x3f, 0xaf, 0x37, 0xb3, 0x7f, 0x74, 0x7d, 0x4c, 0xe1, 0x03, 0x3d, 0x8e, 0x5d, 0x8b, - 0xda, 0x47, 0xf1, 0xbc, 0x94, 0xf8, 0xc2, 0xef, 0x25, 0x8f, 0x9b, 0xa1, 0xaf, 0xbe, 0x86, 0x39, 0x0c, 0xad, 0x58, - 0x1b, 0xa9, 0xfc, 0x02, 0x9b, 0xde, 0x84, 0x3b, 0x71, 0xc4, 0x80, 0x73, 0x3d, 0x47, 0x9a, 0xf9, 0xcc, 0x64, 0xeb, - 0x99, 0xa4, 0xd1, 0x30, 0x1d, 0x89, 0x38, 0x6a, 0x01, 0x2a, 0x3e, 0x71, 0x70, 0x7f, 0x78, 0xc0, 0x48, 0x71, 0x18, - 0xa3, 0x1f, 0x8b, 0x7c, 0x9b, 0x12, 0xcb, 0x86, 0xaf, 0xe0, 0xb9, 0x66, 0x97, 0x3f, 0xd8, 0x6f, 0x8d, 0x8b, 0x55, - 0x8f, 0x95, 0x41, 0xbc, 0x9c, 0xae, 0xd9, 0x1b, 0x94, 0xb1, 0x3a, 0x8f, 0xb0, 0xdc, 0x9b, 0xcc, 0xe6, 0xcc, 0x05, - 0x72, 0x12, 0xa8, 0xde, 0xe8, 0xe6, 0x97, 0x22, 0xba, 0xd5, 0xae, 0xc1, 0x39, 0x3f, 0x33, 0xdf, 0xa3, 0x48, 0xfc, - 0xe4, 0x47, 0x5d, 0x32, 0xcb, 0xd6, 0x09, 0x74, 0xb2, 0xec, 0xca, 0x8d, 0xef, 0xb6, 0xbe, 0x78, 0xb7, 0xbe, 0xb0, - 0xfe, 0x44, 0x86, 0xf3, 0x4b, 0x72, 0xf7, 0xf8, 0x27, 0xd6, 0x41, 0x6c, 0xfd, 0xe7, 0x2f, 0x94, 0xfc, 0x4f, 0xa9, - 0x71, 0xe7, 0x8f, 0x9d, 0x21, 0x54, 0x8c, 0x50, 0xe3, 0x0d, 0xc6, 0x82, 0x73, 0x77, 0xa4, 0x64, 0xdd, 0x8c, 0x71, - 0x5a, 0x49, 0x59, 0x03, 0xf7, 0x95, 0x26, 0xa7, 0x55, 0x6e, 0xaf, 0x05, 0x31, 0xbb, 0x34, 0xb5, 0x43, 0x81, 0x4f, - 0x7d, 0x26, 0x65, 0x49, 0x72, 0x9d, 0xf2, 0xec, 0x1f, 0xa9, 0xed, 0x08, 0x60, 0xae, 0x7e, 0x05, 0x10, 0x8c, 0xf3, - 0xe5, 0xee, 0x5a, 0xe9, 0xa9, 0xcf, 0x60, 0x54, 0x8f, 0xbc, 0xf4, 0x2a, 0x5f, 0x16, 0x71, 0xa5, 0x1b, 0xe5, 0x3b, - 0x5c, 0xc2, 0x46, 0xb4, 0x78, 0xf7, 0xd2, 0x6b, 0x85, 0xbc, 0xa3, 0x7c, 0x50, 0x55, 0x39, 0x8c, 0x8a, 0xe6, 0xab, - 0x9b, 0x12, 0x2e, 0xb3, 0x77, 0xb0, 0xc9, 0x26, 0x1d, 0x74, 0x16, 0x6c, 0xc9, 0x04, 0x89, 0xc4, 0xb0, 0xec, 0x90, - 0x90, 0xab, 0xb4, 0x6f, 0xf0, 0x32, 0x54, 0xa7, 0x3a, 0xa7, 0xe8, 0xa7, 0x1d, 0x2f, 0xe9, 0x88, 0x69, 0xa1, 0x2d, - 0xd2, 0x11, 0xa5, 0x03, 0x63, 0xcc, 0x78, 0x85, 0x54, 0x35, 0x30, 0xbc, 0x56, 0x13, 0x4f, 0xb1, 0xbc, 0xf6, 0xe0, - 0x31, 0x91, 0x09, 0x62, 0xdf, 0xc2, 0xd5, 0x46, 0x1c, 0xdc, 0xc8, 0xf2, 0x5a, 0xb9, 0x0a, 0xaf, 0xee, 0xe1, 0x59, - 0xdb, 0x99, 0x7c, 0x48, 0x28, 0x90, 0x58, 0xe6, 0x17, 0x3a, 0x7e, 0xad, 0xa7, 0xbb, 0xe2, 0x25, 0xda, 0x65, 0x07, - 0x48, 0x53, 0x4b, 0xbc, 0x9c, 0xbe, 0xcb, 0x5e, 0x99, 0xd5, 0x4b, 0x4d, 0x1a, 0xdd, 0x42, 0xba, 0xf6, 0x08, 0xf1, - 0x30, 0x1f, 0x0a, 0x76, 0x5f, 0x92, 0x06, 0xe8, 0x0a, 0xb3, 0x5b, 0xfc, 0xa5, 0x8d, 0x0b, 0xf7, 0xe1, 0xa3, 0x88, - 0x48, 0xf4, 0x25, 0xbf, 0x16, 0x2f, 0xfe, 0x93, 0xef, 0x48, 0xc0, 0xe8, 0x22, 0x3e, 0xc9, 0xed, 0x07, 0x56, 0x45, - 0x97, 0x09, 0xcd, 0xfd, 0xe2, 0x34, 0x81, 0xd9, 0x0d, 0xf4, 0xe2, 0x26, 0xf3, 0x35, 0xdd, 0x5d, 0x69, 0xea, 0xde, - 0x1f, 0x8e, 0x55, 0x1d, 0xb5, 0xf9, 0xd2, 0x53, 0x77, 0x93, 0xed, 0x75, 0x8d, 0x4b, 0xdd, 0x42, 0x4d, 0xba, 0x62, - 0x6b, 0x6d, 0x51, 0x9f, 0xa6, 0x79, 0x6f, 0x56, 0xfe, 0x55, 0xb6, 0x75, 0x03, 0xb8, 0x5e, 0x88, 0x75, 0xcd, 0x46, - 0x4d, 0x90, 0xb2, 0xd4, 0x85, 0x68, 0xdf, 0xb8, 0x01, 0x68, 0xb1, 0x86, 0x75, 0x9d, 0x2a, 0xd3, 0x79, 0x9a, 0x8f, - 0x26, 0x04, 0x7d, 0x1f, 0x07, 0x97, 0xf2, 0x46, 0xff, 0x8a, 0x46, 0xad, 0xea, 0xf3, 0xcd, 0x73, 0x1e, 0x9d, 0x08, - 0x6f, 0x1c, 0xd0, 0x2e, 0x8d, 0x11, 0x2f, 0x3d, 0xfd, 0x4c, 0xf9, 0xd2, 0x8d, 0x51, 0x60, 0xbc, 0x00, 0x79, 0x3d, - 0xf4, 0xcb, 0x8d, 0x74, 0x81, 0x5e, 0x55, 0x46, 0x19, 0x5f, 0xdc, 0xcf, 0xbc, 0x7e, 0x25, 0x3e, 0xa0, 0x7c, 0x83, - 0x20, 0x54, 0x58, 0x56, 0x71, 0xc8, 0x20, 0x03, 0x7c, 0xdd, 0xa2, 0x5f, 0x46, 0xbf, 0x68, 0x73, 0x1e, 0xe6, 0x45, - 0xac, 0xbc, 0x39, 0xfc, 0x66, 0x78, 0x79, 0xf5, 0xbc, 0x1e, 0xf3, 0x03, 0xd9, 0xdb, 0xb5, 0xd2, 0x8e, 0x51, 0x3a, - 0x38, 0xc4, 0xae, 0x70, 0x9d, 0x02, 0x30, 0x2a, 0x41, 0xc7, 0x41, 0x54, 0x40, 0x5b, 0xfb, 0x81, 0xd4, 0x8a, 0x32, - 0x52, 0x90, 0x56, 0x6b, 0x38, 0x83, 0xb4, 0x03, 0x4a, 0xb6, 0x4d, 0xb3, 0x18, 0x99, 0x9d, 0x47, 0xba, 0xab, 0x8e, - 0xd3, 0xa2, 0xc1, 0x8b, 0xb3, 0x32, 0x31, 0xee, 0x51, 0x92, 0xab, 0xa4, 0x71, 0x63, 0x78, 0x79, 0xf3, 0x46, 0xa4, - 0x1b, 0xf7, 0x87, 0x4b, 0xae, 0x6e, 0xd9, 0xb9, 0x04, 0xa7, 0x37, 0xbf, 0x04, 0xe2, 0xe3, 0xa6, 0xf9, 0xda, 0x47, - 0x02, 0xee, 0x3f, 0x97, 0x80, 0xbb, 0x62, 0xf2, 0x32, 0x9b, 0xc0, 0xe0, 0x47, 0xe3, 0x9c, 0x69, 0xf0, 0x03, 0x63, - 0xcf, 0x85, 0x5e, 0x0b, 0x18, 0xfc, 0xa8, 0x23, 0x5e, 0xa3, 0x96, 0x90, 0x0e, 0xa3, 0xd2, 0xf7, 0xc4, 0xd8, 0xa0, - 0x3d, 0x32, 0xdd, 0xeb, 0xe0, 0xc6, 0x10, 0x22, 0x2f, 0x4c, 0xa1, 0x70, 0x04, 0xc0, 0xf9, 0xff, 0x0a, 0x92, 0xe6, - 0x9b, 0x43, 0xe1, 0x02, 0xe4, 0xb9, 0xd6, 0x8d, 0x48, 0x87, 0x4e, 0x2c, 0x63, 0xd8, 0x11, 0x33, 0x66, 0x63, 0xa6, - 0xaa, 0xe8, 0x31, 0x27, 0xce, 0x00, 0xca, 0x86, 0xaf, 0xc1, 0xd7, 0x36, 0x03, 0x13, 0xa2, 0x2a, 0x82, 0xc1, 0xbb, - 0xb7, 0xb0, 0x11, 0x74, 0x36, 0x25, 0x46, 0x34, 0x54, 0x43, 0x93, 0xaf, 0xf2, 0x62, 0x3b, 0xa1, 0xb1, 0x3f, 0x06, - 0x99, 0xac, 0x7e, 0xfa, 0xcc, 0x70, 0x1f, 0xeb, 0xf7, 0x3b, 0xd1, 0x56, 0x98, 0x14, 0xe4, 0xd3, 0x96, 0xa5, 0x73, - 0xe9, 0xc5, 0x25, 0x78, 0x69, 0xfa, 0xa6, 0xe6, 0x60, 0x7d, 0x99, 0x83, 0x2c, 0xa7, 0xfe, 0x3c, 0x98, 0x3b, 0x48, - 0x30, 0x75, 0x9e, 0x16, 0x01, 0x2e, 0x21, 0xa2, 0xf4, 0x5c, 0x66, 0x04, 0x36, 0x93, 0x87, 0x99, 0x6c, 0xae, 0xb0, - 0x78, 0x7e, 0xa4, 0x99, 0x9b, 0x51, 0xa1, 0xd7, 0xfd, 0xfc, 0xee, 0xa3, 0x34, 0xfb, 0xba, 0x3c, 0x8e, 0xbb, 0x5b, - 0xcd, 0x19, 0x88, 0xaa, 0x9d, 0xd2, 0x83, 0x5f, 0x64, 0x1d, 0xd8, 0xdb, 0xd6, 0xf4, 0xed, 0xe3, 0x9f, 0x7e, 0xe9, - 0x90, 0x4c, 0x9d, 0xdb, 0xd0, 0x59, 0x74, 0xfa, 0x7e, 0x8f, 0x91, 0x36, 0x5b, 0xe1, 0x88, 0x81, 0xca, 0x53, 0x43, - 0x36, 0xa9, 0x37, 0x71, 0x82, 0x1b, 0x1f, 0x91, 0xaa, 0x4d, 0x7f, 0x03, 0x8f, 0xf5, 0xc3, 0x8f, 0xe6, 0x4e, 0xd5, - 0xed, 0x85, 0xef, 0xdb, 0x3b, 0xa1, 0xdd, 0x3c, 0xbe, 0x56, 0xaf, 0xcd, 0xfb, 0xce, 0x48, 0x5d, 0x50, 0xf4, 0xbc, - 0xf6, 0xbf, 0x52, 0x33, 0x0e, 0xde, 0x36, 0xf7, 0x89, 0x81, 0x6f, 0xc7, 0xe7, 0x31, 0xcf, 0x80, 0xac, 0x65, 0x16, - 0x2d, 0x8d, 0x5c, 0xe3, 0x1a, 0x07, 0x94, 0x15, 0xe2, 0x8a, 0x66, 0xaa, 0x8d, 0x87, 0xa8, 0xeb, 0x1d, 0x2f, 0x67, - 0x2b, 0x5c, 0xdc, 0x62, 0x5a, 0xc5, 0x37, 0x71, 0xe1, 0xec, 0xe6, 0x99, 0xe2, 0x2a, 0x9b, 0x53, 0x75, 0x91, 0xe9, - 0x77, 0x41, 0x57, 0x1d, 0x06, 0xc1, 0x66, 0xd2, 0x87, 0xeb, 0xce, 0x43, 0x17, 0x6e, 0x5c, 0x0c, 0x0f, 0x01, 0xa9, - 0xb4, 0x9c, 0x40, 0x01, 0x63, 0x5b, 0xdc, 0x50, 0x96, 0x38, 0xbe, 0xfe, 0xf9, 0xc0, 0xc3, 0x00, 0xf0, 0x8d, 0x3d, - 0xc4, 0xc4, 0x6c, 0x65, 0x33, 0xcd, 0x09, 0x3f, 0xc3, 0x40, 0x8e, 0x2b, 0xef, 0x34, 0x6e, 0x87, 0xff, 0x33, 0x36, - 0x11, 0x29, 0xa0, 0x49, 0x2c, 0x2c, 0x64, 0xa6, 0xed, 0x14, 0x7d, 0xa2, 0x10, 0xba, 0x62, 0x29, 0x1f, 0x5c, 0xe6, - 0xe0, 0xbb, 0xd6, 0x7b, 0x5f, 0x57, 0x7e, 0x7d, 0x10, 0xb4, 0x54, 0x4d, 0xb0, 0x96, 0x14, 0x0a, 0x49, 0x60, 0xed, - 0x48, 0xa7, 0xf5, 0xb5, 0x1d, 0x28, 0x28, 0x59, 0x16, 0x44, 0xd2, 0xf9, 0x5a, 0x3b, 0xa4, 0x4e, 0xc5, 0x5f, 0xf8, - 0x6f, 0x3f, 0x4d, 0xe0, 0xd7, 0x56, 0xc4, 0x40, 0x7d, 0x1d, 0x5f, 0x77, 0x5f, 0x45, 0xbb, 0x21, 0x6d, 0xd5, 0x8f, - 0xa9, 0xb2, 0x99, 0x91, 0xf2, 0x7e, 0xac, 0xfe, 0xfc, 0xd9, 0x86, 0xa1, 0x69, 0xe2, 0x78, 0x78, 0x73, 0x33, 0x77, - 0x98, 0x29, 0x9f, 0x43, 0xaf, 0x36, 0x56, 0xdf, 0x00, 0x6c, 0x91, 0x93, 0xda, 0x35, 0x51, 0x30, 0xc1, 0x34, 0xd9, - 0x44, 0xdf, 0x3d, 0x52, 0x92, 0x98, 0xb5, 0x47, 0xa1, 0x77, 0x97, 0x32, 0x2d, 0x5a, 0xaa, 0xb9, 0x1a, 0x0b, 0x65, - 0x3a, 0xa9, 0x18, 0x6c, 0x6a, 0xfc, 0xd9, 0x95, 0xf3, 0x99, 0x53, 0x10, 0x79, 0xb1, 0xe1, 0x91, 0xeb, 0x73, 0xc8, - 0xc3, 0xad, 0x7c, 0xd5, 0xe7, 0xe7, 0xf6, 0xc2, 0x2b, 0xde, 0xeb, 0xbd, 0x72, 0x1d, 0x6a, 0xe9, 0x31, 0xcf, 0x8b, - 0xba, 0x5f, 0x96, 0x6b, 0x1c, 0x18, 0x50, 0x3b, 0x01, 0xc6, 0xb9, 0x88, 0x02, 0x0c, 0xf0, 0x4a, 0xba, 0x67, 0x24, - 0x3d, 0x9e, 0xc5, 0x25, 0xfa, 0x91, 0xa1, 0x9a, 0xa7, 0xcd, 0x4b, 0x40, 0x94, 0x2a, 0x3b, 0xce, 0x2d, 0x9d, 0x4c, - 0xb3, 0xa8, 0x2d, 0xbd, 0x33, 0x9d, 0x46, 0xf9, 0xbe, 0x02, 0x80, 0xf4, 0x9d, 0x7e, 0xe4, 0x4c, 0x87, 0x72, 0x73, - 0x80, 0x70, 0xa3, 0x64, 0xc6, 0x8d, 0x89, 0xc2, 0xf3, 0x13, 0x03, 0x22, 0x84, 0xb8, 0x1a, 0xf8, 0xca, 0x4b, 0xda, - 0x27, 0x2a, 0x42, 0x43, 0xfc, 0x80, 0x1e, 0xdc, 0x87, 0x5b, 0xfb, 0xf7, 0x7e, 0x50, 0x55, 0x72, 0xb0, 0x0c, 0x25, - 0x46, 0xe9, 0xde, 0xf8, 0x55, 0x81, 0xdd, 0x4f, 0xcc, 0x4a, 0x2d, 0x11, 0x50, 0x69, 0xf9, 0x7e, 0x71, 0x51, 0xe6, - 0xfc, 0xe9, 0x0f, 0xd7, 0x71, 0x48, 0xa8, 0x91, 0x2f, 0x53, 0xd9, 0x01, 0xf9, 0xf0, 0x1d, 0xfd, 0x2c, 0xca, 0x6a, - 0x0a, 0xbf, 0x8d, 0x2d, 0xdc, 0x5d, 0x16, 0x59, 0xea, 0x00, 0x50, 0x84, 0x63, 0x34, 0x1b, 0x3f, 0xed, 0x92, 0x0c, - 0xed, 0xa2, 0x8d, 0xdf, 0x69, 0x49, 0x33, 0x2a, 0x2a, 0x8a, 0x86, 0xd0, 0x6c, 0x34, 0x43, 0x0a, 0xe6, 0x09, 0x7a, - 0xf1, 0x31, 0x3b, 0xf0, 0xe7, 0x46, 0x49, 0x59, 0xba, 0x35, 0x7f, 0xbd, 0xbd, 0x90, 0xac, 0xa7, 0xac, 0x6e, 0x8a, - 0x30, 0x59, 0xd0, 0x0c, 0x7d, 0xe5, 0xff, 0x30, 0x80, 0xa7, 0x90, 0x97, 0x2b, 0x16, 0xfe, 0x5e, 0xd5, 0x3d, 0x7c, - 0xb9, 0x11, 0xc7, 0xf5, 0xa2, 0x29, 0x1f, 0xb4, 0x0f, 0x21, 0xa9, 0xea, 0x7b, 0x1c, 0xf6, 0x9c, 0xfa, 0x8f, 0x85, - 0x4d, 0xb8, 0x15, 0x05, 0x02, 0xcf, 0x66, 0x2d, 0x9a, 0x88, 0xa9, 0xcb, 0x8c, 0x08, 0x63, 0x49, 0x10, 0xc4, 0xad, - 0xce, 0x79, 0x3e, 0xca, 0xcd, 0xc9, 0x49, 0x9e, 0xb7, 0xb3, 0xeb, 0x68, 0xdf, 0x9b, 0x5b, 0x29, 0xab, 0x5c, 0x37, - 0x84, 0x16, 0x2f, 0x5d, 0x5c, 0xa5, 0x32, 0x4c, 0xcb, 0x55, 0x71, 0x43, 0xab, 0xd6, 0xb4, 0x6a, 0xc0, 0x07, 0x19, - 0xb4, 0x2a, 0x4f, 0x9e, 0x76, 0x95, 0x9b, 0x6c, 0xd3, 0x97, 0x15, 0x5d, 0x77, 0xc0, 0xf0, 0x4a, 0x61, 0x6d, 0xd7, - 0xc1, 0x36, 0x9c, 0x68, 0x70, 0xde, 0xb7, 0xdb, 0x06, 0x90, 0xbc, 0xdd, 0xc5, 0x0a, 0x1e, 0x4e, 0x8e, 0xff, 0x62, - 0x87, 0xe2, 0xf7, 0xbe, 0x68, 0x65, 0x14, 0x23, 0x23, 0x34, 0xf5, 0xaf, 0x8e, 0x08, 0xff, 0xc2, 0x77, 0xa5, 0xf6, - 0x98, 0xab, 0x08, 0x65, 0xed, 0x66, 0x15, 0xfb, 0x83, 0x24, 0xbf, 0x34, 0x49, 0xf5, 0x36, 0x4f, 0x4f, 0xb0, 0x4a, - 0x41, 0x7b, 0x73, 0xd8, 0x60, 0x6b, 0xae, 0x8d, 0x14, 0x37, 0x98, 0xd0, 0xc6, 0xff, 0x60, 0x23, 0xc0, 0x27, 0x52, - 0xbc, 0xe0, 0x72, 0x5c, 0x59, 0x8a, 0xe6, 0x44, 0xf3, 0xd2, 0xc8, 0x3e, 0x85, 0x79, 0x3e, 0xaa, 0x90, 0xeb, 0xe6, - 0x3c, 0x50, 0x2f, 0x87, 0x3e, 0x71, 0xca, 0x38, 0xcf, 0x8e, 0x70, 0x3e, 0x95, 0xd3, 0xae, 0xde, 0xac, 0x2d, 0x43, - 0x5c, 0x27, 0x2b, 0x42, 0x48, 0x3e, 0x8c, 0x53, 0x51, 0xa4, 0xd8, 0xbe, 0xda, 0x39, 0xcf, 0xf1, 0x95, 0x21, 0x0a, - 0x27, 0x5c, 0x44, 0x63, 0x4a, 0xe8, 0x4f, 0x5e, 0x50, 0x74, 0x67, 0xd4, 0x24, 0x98, 0xb5, 0x3a, 0x99, 0x04, 0xce, - 0xd4, 0x7f, 0xc0, 0xc2, 0xd0, 0x1b, 0x20, 0x3a, 0xa8, 0xa9, 0x32, 0x3f, 0xba, 0x5b, 0x71, 0xe3, 0x93, 0x8e, 0xcc, - 0x68, 0x13, 0x33, 0xce, 0x94, 0xda, 0xe2, 0x6b, 0xb3, 0x7b, 0x8e, 0xc0, 0xec, 0x6e, 0x01, 0xc1, 0x22, 0x8e, 0x54, - 0x68, 0xd5, 0x9f, 0xab, 0x77, 0xbb, 0x48, 0x80, 0x73, 0x42, 0x1b, 0x03, 0x2d, 0x3e, 0xe3, 0x74, 0x35, 0xe7, 0xdb, - 0x38, 0xec, 0x18, 0x32, 0x55, 0x9c, 0xdf, 0x45, 0x9f, 0xfb, 0x99, 0x00, 0xdd, 0x2d, 0x44, 0x3a, 0xdf, 0x5b, 0x17, - 0x6a, 0x16, 0x0e, 0x21, 0x6c, 0x7f, 0x12, 0x25, 0x64, 0xa8, 0xbf, 0x16, 0x7e, 0x8e, 0xda, 0xab, 0x97, 0x5a, 0x26, - 0x1b, 0x7e, 0x30, 0xa2, 0xc5, 0xa3, 0x00, 0x92, 0x0c, 0xa3, 0xf7, 0xcf, 0xdf, 0xdc, 0xb0, 0x9f, 0xa1, 0xf0, 0x0c, - 0xe6, 0x11, 0x50, 0xc0, 0xcd, 0xdd, 0x4f, 0xe8, 0xda, 0x52, 0x2e, 0x08, 0x67, 0xb2, 0x0d, 0x09, 0x56, 0xc6, 0xb9, - 0x66, 0x6b, 0xe3, 0x45, 0xc3, 0x09, 0xe9, 0x88, 0x3a, 0x68, 0x4c, 0x7a, 0x9e, 0x33, 0x9a, 0xc7, 0x58, 0xfd, 0xc9, - 0x99, 0x60, 0xf9, 0x81, 0x8d, 0xc9, 0x15, 0x04, 0x55, 0x8b, 0x82, 0x58, 0xd3, 0x1d, 0xed, 0xc0, 0x70, 0x7f, 0x29, - 0x9e, 0x12, 0xe4, 0x6f, 0x97, 0x98, 0x38, 0x2a, 0x14, 0x72, 0xd6, 0xb8, 0xa1, 0x6f, 0x44, 0xb0, 0x5e, 0x8d, 0x07, - 0xbd, 0xe7, 0x4b, 0x91, 0xa5, 0xaa, 0x73, 0xbb, 0x51, 0x0e, 0xcd, 0x30, 0x61, 0x8c, 0x13, 0x5a, 0xca, 0x37, 0x64, - 0x25, 0x76, 0x36, 0xb5, 0x14, 0x4e, 0xff, 0x69, 0xc8, 0x53, 0xb1, 0x85, 0x80, 0xaa, 0xcf, 0x41, 0x93, 0x13, 0xd3, - 0xd4, 0x9d, 0x37, 0x72, 0x67, 0x1e, 0x60, 0x54, 0x53, 0x36, 0x3a, 0xa1, 0x77, 0xcc, 0x47, 0x66, 0xf0, 0x33, 0xb2, - 0x3b, 0x0f, 0x59, 0x2d, 0x93, 0xcb, 0x24, 0x3f, 0xeb, 0x8d, 0xef, 0x1c, 0x20, 0xb1, 0x8e, 0x41, 0xc5, 0xe6, 0x59, - 0x57, 0x59, 0xab, 0x2a, 0xd3, 0x4d, 0xfc, 0xaa, 0x5b, 0x1a, 0x28, 0x78, 0xa2, 0x02, 0x85, 0x48, 0x9a, 0x92, 0xa0, - 0x56, 0x0f, 0x21, 0x47, 0x94, 0xa3, 0xbb, 0x45, 0xcc, 0x75, 0xbc, 0xaa, 0x6c, 0xfc, 0x1b, 0xd3, 0x47, 0x8b, 0xda, - 0xa1, 0xdb, 0xcf, 0x6c, 0x54, 0xc3, 0x22, 0x55, 0x4e, 0x61, 0xc8, 0x8f, 0x38, 0x8f, 0x35, 0x09, 0xb2, 0x71, 0x32, - 0x00, 0x05, 0xbd, 0x54, 0xe0, 0x7f, 0x33, 0xe7, 0x8c, 0x15, 0x2b, 0x17, 0xa0, 0x22, 0x58, 0xbb, 0xe6, 0x5f, 0xf7, - 0x69, 0xc4, 0x28, 0x54, 0x67, 0x0f, 0xc0, 0xac, 0x85, 0x0c, 0xe4, 0x57, 0xeb, 0x6d, 0x28, 0x17, 0xb6, 0xe1, 0xa4, - 0xf5, 0xba, 0xfa, 0x2c, 0xe4, 0x22, 0xad, 0xa6, 0x68, 0xb3, 0x3a, 0x4f, 0x9d, 0x15, 0x4c, 0xf8, 0x25, 0x9c, 0x9b, - 0x4e, 0x90, 0xa5, 0xc6, 0x91, 0xf2, 0x30, 0xfb, 0x38, 0x6a, 0x9d, 0x59, 0x39, 0x76, 0xa1, 0x0a, 0xdb, 0x3c, 0xcf, - 0x9c, 0x30, 0xbd, 0xd8, 0x93, 0xaa, 0xda, 0x95, 0x95, 0xee, 0xe6, 0x5a, 0xcc, 0x9b, 0x5d, 0x1d, 0x49, 0x2d, 0x31, - 0xad, 0x93, 0xfd, 0x89, 0x95, 0x59, 0x81, 0xe0, 0x6d, 0xe8, 0x36, 0x42, 0x64, 0x17, 0xec, 0x47, 0x5a, 0xbc, 0x74, - 0x4b, 0xae, 0x8e, 0x60, 0x11, 0x5a, 0x45, 0xff, 0x50, 0x5a, 0x18, 0x90, 0xea, 0x8a, 0x92, 0xd2, 0x48, 0xff, 0xad, - 0xcc, 0x70, 0x92, 0x59, 0xbd, 0x77, 0xa8, 0x3d, 0x16, 0x41, 0xbd, 0x1f, 0x93, 0x1e, 0xe5, 0x5c, 0x2f, 0x05, 0x9c, - 0x2c, 0x81, 0xd9, 0x0b, 0x76, 0x0b, 0x00, 0x79, 0xed, 0x6d, 0x2d, 0x15, 0x99, 0x70, 0xf9, 0x3c, 0x99, 0x73, 0x69, - 0x15, 0x78, 0x05, 0xbd, 0x6b, 0x6f, 0xb0, 0xb2, 0x10, 0xdc, 0x2f, 0x72, 0xa6, 0xcf, 0x0a, 0x92, 0x4a, 0x43, 0xbc, - 0xb4, 0x04, 0xde, 0x4a, 0xaa, 0x29, 0x70, 0x6b, 0xd9, 0x70, 0x6d, 0xda, 0x46, 0x1f, 0xea, 0xfd, 0x78, 0xc7, 0x68, - 0x15, 0xfc, 0xe7, 0xd3, 0xdf, 0x2a, 0x76, 0x47, 0xf0, 0x6c, 0x15, 0xaa, 0xac, 0xeb, 0x61, 0x22, 0xd9, 0xfe, 0x6a, - 0xe7, 0x0b, 0xa0, 0x45, 0xb8, 0x52, 0xba, 0x26, 0x01, 0x9d, 0xd4, 0x14, 0x0b, 0xdc, 0xa6, 0xc0, 0x2c, 0xa3, 0x9f, - 0xc2, 0xb7, 0x91, 0x6b, 0x1c, 0xa9, 0x46, 0x34, 0x99, 0x71, 0xb8, 0x20, 0x9a, 0xbc, 0xb9, 0x5b, 0x15, 0x01, 0x04, - 0x07, 0x68, 0x2b, 0xef, 0x8c, 0xd3, 0x3b, 0xf7, 0x91, 0xd6, 0x39, 0xf0, 0x43, 0x37, 0xd9, 0x2e, 0x75, 0x68, 0xd5, - 0x12, 0xbd, 0x5d, 0x47, 0x8d, 0x06, 0x19, 0xb6, 0x44, 0x31, 0xb6, 0xe0, 0xe3, 0x13, 0x3e, 0x66, 0x90, 0x55, 0x72, - 0xc0, 0xd7, 0x8b, 0x06, 0x2a, 0x16, 0x15, 0xc8, 0xdf, 0x85, 0x50, 0xa8, 0xa3, 0x6d, 0xb4, 0x00, 0x40, 0x7d, 0x82, - 0x12, 0x3a, 0x71, 0x4b, 0xbd, 0x01, 0x55, 0xbe, 0x0f, 0x29, 0x95, 0x50, 0xdf, 0x54, 0x64, 0xca, 0xd1, 0x52, 0x31, - 0x03, 0x84, 0x91, 0x47, 0x26, 0x43, 0x6d, 0xe2, 0x2c, 0x62, 0xee, 0xde, 0x32, 0xaa, 0x7e, 0x6c, 0xcf, 0x3b, 0x59, - 0xda, 0x6b, 0x11, 0x73, 0x95, 0x33, 0xde, 0x07, 0x50, 0x02, 0x07, 0x57, 0x81, 0xb9, 0x67, 0xaa, 0x77, 0x55, 0xbc, - 0xcf, 0x2c, 0xb3, 0x86, 0x07, 0x4a, 0xcf, 0x2e, 0xc6, 0xd7, 0x98, 0xeb, 0xcf, 0xad, 0x89, 0x67, 0xf1, 0x5f, 0x1f, - 0xb7, 0x7c, 0x9e, 0xc3, 0xef, 0x26, 0xda, 0xd5, 0x19, 0xb8, 0x72, 0xc2, 0x3e, 0x4f, 0xd0, 0xae, 0x1b, 0xbc, 0x5b, - 0xb6, 0x16, 0x6b, 0x9e, 0xbc, 0x09, 0xef, 0x5b, 0x33, 0x87, 0xaa, 0xaa, 0x3c, 0xae, 0x36, 0x10, 0x48, 0xe3, 0x3b, - 0x93, 0xcc, 0xa0, 0x6b, 0x48, 0x9a, 0xe9, 0x46, 0xf0, 0xbb, 0x6f, 0xdd, 0x82, 0x8e, 0x34, 0xb0, 0xd8, 0xda, 0x3b, - 0x81, 0xcf, 0x4c, 0x86, 0x15, 0xb3, 0xe4, 0x0c, 0x7e, 0x7b, 0x1b, 0xc2, 0xd3, 0xd6, 0x9b, 0x72, 0xb9, 0x22, 0x8b, - 0x3e, 0x0f, 0xfd, 0x8a, 0x7e, 0x93, 0x96, 0xe5, 0x71, 0x0f, 0x55, 0x72, 0xff, 0x57, 0xb1, 0xe6, 0x34, 0xfa, 0x2a, - 0xa8, 0x5f, 0xbd, 0x63, 0xc0, 0xe6, 0xb6, 0xf6, 0x16, 0x72, 0xba, 0xb4, 0xc8, 0x3d, 0x18, 0x9a, 0xe9, 0xfd, 0x8f, - 0x02, 0x61, 0xc9, 0x9e, 0xd2, 0xd6, 0xf3, 0xe4, 0xa2, 0x97, 0xea, 0xdc, 0x88, 0x7f, 0xcb, 0x95, 0xdf, 0xbc, 0x8e, - 0x1a, 0xa5, 0x89, 0xff, 0x83, 0xff, 0xb5, 0x51, 0x26, 0x97, 0x3a, 0xb9, 0xd3, 0x0e, 0xca, 0xa3, 0x2e, 0x39, 0x1e, - 0xc5, 0x52, 0x33, 0x1a, 0xc5, 0x33, 0x61, 0x9f, 0xb9, 0xa0, 0x2a, 0xf4, 0x58, 0x36, 0x00, 0x6b, 0x18, 0x40, 0x32, - 0xa0, 0x26, 0x67, 0xc4, 0xa9, 0x3b, 0xc1, 0xad, 0x86, 0xd2, 0x55, 0x64, 0x46, 0x72, 0x5a, 0x78, 0x97, 0xf7, 0x2b, - 0x31, 0x44, 0xb9, 0xac, 0x6f, 0x52, 0x47, 0x54, 0x7c, 0x15, 0x5d, 0x4a, 0xdf, 0x22, 0x36, 0xda, 0x7e, 0xd8, 0xd0, - 0x8e, 0x39, 0x60, 0xe4, 0xbd, 0xd1, 0xa8, 0xe5, 0xcc, 0x20, 0xe6, 0xa7, 0x67, 0xd0, 0xc4, 0x01, 0xb3, 0x15, 0x43, - 0xcc, 0x51, 0x72, 0x55, 0x6a, 0xd2, 0x18, 0x14, 0x13, 0x3b, 0x71, 0xa4, 0x3e, 0xbf, 0xee, 0x4e, 0x0a, 0x3f, 0xcc, - 0xa9, 0xa9, 0x75, 0x3f, 0x80, 0x2d, 0x3e, 0xd5, 0xfa, 0x1d, 0x55, 0x18, 0x98, 0xed, 0x1a, 0x22, 0xfc, 0x8d, 0x8a, - 0x8b, 0xf4, 0x24, 0xfd, 0x3b, 0xf5, 0x55, 0x75, 0x1b, 0x31, 0x64, 0xcc, 0xec, 0x04, 0x6b, 0x26, 0x07, 0xb4, 0x2c, - 0xce, 0xcc, 0x2c, 0xe5, 0xb3, 0x71, 0x2c, 0xb1, 0x16, 0x58, 0x6c, 0x79, 0x9b, 0x07, 0x77, 0x68, 0x41, 0xa8, 0x48, - 0x9c, 0x58, 0xb6, 0x31, 0x73, 0x13, 0xda, 0xe0, 0x09, 0xb1, 0xa2, 0x5f, 0xf0, 0x8d, 0x10, 0x3f, 0x3a, 0xe8, 0x4d, - 0x6a, 0xa7, 0xd1, 0x95, 0xd1, 0xc1, 0x38, 0xbc, 0xe6, 0xbf, 0x5d, 0x37, 0x11, 0x74, 0x89, 0xb8, 0xa9, 0x80, 0x4b, - 0x8e, 0x9f, 0x62, 0x50, 0x27, 0x37, 0x83, 0x4d, 0x7c, 0xa7, 0xe3, 0xad, 0x1d, 0xac, 0x77, 0xc0, 0xb9, 0x3f, 0xfe, - 0x3b, 0x71, 0x1b, 0xa5, 0x5c, 0x9e, 0xfc, 0x16, 0x3b, 0x19, 0xa2, 0x39, 0x4f, 0x6f, 0x1d, 0x5e, 0x2d, 0xd2, 0x4c, - 0x75, 0x6a, 0x7a, 0x73, 0x3c, 0xd2, 0x09, 0xfc, 0x95, 0xf1, 0xec, 0x82, 0xe3, 0xb4, 0x60, 0x05, 0xe5, 0x03, 0x7e, - 0x0f, 0xa5, 0x1a, 0xae, 0x5c, 0xf4, 0x75, 0x40, 0x3d, 0x53, 0x7c, 0x59, 0x8d, 0xb5, 0x6f, 0xd2, 0x2d, 0xf8, 0xc3, - 0x1e, 0x16, 0x65, 0x5d, 0x3f, 0x3f, 0x7f, 0xb3, 0x97, 0x8d, 0xf4, 0xfc, 0x77, 0x60, 0x49, 0xfd, 0x53, 0x09, 0xaa, - 0xf6, 0xa6, 0xe6, 0x8d, 0x83, 0x78, 0x1a, 0x53, 0x1a, 0xd1, 0xff, 0xd2, 0x31, 0x75, 0x55, 0x06, 0x57, 0xc0, 0x3c, - 0x78, 0x12, 0x93, 0xa5, 0x9f, 0x8d, 0xa9, 0xa5, 0xf0, 0x6b, 0xcc, 0x4f, 0x6a, 0xf5, 0x90, 0xe3, 0x3c, 0xe4, 0xe2, - 0x95, 0xa4, 0x7b, 0x6f, 0x56, 0xdf, 0xce, 0x16, 0x06, 0xa7, 0xf9, 0x2a, 0x80, 0xff, 0xc7, 0x39, 0x01, 0x74, 0xf7, - 0xcc, 0xc5, 0x63, 0x9e, 0x7c, 0x78, 0xb3, 0xb5, 0x9a, 0x16, 0xe4, 0xdd, 0x79, 0x2a, 0xcd, 0xd6, 0x82, 0x58, 0x9b, - 0x7a, 0x34, 0x41, 0xbd, 0xd3, 0x5b, 0xd3, 0xbe, 0xb1, 0x3e, 0x8c, 0x86, 0xbe, 0x23, 0x0b, 0x85, 0xe7, 0x8f, 0x09, - 0x67, 0xc7, 0xb3, 0x89, 0x89, 0x61, 0xbf, 0x53, 0xed, 0x62, 0x60, 0xab, 0xab, 0x15, 0x0b, 0xc6, 0xfb, 0x81, 0xee, - 0x9b, 0x4c, 0x96, 0x72, 0x3c, 0xc6, 0x4c, 0x25, 0x6a, 0xda, 0xb7, 0xd4, 0xb2, 0xbb, 0x17, 0x28, 0x23, 0x66, 0xa9, - 0x81, 0xd9, 0x17, 0xaf, 0x0a, 0x0c, 0x14, 0xaa, 0xf3, 0xe1, 0x8d, 0x15, 0x94, 0xc1, 0x47, 0xf3, 0xba, 0x94, 0x15, - 0x04, 0x8e, 0x49, 0xeb, 0xc0, 0xfd, 0xf2, 0x40, 0x8f, 0x14, 0x7d, 0xf1, 0x36, 0x0a, 0x58, 0x5e, 0xd7, 0x53, 0x83, - 0xb7, 0x1a, 0xae, 0x8d, 0xf5, 0x32, 0xe3, 0x97, 0xf5, 0x40, 0x61, 0x14, 0x5c, 0xdc, 0x99, 0x5d, 0x8c, 0xc3, 0xbe, - 0xdb, 0x2a, 0x67, 0x4a, 0xa6, 0x5c, 0xaf, 0x6c, 0x7e, 0xc6, 0x40, 0xcf, 0x9b, 0xb5, 0xac, 0x71, 0xfd, 0xc4, 0xef, - 0x6e, 0x8e, 0x2b, 0xe3, 0x6c, 0x14, 0xba, 0xff, 0x23, 0x1b, 0x6a, 0x7c, 0x03, 0x35, 0x82, 0x90, 0x83, 0xab, 0xa5, - 0xb2, 0x34, 0xd2, 0x7e, 0xb6, 0x9f, 0xbe, 0x4f, 0x1e, 0x2b, 0xc8, 0xf2, 0x5f, 0xb2, 0x62, 0x63, 0x0e, 0x93, 0xc9, - 0xaf, 0x3a, 0x85, 0x74, 0x40, 0xd5, 0xa2, 0x1d, 0xa3, 0x57, 0xd9, 0x09, 0x41, 0x7d, 0x31, 0x10, 0x75, 0x00, 0x66, - 0x5b, 0xa5, 0xbc, 0x2c, 0x06, 0x9a, 0x49, 0x94, 0x2d, 0x07, 0x7d, 0x6d, 0xf8, 0xf0, 0x1a, 0xbc, 0x6a, 0x94, 0xd5, - 0xf4, 0xb2, 0x9a, 0x42, 0xa5, 0xd3, 0xa6, 0x95, 0xe0, 0x35, 0x79, 0xba, 0x5f, 0xea, 0x5c, 0x77, 0x4d, 0x1c, 0xfc, - 0x6c, 0xf5, 0x7b, 0xb0, 0xa3, 0xc9, 0xb1, 0x2b, 0xb9, 0xb9, 0xc1, 0x71, 0x1e, 0x73, 0x5c, 0xb9, 0x40, 0x44, 0xcd, - 0x42, 0x2b, 0x18, 0xd0, 0x22, 0x75, 0xa7, 0xbe, 0xbb, 0xc4, 0x6e, 0x02, 0xd8, 0x2a, 0xf6, 0x1e, 0x24, 0xdb, 0x3e, - 0x4b, 0x6f, 0x74, 0x60, 0x3b, 0x78, 0x8b, 0x26, 0xbe, 0x31, 0x57, 0xaa, 0xa9, 0xc8, 0xea, 0x8c, 0xea, 0xb0, 0x73, - 0x9a, 0xcf, 0x0f, 0x9a, 0xb1, 0x72, 0x9b, 0x84, 0xdb, 0x31, 0x52, 0x27, 0x88, 0x05, 0x2a, 0x56, 0xd3, 0xa0, 0x5a, - 0x46, 0x50, 0xb9, 0x49, 0xfa, 0xca, 0x23, 0x59, 0x8d, 0x15, 0xeb, 0x67, 0xa0, 0x6e, 0xae, 0xdc, 0xb8, 0x6d, 0x86, - 0xac, 0x5a, 0xae, 0x70, 0x46, 0x20, 0x86, 0xc6, 0x67, 0xd6, 0x48, 0x54, 0x5b, 0x09, 0xe8, 0xc0, 0xe1, 0x22, 0x05, - 0xb5, 0xbb, 0x2d, 0xaf, 0xdf, 0x8d, 0xd2, 0x23, 0x4a, 0x54, 0xd4, 0x8a, 0xca, 0x29, 0xdd, 0x50, 0xae, 0x9e, 0x89, - 0x26, 0x60, 0xa2, 0x51, 0x6c, 0xa4, 0x16, 0xe5, 0xed, 0x56, 0x85, 0xec, 0xe5, 0xba, 0x7f, 0x79, 0xff, 0x91, 0xd3, - 0xb0, 0xe9, 0x3b, 0x21, 0x69, 0x30, 0x48, 0x45, 0xc2, 0x07, 0xec, 0xa8, 0xb7, 0xe4, 0x9b, 0xcc, 0x90, 0xa9, 0x23, - 0x63, 0xd4, 0x97, 0x58, 0xf9, 0xd2, 0xfc, 0xdd, 0xab, 0x7b, 0xa3, 0x80, 0xad, 0xdf, 0xe9, 0xda, 0xdc, 0x94, 0xc2, - 0xdb, 0x0e, 0x61, 0x0a, 0xe9, 0x26, 0x23, 0xd2, 0xfa, 0xcf, 0x54, 0xfd, 0x66, 0xe2, 0x77, 0x35, 0xb6, 0x6b, 0x82, - 0x3c, 0xd1, 0x9b, 0xcd, 0xe6, 0x9c, 0xaa, 0x59, 0x00, 0x20, 0xfe, 0xab, 0xcd, 0x37, 0xf3, 0x95, 0x2a, 0x1a, 0x88, - 0xe0, 0xb3, 0xd0, 0xf5, 0x6f, 0x64, 0x54, 0x7d, 0x1a, 0xd1, 0xbf, 0x06, 0x49, 0x08, 0x65, 0xce, 0xe6, 0x7a, 0x43, - 0x50, 0xc7, 0x9e, 0x67, 0x6f, 0xf5, 0x29, 0x4c, 0xfc, 0x8f, 0xbc, 0xfa, 0x39, 0xee, 0x55, 0x14, 0xa5, 0xd8, 0xd5, - 0xa1, 0x71, 0x98, 0xc2, 0x4d, 0xa6, 0x5b, 0xef, 0x92, 0x21, 0xe0, 0xf4, 0x5f, 0x1c, 0x0e, 0x23, 0x73, 0xd3, 0x9d, - 0x0d, 0x0c, 0x06, 0x05, 0x23, 0x29, 0x96, 0x21, 0x94, 0xb9, 0xc1, 0x5c, 0xbc, 0x75, 0x80, 0x2f, 0x5d, 0x90, 0xe5, - 0x9b, 0x85, 0x8e, 0xf1, 0xd9, 0xb7, 0xe7, 0x1d, 0x1f, 0xa9, 0xd0, 0x32, 0x4b, 0x04, 0x29, 0xa4, 0x2f, 0xfe, 0x19, - 0x46, 0x2d, 0x8f, 0x89, 0x0b, 0xa6, 0xd5, 0xc3, 0x4b, 0x29, 0xc0, 0xce, 0x73, 0x50, 0x53, 0x2f, 0xa0, 0x8e, 0x85, - 0x9b, 0xca, 0x03, 0xbb, 0x12, 0x43, 0x6a, 0x53, 0x04, 0x30, 0x7e, 0xeb, 0x08, 0x11, 0x0f, 0xd2, 0xa0, 0x54, 0x4b, - 0xc8, 0x78, 0xb3, 0x9c, 0x58, 0x77, 0x17, 0x03, 0xe2, 0x9b, 0x23, 0x06, 0xb4, 0xa5, 0x66, 0x18, 0x1e, 0xe7, 0x5f, - 0x4b, 0x79, 0x13, 0x32, 0x88, 0x5d, 0x03, 0x5d, 0x49, 0xb9, 0x59, 0xfb, 0xe1, 0x18, 0xa8, 0xda, 0x86, 0x44, 0xe9, - 0x37, 0xd5, 0x95, 0x75, 0x25, 0x56, 0xa8, 0x56, 0x3b, 0xbb, 0x37, 0x79, 0x9d, 0x36, 0x34, 0xc3, 0x53, 0xb8, 0xb9, - 0x52, 0xdb, 0xc6, 0xae, 0xed, 0xff, 0x24, 0x73, 0xd0, 0x14, 0xac, 0x95, 0x1f, 0xec, 0x78, 0x36, 0xd1, 0xbf, 0x9e, - 0xd5, 0x99, 0x74, 0xfd, 0x51, 0x79, 0x96, 0x9f, 0x5b, 0x75, 0x50, 0x81, 0x87, 0xd3, 0x22, 0xff, 0xd1, 0xd7, 0x70, - 0x0d, 0xbd, 0x27, 0xef, 0x7a, 0xbb, 0xc1, 0x18, 0xbe, 0x78, 0x13, 0x4f, 0xfb, 0x9b, 0x4c, 0xe0, 0x14, 0xc2, 0xb6, - 0x75, 0x02, 0xd6, 0x3a, 0x7d, 0x47, 0x52, 0xd0, 0x22, 0xbf, 0x45, 0xb3, 0x5f, 0x2b, 0x73, 0xc3, 0x2f, 0x1c, 0xc5, - 0xcd, 0xa5, 0x74, 0x91, 0x3c, 0x59, 0xa5, 0xed, 0x30, 0xcb, 0x20, 0x8e, 0xc0, 0x72, 0xf4, 0x73, 0x27, 0x72, 0xeb, - 0x63, 0x35, 0xcc, 0xee, 0x38, 0x0e, 0xc5, 0xa8, 0x7e, 0xaa, 0x23, 0x52, 0x1e, 0x26, 0x03, 0x36, 0x35, 0xa1, 0xc5, - 0x58, 0x58, 0xba, 0x24, 0x41, 0x0a, 0x74, 0x80, 0x5a, 0x22, 0x73, 0x52, 0x8b, 0xec, 0x8a, 0x71, 0xcf, 0xb6, 0x62, - 0xe9, 0xda, 0xc7, 0x47, 0x9d, 0x3d, 0x03, 0x37, 0x8e, 0x93, 0x93, 0xcd, 0x9d, 0x2d, 0xc0, 0x4a, 0x8f, 0xc9, 0xe9, - 0xec, 0x87, 0x12, 0xcb, 0x35, 0xd9, 0x7d, 0x54, 0xb4, 0xbb, 0xef, 0xe0, 0x88, 0x2c, 0x11, 0xa3, 0xff, 0xb4, 0xce, - 0x64, 0xad, 0xbf, 0x91, 0x03, 0xf8, 0x16, 0x1a, 0xf5, 0x82, 0xc5, 0x80, 0xcb, 0xdd, 0xe5, 0x5d, 0x8d, 0x0f, 0xbc, - 0x32, 0xe1, 0xac, 0x2a, 0xd7, 0xdc, 0x6c, 0x64, 0x9a, 0xa8, 0x09, 0xe9, 0xff, 0x2b, 0x5b, 0x0d, 0xb1, 0x05, 0x78, - 0x32, 0xf6, 0xcd, 0x9b, 0x0d, 0x4c, 0xcd, 0x42, 0x8b, 0x2b, 0xec, 0x43, 0x1c, 0xa7, 0x22, 0xba, 0xb9, 0x81, 0x1a, - 0x7e, 0x90, 0xd0, 0xca, 0x77, 0x09, 0x55, 0xff, 0x41, 0x34, 0xf6, 0xbd, 0x57, 0x59, 0xc2, 0x41, 0xcf, 0x41, 0xa6, - 0xd1, 0xbd, 0x66, 0xd2, 0x93, 0xbd, 0xb9, 0x31, 0x54, 0x8d, 0xbc, 0x56, 0xee, 0x1e, 0xdc, 0x2d, 0xe1, 0xf9, 0xd9, - 0x9c, 0xf7, 0xe6, 0x23, 0xe1, 0x51, 0x37, 0x5e, 0xf5, 0x0f, 0x71, 0x87, 0xaf, 0xae, 0x1f, 0x27, 0x62, 0x45, 0x11, - 0x17, 0x1f, 0xd6, 0xbb, 0x5a, 0x79, 0xdc, 0x3a, 0x3c, 0xc5, 0xfb, 0x06, 0x74, 0x4a, 0x4a, 0x75, 0xde, 0x35, 0x81, - 0xae, 0xe0, 0xfb, 0x73, 0xed, 0xf2, 0xfd, 0x8d, 0xb3, 0x6e, 0xcb, 0xcd, 0xc6, 0xc1, 0x1b, 0x93, 0x2e, 0x5a, 0xb0, - 0xeb, 0x3b, 0x9e, 0xbe, 0xf9, 0x38, 0xfc, 0x68, 0x64, 0x58, 0xd5, 0x58, 0x40, 0x1b, 0x5a, 0xbe, 0x20, 0xef, 0xc9, - 0x22, 0x46, 0x77, 0xa5, 0xc9, 0x53, 0x72, 0xbb, 0xf9, 0x3e, 0x44, 0xbc, 0x59, 0x07, 0xba, 0x72, 0xd0, 0xdd, 0xf8, - 0xd7, 0xfa, 0xe5, 0x65, 0xe9, 0xde, 0xbc, 0x7a, 0xee, 0xb5, 0x90, 0x30, 0xa9, 0xf3, 0xc9, 0x20, 0x97, 0x0f, 0x86, - 0xc8, 0xc8, 0xe6, 0x18, 0xcf, 0x24, 0x65, 0x09, 0xbc, 0x1c, 0x57, 0x19, 0xbc, 0x33, 0x6d, 0xe4, 0x1f, 0xf7, 0x44, - 0x22, 0x1e, 0x0c, 0xb4, 0x6d, 0x50, 0x28, 0x4c, 0xea, 0xed, 0x62, 0x88, 0x7b, 0x94, 0x31, 0xd1, 0x3c, 0x76, 0x7d, - 0xbf, 0x46, 0x27, 0x47, 0x6f, 0x66, 0xd4, 0x6e, 0xff, 0x61, 0x35, 0x05, 0x7a, 0xe2, 0xe0, 0x89, 0xba, 0xa2, 0x12, - 0x1e, 0xff, 0xf4, 0x89, 0xf6, 0x4b, 0x7a, 0x38, 0x55, 0x87, 0xe7, 0xab, 0xf8, 0xca, 0x45, 0x55, 0x2b, 0x7e, 0x09, - 0xfa, 0x70, 0xb1, 0xc8, 0xc9, 0xf3, 0x48, 0xaf, 0x6c, 0xf6, 0x6a, 0x66, 0x13, 0xc5, 0x9d, 0xc2, 0xf2, 0xb8, 0xf9, - 0x8a, 0xe6, 0xd4, 0x90, 0x68, 0xf5, 0xef, 0x43, 0x7f, 0x0c, 0xf6, 0x36, 0xfb, 0xbf, 0x25, 0x71, 0xe6, 0xe9, 0x33, - 0xe2, 0x77, 0xb3, 0xf5, 0x92, 0x1f, 0xba, 0xbf, 0xc4, 0xbf, 0x8f, 0x4d, 0xa0, 0x59, 0xa6, 0x34, 0x51, 0xc6, 0x30, - 0x00, 0x38, 0x00, 0x7e, 0x6d, 0xfe, 0xe2, 0xdf, 0x2d, 0x9b, 0xdc, 0xcc, 0xe2, 0xa4, 0xc5, 0x9d, 0x7f, 0xfa, 0x42, - 0x69, 0x69, 0x9c, 0xe6, 0x01, 0x41, 0x35, 0xae, 0x4d, 0x8f, 0x8d, 0x64, 0x1e, 0xc8, 0x3a, 0x18, 0xb6, 0x96, 0x9c, - 0x60, 0x02, 0x22, 0xf7, 0xaa, 0xe6, 0x4b, 0x97, 0x6a, 0x65, 0x96, 0xa9, 0xcd, 0xd7, 0xd2, 0xc1, 0x60, 0xdf, 0x41, - 0xcc, 0xf7, 0xb9, 0xc7, 0x6c, 0x26, 0x3f, 0xb7, 0xb4, 0xe0, 0x6f, 0xa5, 0x3c, 0x19, 0x73, 0xf3, 0x46, 0x28, 0x2e, - 0x3e, 0x0a, 0xcc, 0x70, 0x46, 0xb0, 0x50, 0xab, 0xaf, 0xbc, 0x89, 0x0d, 0xff, 0x50, 0x12, 0x78, 0xb1, 0x7b, 0xb9, - 0xf2, 0x0a, 0xbc, 0x09, 0xed, 0x1f, 0x28, 0xff, 0xef, 0xa9, 0x96, 0xbd, 0xbc, 0x57, 0xa7, 0xb6, 0xe3, 0x5a, 0x50, - 0x91, 0x54, 0x05, 0x6f, 0xd7, 0xbf, 0x65, 0xa2, 0x81, 0xe5, 0xc9, 0x52, 0xf6, 0xb5, 0x33, 0xf0, 0xb1, 0x81, 0x2e, - 0xf5, 0x95, 0x54, 0xbd, 0x10, 0x67, 0x2c, 0x24, 0xcd, 0x0c, 0x80, 0xe8, 0x75, 0x9f, 0x9e, 0x54, 0xd3, 0xb0, 0x57, - 0x67, 0x2b, 0x7a, 0xd6, 0x88, 0x91, 0xde, 0xa5, 0xd2, 0x98, 0x3d, 0x3d, 0x52, 0xa6, 0xcf, 0x3b, 0x3f, 0x2a, 0x6f, - 0x48, 0x66, 0x1b, 0x12, 0xfc, 0x29, 0x2f, 0x50, 0x52, 0x66, 0xdb, 0x8a, 0x4d, 0xf1, 0x66, 0xee, 0x02, 0x98, 0xac, - 0x27, 0x98, 0xbb, 0x6f, 0x5e, 0x72, 0x30, 0xc6, 0xba, 0x52, 0x45, 0xb9, 0xf1, 0x79, 0x9c, 0x75, 0xb9, 0x43, 0xd8, - 0x44, 0x16, 0x3d, 0x07, 0x81, 0xcd, 0xea, 0x5a, 0x1e, 0xcc, 0xc7, 0x9c, 0x64, 0x97, 0x35, 0xfa, 0x85, 0x49, 0x90, - 0x6e, 0xde, 0xf0, 0x5c, 0xb3, 0x42, 0xde, 0xbc, 0x2f, 0xb9, 0x11, 0xcc, 0x60, 0xb4, 0x11, 0x29, 0xb4, 0x75, 0xca, - 0xb0, 0x8f, 0x88, 0x5e, 0x49, 0x98, 0xfe, 0x41, 0x9e, 0xaf, 0x7e, 0x10, 0xa6, 0xe7, 0xeb, 0x05, 0xaa, 0xfa, 0x87, - 0x02, 0x5e, 0x4c, 0x38, 0xc0, 0x02, 0xea, 0xe8, 0xa5, 0x5c, 0xc7, 0x9a, 0xa0, 0x9c, 0x70, 0xa9, 0xaf, 0xd9, 0x28, - 0xaf, 0xa5, 0xfa, 0x84, 0xd6, 0xb1, 0x66, 0x03, 0x4c, 0x46, 0x37, 0xb6, 0xf1, 0xb7, 0x31, 0xb7, 0xe9, 0xb2, 0x7f, - 0xaa, 0xd8, 0x1e, 0x82, 0xb2, 0xe1, 0x02, 0x3e, 0xf7, 0x08, 0xdc, 0xb9, 0x9e, 0x80, 0xd6, 0x10, 0xff, 0xe3, 0x38, - 0xd6, 0xf2, 0x65, 0x9d, 0x29, 0x89, 0x55, 0x16, 0x42, 0x85, 0xca, 0x89, 0xfd, 0xdc, 0x30, 0xd7, 0x7a, 0x1c, 0x5c, - 0x23, 0xc1, 0x40, 0x70, 0x0a, 0x30, 0x89, 0xab, 0x29, 0x0d, 0x8d, 0x3b, 0x47, 0x7f, 0x78, 0x2d, 0xbf, 0xf0, 0xaa, - 0x5c, 0x17, 0xdc, 0xf4, 0xbd, 0x19, 0x01, 0xf3, 0x0b, 0xfb, 0xc2, 0xd1, 0x45, 0xcb, 0xe8, 0xfa, 0xec, 0x80, 0x04, - 0xc8, 0x63, 0x65, 0x19, 0x49, 0xd8, 0x92, 0xb5, 0x7a, 0x93, 0x9f, 0xef, 0x99, 0x42, 0x24, 0x5b, 0xa0, 0xca, 0xf1, - 0x0b, 0x6c, 0x2d, 0x2d, 0xa9, 0x64, 0x25, 0x5a, 0xab, 0x50, 0x81, 0x68, 0xad, 0x09, 0xd5, 0xaa, 0xd3, 0x7b, 0xdf, - 0x22, 0x3a, 0x2f, 0x8d, 0xd4, 0x21, 0x86, 0x80, 0x88, 0xa5, 0xf5, 0x9d, 0xd2, 0x46, 0xeb, 0xc9, 0xb2, 0xb8, 0xaf, - 0xc6, 0xf6, 0x6b, 0xb8, 0x7a, 0x26, 0xde, 0x54, 0xde, 0xd6, 0xc5, 0xc3, 0x9c, 0x55, 0x4e, 0x74, 0x5d, 0x87, 0x69, - 0xb3, 0xb6, 0xd3, 0x5f, 0xd5, 0x55, 0x26, 0x43, 0xf0, 0xb1, 0x87, 0x50, 0x73, 0xa1, 0x4a, 0x85, 0x48, 0x2f, 0x77, - 0x62, 0x73, 0xe5, 0x1e, 0x73, 0xa5, 0x73, 0x1c, 0xd9, 0x3a, 0xb6, 0x93, 0xe1, 0xa9, 0xc9, 0x05, 0x71, 0xec, 0xee, - 0x7e, 0x88, 0x0b, 0xfe, 0xcf, 0x17, 0xd2, 0x9c, 0xc7, 0xe7, 0x2f, 0xfd, 0xf4, 0x93, 0xb1, 0x92, 0xd2, 0x38, 0x99, - 0x65, 0x4d, 0x2f, 0xcb, 0x20, 0xce, 0x7f, 0xc6, 0xcb, 0x9c, 0x85, 0xd7, 0x59, 0xfb, 0x57, 0xc3, 0xad, 0x38, 0xb4, - 0x2e, 0x45, 0x32, 0x45, 0xb9, 0xfb, 0xd7, 0x71, 0x12, 0x22, 0xc3, 0x9f, 0xf3, 0x86, 0xb1, 0xf6, 0x69, 0xd5, 0x7c, - 0x24, 0x2b, 0x76, 0xf6, 0x7e, 0xe9, 0xb1, 0x71, 0x51, 0x70, 0x27, 0xc8, 0x95, 0x56, 0x4a, 0x0e, 0x8e, 0x03, 0x4d, - 0xe5, 0x03, 0x05, 0x7f, 0x98, 0x92, 0xc6, 0x53, 0xcc, 0x56, 0xdf, 0xa7, 0x36, 0xcb, 0x98, 0x0c, 0x8f, 0x74, 0x66, - 0xcc, 0x46, 0xad, 0xa0, 0xb4, 0xc7, 0xf9, 0xb0, 0xb0, 0xce, 0x69, 0x9b, 0x71, 0x4c, 0xf2, 0xc7, 0xb7, 0x0a, 0xd9, - 0xaa, 0x7c, 0xa9, 0xf7, 0x7b, 0x69, 0x6f, 0x93, 0x17, 0x2b, 0x7a, 0x2b, 0x4c, 0x84, 0x81, 0x88, 0x4a, 0x15, 0x34, - 0x12, 0xb2, 0xb0, 0xd3, 0x4e, 0xed, 0x0c, 0x55, 0x69, 0x31, 0x00, 0x3f, 0x86, 0xf5, 0xf1, 0xf8, 0x5a, 0x34, 0xa6, - 0xd6, 0x51, 0x23, 0x36, 0x2e, 0xe7, 0x19, 0x00, 0x2f, 0x54, 0x3c, 0xb3, 0x62, 0xfa, 0x8c, 0x9c, 0x39, 0x82, 0x2a, - 0x0b, 0x41, 0xda, 0x61, 0x28, 0xb6, 0xdc, 0x98, 0xaa, 0x0d, 0xe4, 0xc2, 0x9f, 0x75, 0x52, 0xa5, 0x11, 0xca, 0x21, - 0xd7, 0x26, 0xef, 0x32, 0xdf, 0x20, 0x44, 0x1f, 0xda, 0xf8, 0xeb, 0xc9, 0x8d, 0x04, 0x64, 0x0a, 0x38, 0x8f, 0x34, - 0x5e, 0xd3, 0xf7, 0x3c, 0x03, 0xde, 0x54, 0x6f, 0x92, 0x04, 0xe4, 0x59, 0x75, 0xa2, 0xdb, 0xf0, 0x90, 0x3c, 0xfb, - 0xad, 0x1c, 0x95, 0x7b, 0x72, 0xa5, 0x65, 0xdf, 0xea, 0x36, 0x63, 0xbe, 0x64, 0xed, 0xd2, 0xda, 0xdb, 0x09, 0xb3, - 0x4e, 0x53, 0x65, 0x4a, 0xc4, 0x83, 0x4a, 0xd2, 0xda, 0x19, 0x40, 0x98, 0xfa, 0xe9, 0x5b, 0xd4, 0x8e, 0x37, 0x92, - 0x73, 0x93, 0x01, 0x0b, 0xaa, 0xac, 0x5c, 0x76, 0x81, 0x44, 0x40, 0x6e, 0xdb, 0xf8, 0xa6, 0xc9, 0x12, 0x8c, 0xc8, - 0x3f, 0xa0, 0x77, 0xc1, 0x1d, 0xd9, 0x5b, 0xa0, 0x3b, 0xd3, 0xc7, 0x9e, 0x1a, 0xef, 0xca, 0x9a, 0xec, 0x42, 0x66, - 0xbe, 0x89, 0x81, 0x6b, 0x57, 0x2d, 0x21, 0xe1, 0xba, 0xb1, 0xcb, 0xbc, 0xa8, 0x33, 0x99, 0xad, 0x59, 0x95, 0xc7, - 0x6a, 0x98, 0x4a, 0x87, 0xa9, 0x9a, 0xb0, 0x25, 0xc8, 0x05, 0x84, 0xcb, 0x6b, 0x97, 0xeb, 0xf8, 0x2a, 0x01, 0x22, - 0x3d, 0x88, 0x93, 0x62, 0xec, 0xb9, 0x91, 0x77, 0xd7, 0xcb, 0x0a, 0x14, 0xc6, 0x3b, 0x6b, 0x92, 0x93, 0x4b, 0xed, - 0x4f, 0xc6, 0xdb, 0x56, 0x33, 0xdd, 0x8e, 0x2f, 0x12, 0xba, 0x16, 0xc7, 0x16, 0x7c, 0x49, 0xed, 0xde, 0xd5, 0x22, - 0x57, 0xed, 0x65, 0x01, 0xa3, 0x6d, 0x74, 0xd6, 0x6d, 0xb1, 0x30, 0xa7, 0x44, 0x38, 0x59, 0x36, 0xe6, 0x3b, 0x11, - 0x5e, 0x24, 0xd6, 0x18, 0xa8, 0x9d, 0x79, 0xe3, 0x4f, 0x0c, 0xc1, 0x09, 0xbe, 0x10, 0x5c, 0x2c, 0x8d, 0xf9, 0xf4, - 0x05, 0x11, 0xb1, 0x59, 0x1c, 0x9e, 0xad, 0x9b, 0xe0, 0x74, 0x8d, 0xeb, 0x0d, 0xb8, 0x1b, 0x58, 0xd4, 0xdf, 0xd1, - 0x83, 0x79, 0xfb, 0xa3, 0xb0, 0x69, 0x20, 0xc3, 0xe8, 0xd1, 0x23, 0x41, 0xdc, 0xd9, 0x1c, 0x4b, 0x4a, 0x24, 0x1c, - 0xf1, 0xeb, 0xe7, 0x08, 0x16, 0xb5, 0x2b, 0xa3, 0xa3, 0x31, 0x97, 0xfa, 0x07, 0xb9, 0xb4, 0xed, 0x2b, 0x60, 0xf1, - 0xcf, 0x50, 0x92, 0x94, 0x9d, 0x31, 0xc8, 0x6b, 0xdb, 0x80, 0xa9, 0x0a, 0xa8, 0xe3, 0x10, 0x7e, 0x52, 0x12, 0xee, - 0x66, 0x6b, 0x4a, 0xe5, 0xd2, 0x8c, 0x62, 0xcf, 0x1b, 0x44, 0xd1, 0xc5, 0x16, 0xe1, 0x24, 0x03, 0x27, 0xfa, 0x6a, - 0xa3, 0x20, 0x6f, 0xb5, 0xbd, 0xf8, 0x3c, 0x03, 0x67, 0x1d, 0x3a, 0x05, 0x34, 0x19, 0x25, 0x0d, 0xa1, 0x42, 0x1b, - 0xc2, 0xac, 0x0d, 0x2e, 0x5b, 0x11, 0x9a, 0x86, 0xcc, 0xb0, 0x0f, 0xf3, 0x79, 0xe0, 0x8c, 0x22, 0x41, 0x4f, 0xbb, - 0xd4, 0x6f, 0x56, 0xbf, 0xb9, 0x30, 0xdf, 0xdd, 0x48, 0x27, 0x02, 0x10, 0xad, 0xf4, 0xe9, 0xa1, 0x78, 0x91, 0x5b, - 0x10, 0x51, 0x6b, 0x0e, 0x6f, 0x09, 0x0e, 0x3e, 0x26, 0x2c, 0xb5, 0xea, 0xae, 0xb6, 0xf8, 0x17, 0x09, 0xdf, 0xb5, - 0x79, 0x40, 0xcc, 0x46, 0x6f, 0xe8, 0xfa, 0x5e, 0x9a, 0xa7, 0x92, 0xea, 0x89, 0x2d, 0x06, 0x2e, 0x0b, 0x05, 0x55, - 0xfc, 0x66, 0x7c, 0x8d, 0x91, 0x15, 0x01, 0x34, 0x38, 0xbd, 0xc5, 0x08, 0x1c, 0x32, 0xe6, 0xe5, 0xd8, 0x1f, 0xd7, - 0x6c, 0x82, 0x7c, 0xd6, 0x98, 0x90, 0x88, 0xb7, 0xbd, 0x37, 0xd8, 0x2a, 0x94, 0x8d, 0x44, 0x5a, 0x1e, 0x39, 0x8c, - 0x7b, 0x50, 0xf1, 0x30, 0x22, 0x36, 0xac, 0x29, 0xf3, 0x09, 0xa1, 0xcd, 0x1e, 0xc4, 0x9c, 0x5d, 0x98, 0xb0, 0xd0, - 0x4b, 0x0c, 0x44, 0xe8, 0x6d, 0x00, 0xfb, 0x46, 0x6c, 0x91, 0x48, 0x21, 0x89, 0x44, 0x3e, 0x9a, 0x13, 0xe2, 0xb0, - 0x15, 0x19, 0x1e, 0xac, 0xf6, 0x2e, 0x46, 0xf2, 0x67, 0x9c, 0x94, 0xd6, 0x65, 0x62, 0xf3, 0xc7, 0x28, 0x61, 0x0c, - 0x38, 0xbb, 0x3b, 0x29, 0xce, 0xbb, 0x61, 0xf9, 0xe8, 0x03, 0x15, 0x7c, 0xcb, 0x15, 0xc1, 0x1e, 0x4d, 0xe4, 0x48, - 0x95, 0x15, 0xcb, 0xb9, 0x7e, 0x14, 0x1a, 0x3c, 0x65, 0xe1, 0xa8, 0x6a, 0xc3, 0x48, 0x10, 0x51, 0x69, 0x5c, 0x30, - 0x5a, 0xc9, 0x40, 0x47, 0x63, 0xda, 0x6a, 0x44, 0xb8, 0x80, 0xe7, 0x59, 0xfb, 0xa7, 0x05, 0xe3, 0x3c, 0x5e, 0x86, - 0xe3, 0x0f, 0x9a, 0x41, 0xff, 0x1d, 0x99, 0x8c, 0x96, 0x4f, 0xee, 0x46, 0xff, 0x49, 0x3f, 0x68, 0x67, 0xef, 0xf7, - 0xd5, 0xe9, 0xc7, 0xbe, 0x5c, 0x48, 0x43, 0x7e, 0xa1, 0x2b, 0x57, 0x73, 0xbb, 0x35, 0x3c, 0x30, 0x35, 0xb7, 0xd3, - 0xeb, 0x04, 0xf5, 0xce, 0xb9, 0x41, 0xdb, 0x86, 0x0d, 0x4c, 0xe2, 0x31, 0xe7, 0xc9, 0x68, 0xac, 0xc8, 0x80, 0x5a, - 0xc1, 0xca, 0x3c, 0x4b, 0x70, 0xd7, 0x67, 0xc6, 0xe0, 0x9e, 0xb8, 0x28, 0xb3, 0xe4, 0xde, 0x07, 0xe0, 0x24, 0x68, - 0xfe, 0x92, 0xdd, 0xa2, 0x7e, 0xa2, 0x5a, 0x74, 0x07, 0x29, 0x43, 0xad, 0x25, 0xde, 0x57, 0xb5, 0xc6, 0x10, 0xec, - 0x0d, 0x00, 0xad, 0xa9, 0xd5, 0x87, 0x89, 0x1c, 0xf2, 0xc7, 0x56, 0xf5, 0x41, 0x69, 0xa2, 0x2e, 0x18, 0x90, 0xa7, - 0xe6, 0x97, 0x2e, 0x11, 0x26, 0x9d, 0xd4, 0xff, 0xab, 0x97, 0xff, 0x6d, 0x0c, 0x94, 0x89, 0xca, 0xdb, 0x90, 0x87, - 0x93, 0xc7, 0xbd, 0x29, 0xde, 0xd2, 0xf9, 0x46, 0x1b, 0xee, 0x04, 0x4f, 0xf2, 0xf0, 0xfa, 0xbc, 0xb5, 0x37, 0x43, - 0xdc, 0xd7, 0xd1, 0xa6, 0xb2, 0x6d, 0x52, 0x52, 0x52, 0x1d, 0x9c, 0x81, 0x25, 0xda, 0x05, 0x4d, 0xcb, 0x79, 0xa4, - 0x1c, 0xcb, 0x36, 0xa9, 0x72, 0x0b, 0x78, 0xca, 0x29, 0xe5, 0x3f, 0x04, 0x1d, 0xa5, 0x9a, 0x47, 0xcd, 0x65, 0x79, - 0xea, 0x52, 0x58, 0x5b, 0x21, 0xba, 0x37, 0xa7, 0xfc, 0x62, 0x96, 0xb4, 0x94, 0x6a, 0x93, 0x00, 0x91, 0xc6, 0x7b, - 0x9a, 0x58, 0xd6, 0x03, 0xe8, 0x44, 0xd5, 0x2e, 0x61, 0x12, 0x43, 0x3b, 0xd9, 0x86, 0xba, 0xfa, 0x68, 0x15, 0xd6, - 0xe7, 0x2f, 0x68, 0x78, 0xb5, 0xdf, 0xd2, 0x23, 0x46, 0xcd, 0x1a, 0xde, 0x1f, 0x1e, 0x4a, 0x70, 0xb1, 0x69, 0xec, - 0x6c, 0xb3, 0x26, 0x0e, 0x3b, 0x7e, 0x0e, 0x2b, 0x08, 0xa6, 0x67, 0x47, 0x1b, 0xc6, 0x6a, 0x70, 0x7c, 0x95, 0x5f, - 0xed, 0x7a, 0x31, 0xa0, 0x26, 0x52, 0xdc, 0x29, 0x72, 0xc0, 0x00, 0x13, 0x2d, 0xe4, 0xcd, 0xd3, 0x79, 0xfc, 0x21, - 0xbe, 0x1e, 0x0f, 0xb4, 0x9f, 0x20, 0x8f, 0x9e, 0x05, 0x8a, 0x0c, 0x50, 0xd1, 0x93, 0xfb, 0x8b, 0x53, 0x28, 0xc3, - 0x6e, 0xa2, 0xd3, 0x41, 0xd1, 0xed, 0xdd, 0x23, 0x6f, 0x7c, 0xbc, 0xa9, 0xca, 0xe5, 0x3c, 0xc2, 0x40, 0xd7, 0x1b, - 0xd8, 0x40, 0x11, 0x19, 0xcb, 0x2a, 0xc5, 0x8f, 0x31, 0xaa, 0x0c, 0x51, 0x70, 0xab, 0x4f, 0x58, 0xc3, 0x45, 0x60, - 0xef, 0x10, 0x26, 0x09, 0xa3, 0x47, 0xee, 0xb9, 0xa9, 0x79, 0x72, 0xcd, 0xec, 0x3c, 0xca, 0x1c, 0xac, 0x2a, 0x0e, - 0x4c, 0x98, 0xb2, 0x41, 0x31, 0x79, 0x2c, 0x97, 0x72, 0xab, 0x55, 0x37, 0x73, 0xa2, 0x98, 0x1e, 0xd9, 0xc3, 0xd0, - 0xc2, 0x4d, 0xba, 0x21, 0x46, 0x7f, 0xe1, 0x85, 0x7e, 0xb4, 0x1a, 0x04, 0x43, 0xb4, 0xc2, 0xce, 0xda, 0x28, 0x67, - 0x8c, 0xa2, 0xf8, 0xfb, 0x02, 0x10, 0x6c, 0xeb, 0xfa, 0x96, 0xae, 0x3e, 0x79, 0x6b, 0x77, 0xab, 0x4a, 0xcf, 0x83, - 0x12, 0x23, 0x7e, 0xcd, 0x2a, 0xe7, 0x9d, 0xea, 0x40, 0xe2, 0x87, 0x50, 0x69, 0x01, 0x57, 0x84, 0xb0, 0x4a, 0xe3, - 0x60, 0x02, 0x9c, 0xce, 0x45, 0x53, 0xdf, 0x45, 0x03, 0x48, 0x28, 0x93, 0xf8, 0xe4, 0x3c, 0x9b, 0x84, 0x5a, 0x1e, - 0x1d, 0xd2, 0x7b, 0xb7, 0x0e, 0x42, 0xe1, 0x3b, 0x53, 0xad, 0x17, 0xdc, 0x3d, 0xa5, 0xfd, 0x7a, 0xed, 0x0b, 0x2b, - 0x95, 0xc6, 0xfd, 0x77, 0xd3, 0xc7, 0xb7, 0xdf, 0xf1, 0xe2, 0xa8, 0xef, 0x26, 0xce, 0x86, 0xe5, 0x5b, 0x1e, 0x80, - 0x37, 0x0b, 0x0e, 0x08, 0xf0, 0x11, 0xf5, 0x54, 0xa7, 0xfd, 0x1e, 0xba, 0xf1, 0x75, 0x66, 0xf6, 0x2c, 0xe9, 0xfc, - 0x9d, 0x1f, 0x7c, 0xd8, 0xb6, 0x20, 0xd0, 0x05, 0xe3, 0xff, 0xa3, 0xa5, 0x02, 0x02, 0x50, 0xf0, 0xf7, 0xe1, 0x75, - 0x38, 0x45, 0xc1, 0x73, 0x18, 0xf5, 0x71, 0x44, 0x99, 0xee, 0x9d, 0x34, 0xf9, 0x5e, 0x45, 0x36, 0xcb, 0xbc, 0x42, - 0x36, 0x61, 0x6c, 0x7a, 0x59, 0xa7, 0x7c, 0x6d, 0x66, 0x60, 0xac, 0xbe, 0x04, 0xa8, 0x8c, 0x44, 0x6f, 0x4a, 0xbf, - 0x84, 0x5f, 0x5f, 0x8a, 0xc5, 0x90, 0x07, 0xdf, 0x69, 0xf5, 0xda, 0xad, 0x8f, 0x8d, 0xdf, 0xae, 0xdc, 0x83, 0xa1, - 0x0f, 0x42, 0xee, 0xe7, 0x0d, 0x59, 0x19, 0x47, 0x9b, 0xe7, 0x05, 0x97, 0xc6, 0xcb, 0x28, 0x97, 0x86, 0x8e, 0x24, - 0x6a, 0x03, 0x7d, 0x5a, 0x5a, 0x72, 0xc0, 0x65, 0x48, 0x8c, 0xfd, 0x20, 0x2b, 0x3d, 0x3e, 0x92, 0xf6, 0xc1, 0xe4, - 0x18, 0x3e, 0x9f, 0x6e, 0x71, 0x11, 0xef, 0x44, 0x60, 0xc7, 0x40, 0x95, 0x1b, 0xae, 0xda, 0xdb, 0xbd, 0xbd, 0xfd, - 0xc3, 0xf6, 0xe1, 0x66, 0xfd, 0x75, 0x85, 0x0e, 0xa9, 0xc6, 0x38, 0x9d, 0x5a, 0xab, 0xb5, 0x9c, 0xb4, 0x85, 0xbf, - 0xb7, 0x2c, 0xda, 0x24, 0xa4, 0x48, 0x0c, 0x98, 0x5b, 0x46, 0x26, 0x55, 0x2b, 0x0f, 0x30, 0x91, 0x9a, 0xba, 0x4d, - 0x4f, 0xf7, 0x99, 0x92, 0xa5, 0x06, 0xbd, 0xd8, 0xe9, 0xaa, 0x10, 0xeb, 0xa5, 0xeb, 0xc7, 0x8b, 0xa5, 0xd7, 0xba, - 0x2e, 0xb0, 0x89, 0x6c, 0x18, 0x48, 0x1d, 0x7f, 0xc7, 0x46, 0xee, 0xd7, 0xc3, 0x93, 0x25, 0x80, 0xc2, 0x25, 0xd2, - 0x75, 0x09, 0x72, 0xb4, 0x29, 0x49, 0x48, 0x2e, 0x5e, 0xa1, 0x8a, 0xf1, 0xa4, 0x66, 0x7b, 0xf3, 0x6c, 0x21, 0x12, - 0x19, 0x4a, 0x19, 0x1b, 0xbb, 0x9b, 0x74, 0xef, 0x02, 0x1c, 0xd4, 0xa2, 0x2e, 0xd7, 0x17, 0x55, 0x80, 0xed, 0x9c, - 0xbf, 0x1a, 0x8d, 0xf3, 0xa8, 0x89, 0x6e, 0xd7, 0xb0, 0x2f, 0xbb, 0xe6, 0x4c, 0x6e, 0x2e, 0x9d, 0xe6, 0xf9, 0x91, - 0xcf, 0x16, 0xab, 0x67, 0x18, 0x5c, 0xee, 0x3a, 0x01, 0x03, 0x54, 0xee, 0x95, 0x01, 0x7c, 0xcb, 0x02, 0xeb, 0x06, - 0x73, 0x49, 0x64, 0x93, 0x44, 0x5b, 0xbb, 0xa7, 0x9c, 0x84, 0x26, 0xb7, 0xee, 0x59, 0xe2, 0xca, 0x0f, 0x82, 0xaa, - 0x6c, 0xf3, 0xb4, 0x5e, 0x34, 0xf7, 0x68, 0xe9, 0x7f, 0x7a, 0x58, 0x04, 0x45, 0x81, 0xe6, 0xe1, 0x2d, 0x52, 0x73, - 0x98, 0x05, 0x51, 0x63, 0x27, 0xbc, 0xa1, 0x7d, 0x60, 0xad, 0x6d, 0xd4, 0x8e, 0x54, 0xef, 0x6f, 0x90, 0x12, 0xd6, - 0xec, 0x92, 0x14, 0x2c, 0x2b, 0xe2, 0x72, 0xd0, 0x8e, 0x08, 0xf0, 0x58, 0xd9, 0x0a, 0x1e, 0xe5, 0xc5, 0xdd, 0x6c, - 0xec, 0x0b, 0x64, 0xac, 0xc9, 0x1c, 0x74, 0x0d, 0xbf, 0x45, 0xa8, 0xd6, 0x56, 0xb7, 0x83, 0xb5, 0x7b, 0xc3, 0x34, - 0xd1, 0x3a, 0x09, 0x76, 0x44, 0x49, 0xfb, 0x05, 0x07, 0x6e, 0xaa, 0xca, 0x8e, 0xdc, 0x5b, 0x89, 0x34, 0x68, 0x57, - 0xe8, 0xfc, 0x75, 0x37, 0x35, 0x02, 0xde, 0x4c, 0xa7, 0xe4, 0x28, 0xf1, 0x89, 0x94, 0x41, 0x41, 0x49, 0x72, 0xfe, - 0x9f, 0xf5, 0xb1, 0x03, 0x05, 0xf1, 0x8d, 0x9f, 0x7f, 0x17, 0x04, 0x38, 0xb0, 0xdb, 0x41, 0xd6, 0xbe, 0x1c, 0x4b, - 0x60, 0x51, 0x85, 0x39, 0xd7, 0x83, 0x5a, 0xff, 0x9e, 0x17, 0xe1, 0xf9, 0xaf, 0x17, 0x5b, 0xaa, 0x75, 0xdb, 0x5e, - 0xf7, 0x16, 0xc9, 0x35, 0x63, 0x3b, 0xec, 0xcb, 0xc1, 0x87, 0xd3, 0x4c, 0xb2, 0x05, 0x24, 0x0d, 0x99, 0xbe, 0x94, - 0x36, 0xe9, 0x86, 0x03, 0x72, 0x07, 0x64, 0x70, 0x10, 0x68, 0x32, 0x28, 0x6b, 0x78, 0xac, 0xe6, 0xe1, 0xbc, 0xbd, - 0x7a, 0xf2, 0xd7, 0x2a, 0x5f, 0xa2, 0x43, 0xea, 0x9d, 0xc5, 0x80, 0xff, 0x7e, 0x2b, 0x18, 0xc9, 0xf6, 0xcd, 0x7e, - 0x77, 0xd3, 0x94, 0xe2, 0x0a, 0xa6, 0xfd, 0x83, 0xff, 0x3f, 0xf4, 0x16, 0x5e, 0xef, 0x64, 0x68, 0xaa, 0xc3, 0x94, - 0x1b, 0xd6, 0x8b, 0x0b, 0xf9, 0xae, 0x4c, 0x8c, 0x11, 0x04, 0x46, 0x60, 0x56, 0x97, 0xe8, 0x1e, 0x86, 0x3b, 0xeb, - 0x51, 0xcd, 0x70, 0x72, 0x69, 0x33, 0x86, 0x55, 0x0b, 0x11, 0x01, 0x2e, 0x51, 0xa0, 0x44, 0x91, 0x20, 0x89, 0x01, - 0xa2, 0x7b, 0xeb, 0xf3, 0x08, 0x65, 0x51, 0xb3, 0xbe, 0xa1, 0xb6, 0xb3, 0xb2, 0x39, 0x09, 0x68, 0x6d, 0xe6, 0x98, - 0x56, 0xa3, 0x00, 0x9d, 0xbb, 0xd3, 0x00, 0x3a, 0xf4, 0x16, 0xe9, 0xa5, 0x8c, 0x15, 0xfb, 0xae, 0x67, 0x6d, 0xe9, - 0x90, 0x4f, 0xa2, 0xd6, 0xea, 0x20, 0xad, 0x55, 0x4e, 0x45, 0x66, 0x42, 0x5f, 0xe8, 0xd2, 0xc2, 0x19, 0xe8, 0x1b, - 0x6f, 0x0f, 0xd6, 0x78, 0x4a, 0x6f, 0xf2, 0xa5, 0x29, 0xe5, 0x65, 0x8f, 0x09, 0xf7, 0x3b, 0xa9, 0x8c, 0xed, 0xad, - 0x01, 0x91, 0x4b, 0xfa, 0xbb, 0x87, 0x84, 0x66, 0x1e, 0xbd, 0x0d, 0x38, 0xec, 0x82, 0x56, 0xfc, 0xaa, 0x7a, 0xbc, - 0x63, 0x82, 0x87, 0xa5, 0x34, 0xf9, 0xfe, 0xc5, 0x9b, 0x61, 0xd6, 0x30, 0x5e, 0x58, 0xec, 0x82, 0x80, 0x82, 0xd9, - 0x5b, 0xcc, 0xdd, 0xff, 0xe5, 0x8f, 0xd6, 0xc0, 0x8d, 0x99, 0x43, 0x6e, 0x3e, 0xe0, 0xf1, 0x3d, 0xbd, 0x4f, 0xbd, - 0x9b, 0xd5, 0xab, 0x4f, 0xa7, 0xc5, 0x85, 0x91, 0xf7, 0xed, 0x74, 0xb4, 0x47, 0x24, 0x5c, 0x03, 0x30, 0x01, 0x50, - 0x96, 0x78, 0x40, 0x09, 0x8b, 0xf7, 0xe5, 0xd2, 0x2a, 0x3b, 0x01, 0x4d, 0xb5, 0x67, 0x9b, 0x3a, 0x72, 0xe1, 0x19, - 0xdb, 0x51, 0x2c, 0x6d, 0xa7, 0x29, 0x61, 0xf2, 0x5a, 0xd7, 0xee, 0xf4, 0xf2, 0xa3, 0x34, 0x81, 0x9a, 0xa9, 0x5c, - 0x29, 0xbf, 0x46, 0xd6, 0x10, 0x7c, 0x0a, 0x8b, 0x28, 0x2a, 0xc0, 0xb3, 0xe8, 0x04, 0xaa, 0xd6, 0x0f, 0xed, 0x77, - 0x77, 0x58, 0x6c, 0x5d, 0x4c, 0x8f, 0x1f, 0x2a, 0x90, 0x79, 0xe6, 0xb8, 0x73, 0xa6, 0xd9, 0xd1, 0x4d, 0xe3, 0x5d, - 0x4c, 0xd9, 0x4f, 0x5f, 0xa0, 0x4f, 0x16, 0x66, 0x76, 0x2f, 0x68, 0x2c, 0x83, 0x27, 0x45, 0x36, 0x48, 0x91, 0xef, - 0xc2, 0x10, 0xc6, 0x48, 0xa5, 0x33, 0x35, 0x8f, 0xd1, 0xf4, 0xb7, 0xd0, 0x16, 0x4c, 0xed, 0xde, 0x53, 0x7d, 0xe8, - 0x7a, 0xa3, 0x54, 0x6b, 0xdf, 0x49, 0x99, 0x49, 0x2f, 0x61, 0xa4, 0x68, 0xb7, 0xd7, 0xea, 0xa7, 0x5f, 0x2b, 0x73, - 0xa9, 0xf6, 0xd2, 0x34, 0x79, 0x11, 0xdd, 0x29, 0xc8, 0xe2, 0x70, 0x31, 0xa5, 0xb4, 0x7d, 0x52, 0xfd, 0x7b, 0xbf, - 0xb8, 0x41, 0xfc, 0x6c, 0xfc, 0x63, 0xe6, 0xf3, 0xc0, 0x97, 0xba, 0xb4, 0x01, 0x72, 0x7f, 0x72, 0x6f, 0x95, 0x18, - 0x86, 0x21, 0x05, 0x64, 0xe5, 0x6a, 0x09, 0x58, 0x14, 0xc8, 0x03, 0x15, 0x10, 0x8d, 0x38, 0xa3, 0x1d, 0x52, 0x6b, - 0xd6, 0x97, 0x25, 0x40, 0x18, 0x70, 0xed, 0x2f, 0x34, 0xce, 0x7e, 0xb1, 0xb7, 0x20, 0xa8, 0x65, 0xc3, 0x4b, 0x9e, - 0x3f, 0x02, 0x23, 0x03, 0x84, 0x9c, 0x1e, 0x89, 0x3d, 0x8b, 0xd1, 0xbc, 0xa2, 0xb3, 0xe8, 0x81, 0x8c, 0x85, 0x9a, - 0x2a, 0x6f, 0xec, 0x04, 0x98, 0xdd, 0x07, 0x97, 0x54, 0xf5, 0x18, 0x0c, 0xe0, 0x05, 0x44, 0x05, 0xac, 0x68, 0x02, - 0x9d, 0xfa, 0xd8, 0x10, 0x07, 0x6f, 0x68, 0x51, 0x80, 0x20, 0xb0, 0x37, 0x10, 0xf6, 0x27, 0xd6, 0x1f, 0x5c, 0xcd, - 0xb0, 0xcb, 0x30, 0x8d, 0xe3, 0xd0, 0xd0, 0x9e, 0x82, 0x9f, 0x0a, 0x9b, 0x68, 0xaa, 0x04, 0x28, 0x37, 0x09, 0xb1, - 0x07, 0x01, 0xff, 0xca, 0x23, 0xf2, 0xb8, 0x6e, 0x6a, 0xff, 0x09, 0xa6, 0x38, 0x2a, 0x83, 0x75, 0x9b, 0xba, 0xeb, - 0xef, 0x75, 0x19, 0xc7, 0x35, 0xa0, 0xb0, 0xa5, 0x73, 0x9c, 0x1e, 0xd3, 0x10, 0xff, 0x6b, 0xa0, 0x7f, 0xd7, 0xaa, - 0xad, 0xef, 0x42, 0x6c, 0xd6, 0x66, 0xcc, 0x07, 0x0d, 0xbb, 0x8b, 0x13, 0xe3, 0xc8, 0xe3, 0xbe, 0xc0, 0xb4, 0x6b, - 0x89, 0x8f, 0x34, 0xf4, 0xe4, 0x11, 0x94, 0x9e, 0xae, 0x76, 0x95, 0xf1, 0xab, 0xf1, 0x78, 0x7b, 0xb3, 0xf5, 0x2a, - 0x86, 0x98, 0x11, 0x05, 0x6c, 0xf5, 0x3b, 0xeb, 0xf8, 0xe4, 0x60, 0x39, 0x8e, 0xb9, 0xf5, 0x12, 0x35, 0xae, 0x2f, - 0xb2, 0x14, 0x8b, 0x54, 0xfb, 0x72, 0xf7, 0x35, 0x1f, 0x4c, 0xaf, 0x7c, 0xfc, 0xfb, 0xf3, 0x50, 0x08, 0x2e, 0xa8, - 0x12, 0x23, 0xd1, 0x40, 0x77, 0x6e, 0x5b, 0x41, 0x0b, 0xbf, 0x95, 0x94, 0x56, 0x3c, 0x0f, 0x56, 0xa3, 0x5d, 0x02, - 0x42, 0x55, 0x03, 0x5e, 0x9f, 0xa2, 0xc9, 0x85, 0x03, 0xc7, 0x08, 0xb5, 0x68, 0x72, 0x96, 0x30, 0x9c, 0x74, 0xfb, - 0x6d, 0x7e, 0xfa, 0xeb, 0x9c, 0x0c, 0x91, 0x02, 0x90, 0xfa, 0x76, 0x4c, 0xf8, 0xf4, 0x3b, 0x5e, 0x4c, 0xfe, 0xf3, - 0x8d, 0x90, 0xbe, 0xe9, 0xc4, 0xc6, 0x43, 0x90, 0x37, 0x8a, 0x42, 0x84, 0x08, 0x76, 0x71, 0x20, 0xcc, 0x76, 0xf8, - 0x95, 0xdc, 0xc2, 0x57, 0xf4, 0x96, 0x9a, 0xa3, 0xa7, 0xd1, 0x41, 0x0b, 0x27, 0xac, 0x4d, 0x7f, 0x9e, 0x47, 0x5f, - 0x60, 0xc0, 0xe1, 0x33, 0x2b, 0xc0, 0x8d, 0x61, 0x15, 0xc0, 0x5a, 0x63, 0xee, 0x18, 0xbe, 0x96, 0xe9, 0x89, 0xb5, - 0xcc, 0x01, 0xf8, 0xb8, 0x92, 0xe3, 0x86, 0xee, 0x1c, 0x2a, 0x05, 0xf3, 0x76, 0x60, 0x8b, 0xfc, 0x9f, 0x69, 0x47, - 0x59, 0x55, 0x4c, 0x2c, 0x03, 0xe1, 0x72, 0x44, 0x42, 0xe6, 0xeb, 0xde, 0xc5, 0x20, 0x0a, 0x3e, 0x62, 0x64, 0xa7, - 0x54, 0x5c, 0xe7, 0x26, 0xbf, 0xea, 0x9f, 0x5f, 0x22, 0xf6, 0xba, 0x78, 0x5d, 0xbf, 0x7f, 0xe8, 0xef, 0xfe, 0xa4, - 0x15, 0xa0, 0x7a, 0xae, 0xec, 0xca, 0x6a, 0x26, 0x07, 0x9b, 0xc8, 0xf0, 0x73, 0xbd, 0x84, 0xca, 0xb4, 0x99, 0x00, - 0x21, 0x9c, 0xe3, 0x72, 0x72, 0x3d, 0x5a, 0x4c, 0xfc, 0x04, 0xd2, 0x18, 0x7a, 0x09, 0x4a, 0xe6, 0xfd, 0x11, 0x1e, - 0x5c, 0x0e, 0x08, 0xc4, 0xbb, 0xb8, 0x0a, 0x39, 0x5a, 0x1a, 0x24, 0x31, 0xbb, 0x9f, 0x62, 0x08, 0x25, 0x2e, 0x23, - 0x05, 0x6a, 0xd9, 0x9a, 0xb2, 0x6f, 0xc1, 0x72, 0x47, 0xd5, 0x61, 0x47, 0x98, 0x29, 0x4c, 0x95, 0xc8, 0x7f, 0x78, - 0x8c, 0xa4, 0x0a, 0x4f, 0xdd, 0xc9, 0xb3, 0x15, 0x52, 0x96, 0x93, 0x06, 0x12, 0x12, 0x78, 0x28, 0x44, 0x01, 0xfa, - 0x01, 0x5b, 0xa3, 0x8a, 0xc7, 0xff, 0x61, 0x5b, 0x02, 0xdd, 0x12, 0x9f, 0x58, 0x76, 0xbc, 0x61, 0x68, 0x0e, 0x79, - 0x8c, 0x44, 0x11, 0xb4, 0xc2, 0xcf, 0xaa, 0xe4, 0x07, 0x81, 0x12, 0x50, 0xc6, 0x45, 0x76, 0x14, 0xa8, 0x4a, 0x4c, - 0x70, 0x35, 0xd0, 0x83, 0xe8, 0xde, 0x65, 0xa0, 0x69, 0x3a, 0x78, 0xed, 0xd0, 0x30, 0x96, 0xc6, 0x54, 0x07, 0xdb, - 0x51, 0x21, 0x38, 0xd2, 0xe9, 0x90, 0x51, 0x70, 0x72, 0xfb, 0x0e, 0x97, 0x0d, 0x39, 0xdd, 0xee, 0x5a, 0xa1, 0xe8, - 0x19, 0xc8, 0xea, 0x5c, 0x6c, 0x9e, 0x67, 0x63, 0x22, 0x40, 0xfa, 0xc4, 0x3c, 0x54, 0x9c, 0x97, 0x19, 0x98, 0x36, - 0x79, 0xbc, 0x2d, 0x13, 0xc5, 0x1c, 0x4b, 0xae, 0x86, 0x7d, 0xc4, 0xd3, 0x7c, 0x3d, 0x93, 0xb2, 0xdf, 0x85, 0x01, - 0x47, 0x62, 0x98, 0xf5, 0x3b, 0xed, 0xf3, 0xda, 0x68, 0x73, 0x09, 0xf5, 0xa6, 0xc2, 0x24, 0xd1, 0xec, 0x58, 0x43, - 0xbd, 0x0a, 0x2d, 0x7e, 0x32, 0xb0, 0x7e, 0x0d, 0xa9, 0x37, 0x52, 0x33, 0xec, 0x8a, 0xe7, 0x23, 0x8f, 0x1f, 0xdd, - 0xa6, 0x56, 0xd6, 0x95, 0xd5, 0xcc, 0x36, 0x95, 0x18, 0xdf, 0x0f, 0xbb, 0xad, 0x6a, 0xcf, 0xb4, 0xca, 0xc7, 0xc3, - 0x97, 0x94, 0x4e, 0x07, 0xa2, 0xa9, 0x30, 0xb0, 0x87, 0x50, 0xc7, 0x02, 0xad, 0x8d, 0xc5, 0x2e, 0xca, 0xa3, 0x32, - 0xa5, 0xad, 0xd2, 0x18, 0xc6, 0x50, 0x1b, 0xc0, 0xd5, 0xed, 0x7a, 0x90, 0x96, 0x51, 0xd6, 0x5d, 0x4a, 0x0b, 0xc5, - 0x74, 0x0c, 0x6b, 0x85, 0x33, 0x25, 0xc3, 0x4d, 0x21, 0x4e, 0x03, 0x7c, 0x79, 0xe1, 0xff, 0xfe, 0x00, 0x56, 0xcd, - 0xed, 0x8e, 0x64, 0x1b, 0x97, 0x1d, 0x5d, 0x69, 0x85, 0xe7, 0xe9, 0xbc, 0x7c, 0x91, 0xb2, 0x2d, 0xd5, 0xa2, 0x61, - 0x1a, 0x1d, 0x65, 0x0c, 0xb5, 0x7d, 0xbb, 0x98, 0x31, 0x9c, 0x61, 0xc4, 0x5c, 0xf9, 0x06, 0x67, 0xbd, 0x96, 0xbc, - 0xfb, 0x2d, 0x23, 0xa7, 0x52, 0x5c, 0xf1, 0xa2, 0x4a, 0x0d, 0xaf, 0x7c, 0xf2, 0x1f, 0xe4, 0x6d, 0x52, 0xfc, 0x6a, - 0xd5, 0x18, 0x4a, 0x92, 0xcb, 0x89, 0xce, 0x9b, 0xd7, 0x70, 0xc2, 0xdb, 0x9e, 0xa6, 0x62, 0x86, 0xe2, 0xb1, 0x04, - 0xbf, 0xab, 0x3a, 0xdb, 0xcd, 0x1f, 0x7c, 0x2e, 0xc8, 0x5a, 0x4c, 0x96, 0xe5, 0xab, 0x0a, 0xce, 0xa4, 0x1e, 0x3f, - 0x7b, 0xb8, 0x53, 0x12, 0xa4, 0xba, 0x6d, 0xc8, 0xa7, 0x41, 0xa4, 0xb7, 0xcd, 0xea, 0x28, 0x43, 0x5e, 0x99, 0xd8, - 0x84, 0xa9, 0x53, 0xc7, 0x1b, 0x77, 0x5b, 0x2a, 0x26, 0x3b, 0x13, 0xe7, 0xe1, 0xff, 0xcc, 0x16, 0xbe, 0x4d, 0x3d, - 0xf9, 0x2b, 0xb6, 0x74, 0x90, 0xfc, 0x0a, 0xc4, 0x87, 0x63, 0x04, 0xf3, 0x39, 0x7d, 0x87, 0xc2, 0xa3, 0x8e, 0x65, - 0x60, 0x60, 0x62, 0xe5, 0xd9, 0x77, 0xfc, 0xdb, 0xf1, 0x96, 0x58, 0xa3, 0xb2, 0xca, 0x50, 0x0c, 0xc1, 0x20, 0xcd, - 0xeb, 0x00, 0x40, 0xae, 0x6c, 0x2a, 0xb6, 0x05, 0x22, 0x5b, 0x5e, 0x44, 0x8b, 0x77, 0xda, 0xb9, 0x11, 0xdc, 0x94, - 0xf8, 0x94, 0xbd, 0x3d, 0x65, 0x0c, 0x70, 0x0b, 0xec, 0x74, 0xec, 0xe0, 0x81, 0x98, 0x23, 0xa1, 0x76, 0x45, 0x16, - 0x4b, 0x52, 0x87, 0x8a, 0x45, 0xb3, 0xbe, 0x50, 0x62, 0x22, 0x86, 0x6c, 0x4d, 0x9d, 0x60, 0x45, 0xea, 0xa8, 0x3d, - 0x07, 0x16, 0x25, 0xcd, 0x3e, 0x43, 0x5e, 0x4c, 0x72, 0xc7, 0x44, 0x34, 0xe3, 0xc1, 0xcf, 0x42, 0x49, 0xcf, 0xbd, - 0x89, 0x85, 0xfc, 0xdd, 0x66, 0xf9, 0x0c, 0x7b, 0x87, 0x3f, 0x49, 0x15, 0xbe, 0x9c, 0xc2, 0x6a, 0x92, 0xd0, 0x56, - 0x2e, 0xbc, 0x5d, 0x12, 0xa0, 0x40, 0x59, 0xda, 0xa7, 0xc1, 0x81, 0x42, 0x1f, 0x0a, 0xca, 0x16, 0xcb, 0x94, 0x12, - 0x33, 0xe3, 0x22, 0xa6, 0xe4, 0x5e, 0xf4, 0x79, 0x3c, 0x5f, 0xd3, 0x77, 0x40, 0xa0, 0x72, 0xb3, 0xdf, 0x6c, 0x4c, - 0x72, 0xc0, 0xd0, 0x4c, 0x7f, 0xc2, 0x27, 0xb4, 0x7b, 0xbd, 0x64, 0x3f, 0x72, 0xe0, 0xfb, 0xc0, 0x71, 0x30, 0x7b, - 0xf2, 0x43, 0xca, 0x59, 0xab, 0xea, 0x3e, 0x0b, 0xf8, 0xfb, 0xe2, 0x05, 0xe2, 0xca, 0x24, 0x04, 0xba, 0x8b, 0x49, - 0x82, 0xd5, 0xa7, 0x60, 0x48, 0x3a, 0x01, 0x5d, 0xac, 0xb0, 0xb9, 0xd6, 0x6c, 0x39, 0x41, 0x17, 0x53, 0x59, 0xc1, - 0x9d, 0x3a, 0x94, 0xea, 0xe5, 0x61, 0x66, 0x3d, 0xac, 0xa6, 0xa7, 0x29, 0x48, 0x22, 0x9d, 0xec, 0xf6, 0x53, 0x92, - 0xbd, 0x26, 0x61, 0x64, 0xdf, 0x37, 0x33, 0x22, 0x00, 0xbe, 0xe8, 0x15, 0x22, 0xf6, 0xbd, 0x48, 0x39, 0x49, 0xa5, - 0x6b, 0xce, 0xe4, 0xb6, 0x42, 0x83, 0x58, 0x17, 0xfe, 0x55, 0x50, 0x37, 0xa5, 0xf9, 0x14, 0xdc, 0xa9, 0xbe, 0x81, - 0x5d, 0x02, 0xaf, 0xcd, 0xbb, 0x10, 0x34, 0x8d, 0x0d, 0xbe, 0x04, 0xb0, 0xb8, 0x0b, 0x03, 0x4f, 0xe0, 0x17, 0x5e, - 0x07, 0x70, 0xb3, 0x59, 0xa1, 0x56, 0x31, 0xd1, 0x9b, 0xf9, 0xa3, 0x5e, 0xd9, 0x78, 0xde, 0x9d, 0x04, 0x0b, 0xcb, - 0x49, 0x90, 0x7d, 0x86, 0x01, 0x2d, 0x5d, 0xbf, 0xe3, 0x62, 0x55, 0x0a, 0x2a, 0x21, 0xa4, 0xf4, 0xdd, 0xbf, 0x99, - 0xef, 0xe9, 0xb4, 0x5e, 0x8c, 0xf4, 0xcc, 0x00, 0x82, 0x5b, 0x92, 0x79, 0xd7, 0xd1, 0xb7, 0xa6, 0x67, 0x11, 0xf7, - 0x24, 0x2f, 0xbb, 0xcb, 0xae, 0x90, 0xd5, 0x22, 0xa6, 0xd4, 0xad, 0x9c, 0x5e, 0xc3, 0xbd, 0xcd, 0x3b, 0x09, 0xdc, - 0xcc, 0xe2, 0x96, 0x47, 0x09, 0x01, 0x57, 0x8e, 0xad, 0xa5, 0xd0, 0x30, 0xe2, 0xf5, 0x20, 0x83, 0x48, 0x90, 0xfe, - 0xed, 0x22, 0x43, 0xe9, 0x29, 0x9f, 0x8f, 0x6d, 0x24, 0xd4, 0xc3, 0x4d, 0xed, 0x08, 0x0e, 0xef, 0xde, 0x5c, 0x7d, - 0xc4, 0x1f, 0xa5, 0xd7, 0xf1, 0xa1, 0x37, 0x4e, 0xcb, 0xe5, 0x35, 0x36, 0x12, 0xc0, 0xed, 0xe3, 0xf6, 0x72, 0xe1, - 0x16, 0x0d, 0xcf, 0x6d, 0x35, 0xde, 0xed, 0xe8, 0x6f, 0x5f, 0xc0, 0xcd, 0xe7, 0xdb, 0x75, 0xe7, 0x7e, 0xf3, 0x33, - 0xe5, 0xe2, 0xa5, 0x8b, 0x8c, 0xe8, 0x82, 0xf1, 0xf2, 0x6a, 0x85, 0x14, 0x20, 0xcd, 0x0f, 0x60, 0xf7, 0xf1, 0xed, - 0x91, 0xee, 0x53, 0xd9, 0x2b, 0x24, 0x7d, 0xde, 0x2e, 0x15, 0x56, 0x22, 0x8e, 0x4f, 0x36, 0x8d, 0x2c, 0xe8, 0xb3, - 0x10, 0x5d, 0xaa, 0x9f, 0x92, 0x7c, 0x5e, 0xce, 0x0d, 0x3f, 0xfc, 0x74, 0x02, 0xba, 0x09, 0xcf, 0x06, 0x11, 0x94, - 0x45, 0x4e, 0x7b, 0x4a, 0x69, 0xdf, 0xc9, 0x3f, 0xa5, 0x28, 0xbc, 0x65, 0xa3, 0xfd, 0xd2, 0xaa, 0x9b, 0xfe, 0xac, - 0xba, 0x52, 0xbc, 0x7b, 0x78, 0xb5, 0xd9, 0x5d, 0xa6, 0xa1, 0x3c, 0x73, 0x73, 0xef, 0xab, 0x05, 0xfa, 0x15, 0xc9, - 0xc7, 0xc3, 0x00, 0x11, 0x57, 0xbb, 0xcb, 0x3c, 0x55, 0xbb, 0x67, 0x4d, 0xfb, 0x22, 0x6d, 0x0c, 0x57, 0x8e, 0x3d, - 0xbe, 0x7c, 0x12, 0x27, 0x17, 0xc7, 0xba, 0x39, 0x89, 0x54, 0x94, 0x8f, 0xf5, 0x57, 0x01, 0x86, 0x33, 0x6d, 0xce, - 0x40, 0xb2, 0xaa, 0xcb, 0x53, 0xa0, 0x1e, 0x99, 0x84, 0x27, 0x67, 0xf6, 0xcd, 0x6c, 0x00, 0xd8, 0x0c, 0x98, 0x86, - 0xd6, 0xbe, 0x9b, 0x27, 0xb3, 0xa8, 0x1a, 0x00, 0x47, 0xc9, 0x2f, 0x4e, 0x3d, 0x91, 0x65, 0x57, 0x58, 0xb3, 0xf1, - 0x7a, 0xe9, 0xee, 0xd7, 0x29, 0x49, 0x21, 0x3b, 0x67, 0x47, 0x91, 0x09, 0xf3, 0x71, 0x7c, 0xd5, 0xe8, 0x65, 0x69, - 0xfa, 0x86, 0x61, 0x00, 0x8b, 0x30, 0xcd, 0xdb, 0xdd, 0x76, 0xab, 0x3e, 0xad, 0x02, 0x42, 0xed, 0x9d, 0x73, 0x2b, - 0xed, 0x3f, 0x9c, 0x54, 0x34, 0x9c, 0xcd, 0x4b, 0x21, 0xd9, 0x57, 0x68, 0x50, 0x90, 0xd5, 0x98, 0x91, 0x8e, 0xf5, - 0x29, 0x09, 0x4c, 0x9b, 0x49, 0xfa, 0x76, 0x1b, 0xd4, 0x05, 0xa8, 0x4c, 0xf9, 0x72, 0x5d, 0x58, 0x53, 0x53, 0x6f, - 0x4c, 0xf1, 0xe5, 0xde, 0xbe, 0x40, 0xd3, 0xcc, 0xd0, 0x5e, 0xce, 0x6d, 0x28, 0x65, 0xbd, 0xec, 0x2a, 0xc2, 0x83, - 0x6c, 0xa5, 0xf3, 0xf8, 0x2e, 0xc9, 0xdf, 0xe4, 0x03, 0x6a, 0x2b, 0x16, 0x97, 0x7b, 0xf5, 0x22, 0x6e, 0x37, 0x19, - 0x9a, 0x11, 0x1a, 0x56, 0x53, 0xb0, 0xdc, 0xbd, 0xf9, 0x4c, 0xef, 0x66, 0x73, 0xf5, 0x39, 0xbb, 0xf8, 0xec, 0x60, - 0x1b, 0x24, 0x90, 0x7a, 0xc4, 0xca, 0x9a, 0xec, 0x21, 0x25, 0x86, 0x89, 0x69, 0xca, 0x9e, 0x00, 0x19, 0xc0, 0x1f, - 0x93, 0xf8, 0x7f, 0xfc, 0xfd, 0xef, 0xc1, 0x1d, 0xda, 0xef, 0xce, 0x17, 0x23, 0xef, 0xf9, 0x87, 0xd3, 0x03, 0xa7, - 0x9f, 0xdb, 0xfb, 0x38, 0xb7, 0x47, 0x44, 0x8d, 0x2a, 0x2e, 0x2a, 0x5a, 0xf1, 0xe4, 0x50, 0x55, 0x5a, 0x87, 0xf9, - 0x4e, 0xdc, 0x29, 0x15, 0xae, 0xdc, 0xcb, 0xe0, 0x7e, 0xbf, 0x1f, 0xae, 0xff, 0x5f, 0x9d, 0x2d, 0x59, 0x7f, 0xff, - 0x6f, 0x6b, 0xfa, 0x7f, 0xe9, 0x4d, 0x58, 0x1a, 0xee, 0x7f, 0x6b, 0x70, 0xe9, 0xb7, 0x67, 0x5a, 0x5f, 0xbb, 0xf6, - 0x6f, 0x1d, 0x20, 0x28, 0x64, 0x3f, 0xd9, 0xb3, 0x76, 0xe9, 0xa9, 0xcb, 0x2c, 0x06, 0xca, 0xc1, 0xff, 0x9f, 0x65, - 0x77, 0xec, 0xd9, 0x09, 0x53, 0x1b, 0x1f, 0xdf, 0xcf, 0x30, 0x0e, 0xb8, 0x55, 0x22, 0x8c, 0x71, 0xc8, 0xeb, 0xca, - 0xef, 0x6a, 0xe4, 0x73, 0x48, 0x27, 0xd6, 0x2a, 0xa0, 0x5f, 0xd6, 0x2f, 0x0a, 0xe2, 0xbe, 0x87, 0x3b, 0x13, 0xb1, - 0x24, 0x78, 0xa0, 0x6e, 0x9c, 0x0a, 0xca, 0x8f, 0xa4, 0x69, 0x7a, 0x8e, 0x92, 0x5f, 0xda, 0xff, 0x31, 0x5b, 0xc3, - 0xaa, 0xf7, 0x17, 0xc4, 0x8b, 0x93, 0xdb, 0x7f, 0x61, 0x21, 0xed, 0x1b, 0x92, 0x18, 0x1b, 0x53, 0xb7, 0x6e, 0x9c, - 0x3a, 0x9d, 0xde, 0xb3, 0xad, 0xea, 0x0c, 0xc2, 0x1f, 0x55, 0x29, 0x4c, 0xde, 0xae, 0x05, 0x51, 0x4d, 0xef, 0xb3, - 0x77, 0x75, 0x34, 0xa0, 0x96, 0x92, 0x67, 0x7e, 0x9b, 0xc1, 0xb3, 0x2b, 0x7c, 0xbf, 0x1a, 0xeb, 0xa7, 0xe0, 0x84, - 0x34, 0x72, 0x99, 0xb2, 0x7e, 0x04, 0x6b, 0xed, 0xe6, 0x83, 0x17, 0x38, 0x89, 0xce, 0xd9, 0x2a, 0xe7, 0x24, 0xaa, - 0xc6, 0xfb, 0x82, 0xf0, 0x3f, 0x67, 0x2c, 0x7c, 0x86, 0x86, 0x0b, 0xb1, 0x9c, 0x80, 0x6a, 0x4c, 0xe1, 0x98, 0x79, - 0xc7, 0xf5, 0x73, 0x7b, 0x6d, 0xbf, 0xf2, 0x8b, 0x21, 0xd2, 0x6c, 0x0c, 0xde, 0xaa, 0x7e, 0xc1, 0x50, 0xb2, 0x1f, - 0x0f, 0x7b, 0x70, 0xe8, 0xa5, 0xe9, 0x45, 0xd6, 0xfe, 0x29, 0x7c, 0x91, 0xaf, 0x7c, 0x48, 0x2d, 0xcd, 0x6b, 0xa5, - 0x18, 0x2f, 0x6e, 0xd8, 0xc5, 0xbf, 0x83, 0xf4, 0xc6, 0xec, 0xb0, 0xdb, 0xb8, 0x81, 0x22, 0x91, 0xc6, 0x1a, 0x32, - 0xf6, 0x3f, 0xad, 0x93, 0x1c, 0x26, 0x2c, 0x31, 0x08, 0xeb, 0x27, 0xb1, 0x79, 0xd5, 0xe7, 0x4e, 0xb2, 0x6f, 0x92, - 0x66, 0x57, 0xa1, 0x69, 0x00, 0x08, 0xcf, 0x1e, 0x91, 0xbb, 0xab, 0x8f, 0x96, 0x6c, 0x7b, 0xc9, 0xe5, 0x6f, 0xc3, - 0xc8, 0xd9, 0x87, 0x4d, 0x5b, 0x1b, 0x9c, 0xda, 0x9c, 0xc4, 0xa6, 0x8d, 0x55, 0xf8, 0xdc, 0x74, 0xc2, 0x7d, 0x7f, - 0xed, 0x59, 0x5c, 0x33, 0x2b, 0x89, 0xe2, 0xda, 0x0a, 0x71, 0x53, 0xf0, 0x03, 0x0c, 0x24, 0xcc, 0x18, 0x73, 0xb6, - 0x51, 0x20, 0x20, 0x49, 0x99, 0xb2, 0x6a, 0x43, 0x7c, 0xf9, 0x41, 0x0c, 0x70, 0x33, 0x13, 0x36, 0x01, 0xb5, 0xfe, - 0xc8, 0xca, 0x0d, 0x27, 0x4b, 0x42, 0xc8, 0xb8, 0xdb, 0x27, 0xbf, 0x60, 0x60, 0xc6, 0x8f, 0x18, 0xa5, 0xc6, 0x77, - 0xeb, 0xfd, 0x63, 0x26, 0x7f, 0xba, 0xfe, 0x93, 0x6d, 0xe3, 0xb7, 0xe1, 0x42, 0x19, 0xb6, 0xe6, 0x33, 0xb4, 0xac, - 0x0a, 0x0c, 0xca, 0xa8, 0xbc, 0xb3, 0x9e, 0xb9, 0xed, 0x93, 0x58, 0x55, 0x49, 0x7c, 0x43, 0xab, 0x32, 0x47, 0xf0, - 0xb8, 0x17, 0xa5, 0x34, 0x25, 0x58, 0x82, 0xdb, 0xf7, 0x2b, 0xe4, 0x2a, 0xe7, 0xe1, 0xcb, 0x13, 0x47, 0x92, 0x2b, - 0x17, 0xa5, 0x57, 0x6f, 0x38, 0xe2, 0xd4, 0xa5, 0x94, 0x9d, 0x65, 0x60, 0x4f, 0x36, 0x0f, 0xa9, 0x20, 0xa5, 0xa1, - 0x96, 0x6d, 0xdb, 0x5a, 0xf9, 0x25, 0x7a, 0x2d, 0xb5, 0xba, 0x60, 0x69, 0x29, 0xe0, 0xc6, 0x8c, 0x28, 0x8f, 0x6a, - 0xeb, 0xe6, 0xea, 0x28, 0xa5, 0x79, 0x50, 0x57, 0xc1, 0x43, 0x6d, 0x1e, 0xb9, 0xb0, 0x86, 0x5f, 0xfa, 0xf8, 0xe8, - 0x91, 0x31, 0x32, 0xed, 0x06, 0x3e, 0x9e, 0x66, 0xc3, 0x66, 0x07, 0x5f, 0xa8, 0x3a, 0x35, 0x21, 0x94, 0x2f, 0xd0, - 0x79, 0xa3, 0x4a, 0xb2, 0x1c, 0xbc, 0x42, 0xc6, 0x2d, 0x4e, 0x12, 0xf7, 0x6f, 0xc8, 0xfa, 0xa2, 0x58, 0x5a, 0xb4, - 0xa7, 0x95, 0x55, 0x41, 0x69, 0x9b, 0xd4, 0xfc, 0xd7, 0x98, 0x7e, 0xe5, 0x21, 0xa9, 0xa7, 0x35, 0xde, 0x1f, 0x72, - 0xbb, 0xe4, 0x1e, 0x77, 0xdf, 0x82, 0x33, 0xa3, 0x76, 0xbb, 0x02, 0x90, 0x76, 0x7d, 0x1c, 0x21, 0x91, 0x39, 0x11, - 0x4e, 0x29, 0xe9, 0xc1, 0x8d, 0x1c, 0xa1, 0xf9, 0xdd, 0x3e, 0xb6, 0x9a, 0x48, 0xb7, 0x70, 0x1c, 0xb1, 0xbf, 0x2c, - 0x63, 0x67, 0x70, 0x12, 0xaf, 0x5d, 0xfc, 0xda, 0x23, 0x14, 0xd9, 0x92, 0x4a, 0x7d, 0x6d, 0xc9, 0x95, 0x76, 0xf9, - 0x4e, 0xed, 0x65, 0xdc, 0xa1, 0xb0, 0x4d, 0x6f, 0x5d, 0x8a, 0xff, 0xc3, 0x29, 0xa5, 0xfa, 0x8e, 0xdf, 0xa8, 0xf4, - 0xb7, 0xdd, 0xfd, 0x5e, 0x6d, 0x05, 0xcb, 0xf9, 0xab, 0x1a, 0xd1, 0x36, 0xed, 0xda, 0x2e, 0x5a, 0xbc, 0x39, 0xd0, - 0xd6, 0xa1, 0xbe, 0x42, 0xff, 0xbc, 0x63, 0x54, 0x05, 0x3a, 0x24, 0x1d, 0xca, 0xb0, 0x99, 0x36, 0xe4, 0xc4, 0x6a, - 0x18, 0x84, 0xfd, 0xa2, 0x50, 0xfb, 0xe0, 0x7f, 0x32, 0x65, 0x45, 0x03, 0x6a, 0xcd, 0x39, 0xd3, 0x96, 0x33, 0xe0, - 0xfa, 0x64, 0xb3, 0xdb, 0xd4, 0x7a, 0xaa, 0x31, 0xce, 0x68, 0xca, 0xb0, 0xad, 0x5b, 0xb6, 0xec, 0xd6, 0xcd, 0x1c, - 0x49, 0xf1, 0x07, 0x33, 0xc3, 0x27, 0xfd, 0xe7, 0xd7, 0xba, 0x01, 0xca, 0xbb, 0x57, 0xef, 0x67, 0x72, 0xaa, 0x3a, - 0xe5, 0x4f, 0xf3, 0xf5, 0xd3, 0x5f, 0x2d, 0x79, 0xfd, 0xa3, 0xbf, 0x78, 0x89, 0xde, 0xf0, 0x17, 0x6c, 0x19, 0xe3, - 0x66, 0xbb, 0x4c, 0x7a, 0x09, 0x3a, 0x2b, 0x35, 0xfa, 0x6c, 0x83, 0xa5, 0xe0, 0x2e, 0x18, 0x09, 0xd4, 0xb4, 0x4d, - 0x59, 0x97, 0xf6, 0x7d, 0x71, 0xfd, 0x74, 0xa3, 0xad, 0x2f, 0xb6, 0xaa, 0x87, 0xb8, 0xef, 0xab, 0xd7, 0xc1, 0x7c, - 0x3e, 0xec, 0xbe, 0xfd, 0x84, 0x4d, 0xf8, 0xa7, 0x10, 0xa0, 0x0d, 0x3b, 0x3d, 0x56, 0x8d, 0x8b, 0xf7, 0xd5, 0xb0, - 0xb8, 0xae, 0xda, 0xe2, 0xac, 0x9a, 0x17, 0xe7, 0xd5, 0xf5, 0xe1, 0xdd, 0x5d, 0xbf, 0x65, 0xf8, 0x1b, 0x56, 0xd3, - 0x1b, 0xb2, 0xf6, 0x33, 0xa6, 0xa9, 0x65, 0xc2, 0xe9, 0x69, 0xb7, 0x7c, 0x84, 0xd3, 0x2e, 0xdd, 0x9d, 0xdd, 0x79, - 0xbc, 0x7d, 0x83, 0x5e, 0xa5, 0x68, 0x97, 0x05, 0x86, 0xea, 0xc4, 0x82, 0xc4, 0xbc, 0xc6, 0xb6, 0x37, 0xeb, 0x90, - 0x33, 0x18, 0xc8, 0x73, 0xc5, 0x35, 0xce, 0x5d, 0x8c, 0x99, 0xbc, 0xa1, 0x00, 0x85, 0x63, 0x49, 0x54, 0xc3, 0xaa, - 0x95, 0x15, 0x75, 0x24, 0xb1, 0x20, 0x88, 0x17, 0x4c, 0x9d, 0x54, 0xc1, 0x2e, 0xdd, 0xc8, 0xbb, 0x1a, 0xc1, 0x00, - 0xb7, 0x9d, 0x4d, 0xb9, 0xb8, 0x2f, 0x1a, 0xd9, 0x62, 0x2b, 0x55, 0x2d, 0xc2, 0x95, 0x48, 0x39, 0x2e, 0xad, 0x6f, - 0x99, 0xdb, 0xf7, 0xba, 0x5f, 0x9c, 0x97, 0xe2, 0x7f, 0xda, 0x01, 0x5e, 0x47, 0x86, 0xac, 0xec, 0x05, 0xbf, 0x52, - 0x32, 0xad, 0x13, 0xeb, 0x54, 0xd3, 0xba, 0xc6, 0x61, 0xf6, 0xf2, 0xd7, 0xf2, 0x40, 0x14, 0x23, 0xfa, 0xa2, 0x56, - 0x2a, 0x6b, 0x74, 0x98, 0xc4, 0x20, 0xd3, 0xd0, 0x94, 0x63, 0x0d, 0xad, 0x15, 0x67, 0xf1, 0x68, 0x57, 0x41, 0x62, - 0xe3, 0x5b, 0xf9, 0x35, 0x27, 0x36, 0xe8, 0x00, 0x62, 0x81, 0x8e, 0xcb, 0x3a, 0x13, 0xfe, 0x3f, 0xea, 0xa1, 0xdc, - 0x37, 0xfd, 0x9f, 0x28, 0xaf, 0x0a, 0xd1, 0x67, 0xe8, 0xdb, 0x25, 0x57, 0x70, 0x09, 0x31, 0xea, 0xc1, 0x9a, 0xa8, - 0xe6, 0xce, 0x6f, 0xd1, 0x27, 0x90, 0x02, 0x82, 0xa7, 0x33, 0x18, 0x9c, 0xa8, 0x36, 0xd2, 0xa0, 0x99, 0x11, 0xa9, - 0x18, 0x0a, 0xef, 0x47, 0x53, 0xb5, 0x6e, 0x47, 0x32, 0xb6, 0x57, 0x32, 0x6f, 0xf5, 0x6b, 0xab, 0x40, 0x61, 0x3e, - 0x5e, 0xae, 0x1a, 0x01, 0xa0, 0xe5, 0xef, 0xdb, 0x9f, 0xd4, 0xd5, 0x38, 0x7a, 0xd7, 0x6d, 0x0a, 0x47, 0xe7, 0x88, - 0x27, 0x86, 0xc5, 0x16, 0xa2, 0xd5, 0x13, 0xa8, 0xf9, 0x0e, 0x0d, 0x57, 0xed, 0x9b, 0xcc, 0x60, 0x5e, 0x4e, 0x4e, - 0x72, 0x7e, 0x87, 0xa9, 0x77, 0xbe, 0x67, 0x8a, 0x30, 0xa9, 0x09, 0xa2, 0xea, 0x3d, 0x14, 0x04, 0x0b, 0xf6, 0x42, - 0x0b, 0xf7, 0xeb, 0x51, 0x92, 0x82, 0xc9, 0x80, 0xae, 0x68, 0xed, 0x88, 0x95, 0x15, 0x53, 0x6a, 0x34, 0x12, 0x19, - 0xae, 0x72, 0xd3, 0xdf, 0xc7, 0x84, 0x4a, 0x01, 0x68, 0xb7, 0x7f, 0x21, 0x63, 0xe4, 0xe0, 0x82, 0x35, 0xd1, 0x6e, - 0x48, 0x43, 0x0b, 0xb7, 0x54, 0x16, 0x04, 0xf0, 0x82, 0x06, 0xab, 0xfd, 0x82, 0xca, 0x71, 0xe1, 0x13, 0x0b, 0x53, - 0xaf, 0x84, 0x5d, 0xf0, 0xe7, 0x86, 0xa5, 0xf5, 0xcf, 0x0f, 0x03, 0x8a, 0xf5, 0x0f, 0x61, 0xd8, 0x97, 0xcf, 0xf3, - 0x9c, 0xf8, 0xd8, 0x08, 0xc9, 0xd5, 0x56, 0x83, 0x10, 0x2f, 0x4a, 0x7a, 0x2b, 0x66, 0x16, 0xb5, 0xde, 0x1e, 0x9e, - 0xd7, 0xbe, 0x74, 0x07, 0xb1, 0xea, 0x97, 0xd8, 0xd8, 0xec, 0x6e, 0x40, 0x90, 0xfd, 0xa6, 0xa8, 0x94, 0xb1, 0xc9, - 0xf7, 0x3c, 0xc9, 0xee, 0xe5, 0xf3, 0x19, 0x81, 0x53, 0xf6, 0xd9, 0x67, 0xbe, 0x26, 0xe0, 0xcb, 0x9e, 0x1e, 0x9b, - 0x3d, 0xad, 0xb3, 0x73, 0x4e, 0x1f, 0x1e, 0xa2, 0x86, 0xda, 0x74, 0x2f, 0x0c, 0x86, 0x2b, 0x90, 0x5f, 0xb8, 0x4f, - 0x88, 0x09, 0x97, 0x9f, 0x9f, 0x46, 0x3b, 0x73, 0x27, 0xe4, 0xc1, 0xd9, 0xe1, 0x13, 0x50, 0x01, 0x33, 0x7b, 0xa7, - 0x92, 0xe6, 0x6d, 0xf5, 0x88, 0x8f, 0x5a, 0x91, 0xd8, 0x03, 0x98, 0xae, 0xbb, 0xe0, 0x3e, 0x5d, 0xef, 0x56, 0xf6, - 0x5d, 0x3c, 0x15, 0xa8, 0x7b, 0x6d, 0xab, 0x6d, 0xea, 0xaf, 0x74, 0xc7, 0xd3, 0x17, 0x85, 0x01, 0xc0, 0xec, 0x2e, - 0x41, 0x0b, 0xbe, 0x92, 0x18, 0xf6, 0xe0, 0xbd, 0x9c, 0xa4, 0xdf, 0x62, 0x07, 0x4f, 0xc6, 0xb5, 0x51, 0x0d, 0xd4, - 0xc2, 0x7c, 0x77, 0x43, 0xcd, 0xaa, 0x1a, 0x48, 0x9c, 0x23, 0xe1, 0x6c, 0xfd, 0xac, 0x3d, 0xe6, 0x8b, 0x9d, 0x2b, - 0x8e, 0xfd, 0x8f, 0x0a, 0xbf, 0xc2, 0xf6, 0x8c, 0xa5, 0x03, 0xaf, 0x0c, 0x2b, 0xe9, 0x18, 0x0c, 0xc8, 0xcf, 0x75, - 0x9c, 0x48, 0xa3, 0xf9, 0xfb, 0xe8, 0x8b, 0x04, 0x35, 0xd0, 0x6f, 0x7c, 0x1e, 0x5f, 0xba, 0xe4, 0x53, 0xad, 0x1f, - 0x08, 0xf8, 0x20, 0x03, 0x6a, 0xcf, 0xe8, 0x8c, 0x16, 0x4f, 0x73, 0xfd, 0x49, 0x7f, 0xcc, 0x25, 0xeb, 0x1f, 0xfd, - 0xd3, 0x2c, 0x4e, 0xad, 0xc5, 0x45, 0x35, 0xc1, 0x7b, 0x0a, 0xfb, 0x9e, 0x02, 0xfe, 0x2e, 0x59, 0x64, 0xc3, 0x32, - 0x9a, 0x47, 0xb1, 0xa6, 0x41, 0x94, 0xd4, 0xfa, 0xc8, 0xad, 0x4d, 0x3e, 0xf6, 0x7d, 0x0f, 0xab, 0x42, 0x5f, 0xe9, - 0xc2, 0x77, 0x55, 0x8b, 0xc5, 0x6c, 0xd5, 0x99, 0x48, 0xb9, 0x9e, 0x51, 0xa9, 0xc0, 0x11, 0x56, 0x9a, 0x23, 0xc7, - 0x34, 0xa5, 0xe1, 0xc0, 0xe1, 0x14, 0x6b, 0x52, 0x80, 0x7d, 0xfd, 0x4b, 0xdf, 0xda, 0x5a, 0x9e, 0x4f, 0xe1, 0xb6, - 0xe1, 0x2d, 0xce, 0xeb, 0x32, 0x94, 0xa4, 0x56, 0x01, 0xcb, 0xbe, 0x8a, 0x05, 0xc4, 0x45, 0xbe, 0xaa, 0x36, 0x27, - 0x8c, 0x51, 0x93, 0x0b, 0xb5, 0x87, 0xcc, 0x0d, 0xd4, 0x44, 0xa7, 0x90, 0x5e, 0x70, 0xda, 0x77, 0x93, 0xd8, 0x5a, - 0xd7, 0x32, 0xeb, 0xeb, 0xc4, 0x52, 0xa5, 0xcd, 0xb3, 0xbd, 0x23, 0x1d, 0x90, 0xcb, 0x98, 0x84, 0x20, 0x89, 0x25, - 0xa8, 0xf0, 0xd8, 0xfe, 0xaa, 0x9f, 0x8b, 0x04, 0x20, 0x81, 0xed, 0x8b, 0xf8, 0x32, 0x70, 0x94, 0xa4, 0xa2, 0x6a, - 0x6a, 0x6d, 0x06, 0x4c, 0xcc, 0x3b, 0x1d, 0x55, 0x6a, 0x51, 0x83, 0x20, 0x40, 0x64, 0xe2, 0x2c, 0x12, 0x39, 0x3d, - 0x8a, 0x1e, 0xee, 0x68, 0xa7, 0x85, 0x4c, 0xd1, 0x0a, 0x4a, 0x64, 0xed, 0x21, 0x49, 0x0f, 0x5f, 0x23, 0x14, 0x83, - 0x13, 0xe7, 0xcc, 0x05, 0xbf, 0xd7, 0x26, 0xbf, 0x9f, 0x5a, 0xe6, 0xde, 0xb5, 0xd8, 0x59, 0x7c, 0xe5, 0x51, 0xae, - 0x9e, 0x6c, 0x04, 0xdc, 0x0e, 0xe8, 0xee, 0x05, 0x05, 0xd8, 0xdb, 0x9b, 0x00, 0x03, 0xaf, 0xb4, 0xa8, 0xb5, 0x6c, - 0xe3, 0xb2, 0x5c, 0x13, 0xd6, 0x96, 0xfc, 0x9f, 0xdf, 0x4b, 0x27, 0x27, 0x9b, 0x28, 0x74, 0x34, 0xc9, 0xa9, 0x12, - 0x1d, 0x41, 0x1a, 0xc3, 0xaa, 0x17, 0x17, 0x90, 0x69, 0x4f, 0x93, 0x37, 0x6e, 0xd9, 0x12, 0x46, 0x66, 0x6f, 0x01, - 0xbb, 0xa7, 0xb7, 0x0c, 0x1c, 0xa9, 0xfa, 0xbf, 0x9f, 0xa6, 0x12, 0x3b, 0x05, 0x11, 0x84, 0x7a, 0xee, 0x58, 0xb2, - 0x0b, 0x64, 0x6c, 0xf5, 0x77, 0xcc, 0xb4, 0x69, 0xb2, 0x09, 0xe1, 0x11, 0x32, 0xe7, 0xbd, 0x72, 0x5b, 0x84, 0x18, - 0x4a, 0x0b, 0x52, 0xf0, 0xb5, 0xd3, 0x29, 0x82, 0xc3, 0x3c, 0x5d, 0x86, 0x0e, 0x1f, 0xc2, 0x19, 0x99, 0x31, 0xfe, - 0x54, 0xdc, 0x1b, 0x60, 0xde, 0x5d, 0x88, 0x1d, 0x26, 0xeb, 0x95, 0x21, 0x77, 0x44, 0x1e, 0xdf, 0x26, 0x79, 0x7a, - 0xb7, 0xcb, 0xa0, 0x4c, 0xe9, 0xf0, 0xc9, 0x24, 0xe2, 0x53, 0x71, 0xaa, 0x48, 0xb5, 0xa0, 0x6d, 0xf5, 0xed, 0xf7, - 0x65, 0xd0, 0x7b, 0xcf, 0xbe, 0xf5, 0x3e, 0x0a, 0x88, 0xae, 0x37, 0x0d, 0xdb, 0x34, 0x4f, 0x43, 0x83, 0x1c, 0xc3, - 0xfc, 0x74, 0x6b, 0x99, 0x4e, 0xd5, 0xe5, 0x2f, 0x7a, 0x6d, 0x91, 0x2f, 0x80, 0x4d, 0x3d, 0x0d, 0xaa, 0xb3, 0xda, - 0x26, 0x10, 0x21, 0x7d, 0x20, 0x66, 0x89, 0x8f, 0x62, 0xc5, 0xf8, 0xec, 0x35, 0x91, 0x0b, 0x7e, 0x96, 0x9f, 0x43, - 0xee, 0xed, 0x8d, 0x1f, 0xf9, 0xa4, 0xa0, 0xf7, 0xe3, 0x71, 0x76, 0x06, 0xf1, 0x7c, 0x9c, 0xce, 0x76, 0xaa, 0x20, - 0xa6, 0xbf, 0xfb, 0xff, 0x4c, 0x53, 0xd4, 0x1f, 0x20, 0x6c, 0x12, 0x2f, 0x0e, 0x13, 0xbc, 0x56, 0x09, 0x37, 0x09, - 0x3a, 0xa9, 0x7b, 0x28, 0x07, 0x6c, 0x22, 0x80, 0xaf, 0x3c, 0x23, 0x6e, 0x60, 0xba, 0x54, 0xf0, 0x34, 0xf2, 0x0e, - 0xc2, 0xe1, 0x4e, 0xc7, 0x93, 0x76, 0xb8, 0xaf, 0xa2, 0x8d, 0xc5, 0xe3, 0x63, 0x06, 0x91, 0x3f, 0x28, 0xfa, 0x9f, - 0x1a, 0x94, 0x46, 0x7e, 0xbe, 0x98, 0x2f, 0xcd, 0x5c, 0xad, 0xc7, 0x92, 0x36, 0x0a, 0x36, 0xab, 0x50, 0xba, 0x65, - 0xbc, 0x17, 0x17, 0xb6, 0xe8, 0x29, 0x34, 0xfb, 0xfd, 0x69, 0x52, 0x4e, 0xa5, 0xbd, 0xac, 0x5a, 0x93, 0x5e, 0x4b, - 0x6e, 0xef, 0x99, 0x4d, 0xf4, 0x13, 0x60, 0x25, 0x7e, 0x2b, 0x5a, 0xbc, 0xf4, 0x58, 0x94, 0xdf, 0xa5, 0x1a, 0x01, - 0x19, 0x82, 0xe7, 0x4f, 0x1e, 0x03, 0xbb, 0x15, 0xe9, 0xe9, 0xdf, 0x16, 0x97, 0xbe, 0x3b, 0x89, 0xd3, 0xff, 0x53, - 0xc8, 0xfe, 0xc0, 0x8f, 0x19, 0x58, 0x7f, 0xc6, 0x22, 0x55, 0x70, 0x09, 0xb7, 0xdb, 0xc4, 0xe6, 0x0b, 0xa8, 0x8a, - 0xcb, 0xed, 0xb9, 0xa3, 0x4a, 0xec, 0x27, 0x85, 0x0f, 0x3e, 0x8e, 0x4d, 0x6b, 0x11, 0xfe, 0x76, 0x17, 0x99, 0xfc, - 0xab, 0xe3, 0x12, 0x84, 0x57, 0xdd, 0xf8, 0xa0, 0xdf, 0x33, 0x5a, 0x3d, 0xcd, 0x7f, 0x9e, 0xfe, 0x9b, 0x25, 0xff, - 0xfc, 0xe8, 0x9f, 0x66, 0xe5, 0xad, 0x54, 0x3d, 0xe2, 0x01, 0x57, 0xe3, 0x25, 0xe2, 0xf1, 0xe4, 0xf5, 0xfc, 0xa3, - 0x64, 0x57, 0x75, 0x0d, 0x15, 0x5e, 0x9e, 0xc8, 0x05, 0x5a, 0x46, 0x35, 0xdb, 0x7a, 0x8e, 0x5e, 0x28, 0xd7, 0x1d, - 0xc5, 0x92, 0x44, 0x9b, 0x5e, 0x7e, 0x8b, 0xf4, 0x6a, 0x90, 0x24, 0x98, 0xed, 0xbf, 0x93, 0x35, 0x20, 0xd4, 0x1a, - 0x66, 0x56, 0xa9, 0x81, 0xc5, 0x73, 0xdb, 0x96, 0x94, 0xf3, 0x2a, 0xde, 0x1f, 0x45, 0x7e, 0xf9, 0x21, 0x0c, 0x58, - 0x0c, 0x46, 0x6f, 0x84, 0x26, 0xe0, 0x29, 0x22, 0x23, 0x47, 0x55, 0x5d, 0x48, 0xfc, 0x76, 0x47, 0x48, 0xbc, 0x95, - 0x4b, 0xa5, 0xaf, 0x04, 0x90, 0xaf, 0x65, 0xf5, 0xa9, 0xab, 0xc1, 0x5d, 0x7f, 0xd8, 0x93, 0xf4, 0x8d, 0x77, 0xe6, - 0x37, 0xea, 0xf2, 0x56, 0x69, 0xf4, 0x04, 0xcc, 0xce, 0x36, 0x4c, 0x65, 0xc4, 0x49, 0xe4, 0xd0, 0xe6, 0x62, 0x07, - 0x56, 0x99, 0x75, 0x33, 0xba, 0x82, 0x3f, 0x76, 0xe7, 0x2e, 0x24, 0x65, 0xcd, 0xb5, 0x4f, 0x32, 0xfd, 0xd0, 0x8a, - 0xe3, 0x2e, 0x81, 0xf1, 0xbe, 0xb4, 0xbc, 0x30, 0x3c, 0x45, 0x4a, 0x6d, 0x53, 0x0a, 0x1a, 0x90, 0x5f, 0xc5, 0x43, - 0x8a, 0x36, 0x41, 0x20, 0x27, 0x7b, 0xa5, 0x95, 0xea, 0x23, 0x95, 0xbb, 0xec, 0x19, 0xd3, 0xe6, 0x01, 0xa7, 0xd9, - 0x0c, 0x4a, 0x60, 0x9c, 0x4e, 0xfb, 0x64, 0x6d, 0x37, 0x9d, 0xdb, 0x6f, 0x92, 0xb2, 0xf0, 0x6b, 0x14, 0x4a, 0x6e, - 0xfe, 0x36, 0xfd, 0xfb, 0x96, 0xaf, 0x9e, 0xf9, 0x47, 0x82, 0xbd, 0xd2, 0x9f, 0xfd, 0xf5, 0xbe, 0xb2, 0x8b, 0x73, - 0xa5, 0x5b, 0x87, 0x85, 0xe5, 0xe2, 0x61, 0x7f, 0x74, 0x24, 0x80, 0x4c, 0x10, 0x2b, 0xdd, 0xb0, 0xc6, 0xf0, 0xfb, - 0x44, 0xcd, 0x3e, 0xf3, 0x8b, 0xa3, 0xa3, 0x61, 0xe5, 0x1b, 0xbb, 0x59, 0x27, 0x58, 0x0e, 0xff, 0xcf, 0xfd, 0x97, - 0xcd, 0x37, 0xbb, 0xcd, 0xe1, 0xc6, 0xc6, 0x6e, 0x9f, 0x05, 0xc6, 0x31, 0x37, 0xd7, 0x6b, 0x04, 0xc6, 0x48, 0xed, - 0xd0, 0xe4, 0x87, 0xc6, 0x99, 0xe3, 0xaa, 0x4c, 0xd9, 0x3b, 0xa2, 0x16, 0x69, 0x5c, 0xcf, 0x4a, 0x8e, 0xb4, 0xd0, - 0x2e, 0x96, 0xc5, 0xa1, 0x51, 0x24, 0x34, 0xad, 0x17, 0x1b, 0x39, 0xee, 0x87, 0xe7, 0xb3, 0x61, 0xc0, 0x53, 0xc2, - 0xda, 0x81, 0xb3, 0x11, 0x13, 0x41, 0x86, 0xdb, 0x29, 0x42, 0x37, 0xe4, 0x60, 0x80, 0x6e, 0xe8, 0x1c, 0xc1, 0x73, - 0x27, 0x67, 0xce, 0x8f, 0x0b, 0x6f, 0x98, 0x90, 0x0c, 0xa3, 0x04, 0x90, 0x63, 0xb2, 0x92, 0x6e, 0xdc, 0xdb, 0xbd, - 0x69, 0x77, 0x5e, 0x50, 0xd5, 0xc5, 0x50, 0x5b, 0xea, 0x49, 0x47, 0xea, 0xc5, 0x07, 0x12, 0xc3, 0xb6, 0xd3, 0xc9, - 0xf3, 0xca, 0xe8, 0xd5, 0x44, 0xf7, 0xfb, 0x98, 0xe6, 0xba, 0x2f, 0x9a, 0x23, 0xba, 0x02, 0x96, 0x33, 0x99, 0x5d, - 0x4b, 0xc2, 0xd9, 0xee, 0x3e, 0x9a, 0xd0, 0x73, 0x8d, 0x63, 0x51, 0x28, 0x14, 0x6c, 0x69, 0xba, 0x1b, 0xcf, 0xac, - 0xc3, 0xc5, 0x3f, 0xd4, 0xc5, 0x55, 0x06, 0x8a, 0xb3, 0xa6, 0x77, 0x22, 0x71, 0xdf, 0x46, 0x17, 0x06, 0x38, 0x41, - 0x93, 0x8b, 0x1e, 0xf6, 0x44, 0x18, 0x5a, 0x50, 0xd3, 0x5c, 0xca, 0x9f, 0x5b, 0x8f, 0x89, 0x6e, 0x30, 0x38, 0xce, - 0x95, 0x59, 0x4e, 0x4d, 0x1e, 0x0a, 0x57, 0x4a, 0xae, 0xb0, 0x9d, 0x59, 0x5c, 0x36, 0x4b, 0xa5, 0xf0, 0xfe, 0x7f, - 0x71, 0xf0, 0x4c, 0x48, 0xbb, 0x6a, 0xd4, 0xa6, 0xfa, 0x04, 0x3e, 0x03, 0x57, 0x52, 0x39, 0xd9, 0xc4, 0x1f, 0x06, - 0xb8, 0xd3, 0x1f, 0x44, 0x77, 0xcb, 0x86, 0x4b, 0x6e, 0x43, 0x1e, 0x0a, 0x0d, 0xc9, 0xd8, 0x07, 0xc3, 0xd5, 0xe7, - 0x51, 0xf6, 0xf0, 0xf8, 0x3b, 0x46, 0x6b, 0x54, 0xbd, 0xb8, 0x6e, 0x16, 0x3f, 0x70, 0x61, 0xdd, 0xa9, 0xab, 0x5f, - 0x51, 0xde, 0xfc, 0x69, 0xd9, 0x87, 0x55, 0x7e, 0x42, 0x16, 0xd8, 0xd7, 0xf2, 0xe6, 0x04, 0xac, 0xc5, 0x1c, 0x54, - 0x23, 0xf9, 0x45, 0x29, 0x0d, 0xec, 0x80, 0x69, 0xca, 0x35, 0x5a, 0x66, 0xea, 0x4f, 0x3d, 0x38, 0x19, 0x5f, 0x37, - 0x1c, 0x4a, 0x67, 0x77, 0xff, 0xd2, 0x71, 0x0f, 0xa1, 0x29, 0xd2, 0x84, 0xbf, 0x3e, 0x9e, 0xd8, 0x38, 0xb1, 0x8a, - 0x5a, 0x60, 0x5c, 0x39, 0xee, 0xef, 0xad, 0xae, 0x73, 0xf5, 0xd2, 0x87, 0x18, 0x48, 0x92, 0x69, 0xbc, 0x50, 0x09, - 0x52, 0x11, 0xaf, 0x50, 0x70, 0xda, 0xde, 0xef, 0xae, 0xec, 0x51, 0xde, 0xfe, 0xa7, 0x78, 0x33, 0xa3, 0xf9, 0x57, - 0x78, 0x79, 0x2f, 0xd7, 0xef, 0xba, 0xf3, 0xf5, 0x95, 0xfd, 0xb0, 0xdb, 0xff, 0x34, 0x03, 0xc9, 0x55, 0x2a, 0xfd, - 0xe9, 0x52, 0xcf, 0x67, 0x9f, 0x00, 0xf0, 0xeb, 0x95, 0xa1, 0x86, 0x64, 0x58, 0x13, 0xcd, 0x44, 0xc2, 0x5a, 0x25, - 0x62, 0x7c, 0xb3, 0x84, 0xaf, 0x69, 0x77, 0x45, 0x78, 0xa4, 0x8c, 0x8d, 0xb3, 0xb6, 0x43, 0xd6, 0xc7, 0x4c, 0x90, - 0xdd, 0x16, 0xcc, 0xf5, 0xd3, 0xac, 0x9f, 0x86, 0x55, 0xb5, 0x08, 0xd5, 0x27, 0x94, 0xe9, 0xf3, 0x68, 0x00, 0xdd, - 0xa0, 0x70, 0x64, 0x68, 0x24, 0x32, 0x36, 0xfa, 0x61, 0x37, 0x11, 0x1d, 0x47, 0x64, 0x44, 0x64, 0x25, 0x45, 0x21, - 0x9a, 0x4d, 0xfc, 0xf8, 0xfc, 0x27, 0xa5, 0x5a, 0x50, 0x24, 0xe1, 0x1a, 0x80, 0xa4, 0xf6, 0xc3, 0x35, 0x04, 0xa6, - 0xfa, 0xc3, 0xb6, 0x35, 0xe8, 0xd8, 0xc8, 0xca, 0x86, 0xa4, 0x8e, 0xa4, 0xbf, 0x0d, 0x22, 0x49, 0xa6, 0x72, 0x93, - 0x8c, 0x8d, 0x90, 0x03, 0xcc, 0x3b, 0x5a, 0x9b, 0x6f, 0x46, 0xd4, 0x91, 0x74, 0x4c, 0x58, 0x89, 0x3d, 0xa2, 0x30, - 0xc1, 0x11, 0xc2, 0xfd, 0x9a, 0xec, 0x42, 0xff, 0x29, 0xc0, 0xf6, 0x53, 0x43, 0xa2, 0x66, 0xfb, 0x48, 0xc3, 0xa7, - 0xd0, 0xf3, 0x10, 0xe2, 0x6d, 0x98, 0x97, 0x10, 0x16, 0xb9, 0xc1, 0x0e, 0xf4, 0x5e, 0x90, 0xa9, 0x08, 0x6f, 0x24, - 0x6c, 0x62, 0x2d, 0x10, 0x80, 0x67, 0xeb, 0x3e, 0x15, 0x1c, 0x00, 0xa4, 0xcd, 0xca, 0xb1, 0x7c, 0x7f, 0x3c, 0x90, - 0x43, 0x5b, 0x9a, 0x1d, 0xa9, 0x3b, 0xc4, 0xa5, 0x34, 0x9f, 0xe8, 0xd8, 0x1a, 0xc9, 0x41, 0xc2, 0x68, 0xc5, 0x33, - 0xb9, 0x28, 0x9b, 0x76, 0x7e, 0x18, 0xde, 0x57, 0xa5, 0x26, 0x9e, 0xb4, 0xbd, 0xca, 0x1c, 0xc5, 0xe4, 0xf1, 0xd0, - 0xd7, 0xba, 0x0d, 0x97, 0x1e, 0xf4, 0x34, 0x1c, 0x4f, 0x52, 0xfe, 0x7a, 0x8e, 0x62, 0x6d, 0xfc, 0x30, 0xd2, 0x50, - 0x01, 0x19, 0x1e, 0xdc, 0x72, 0xd9, 0x6c, 0xf5, 0xc3, 0xee, 0xf8, 0x61, 0x13, 0x3e, 0xda, 0x8b, 0x6b, 0x33, 0xa7, - 0x97, 0x41, 0x1a, 0xcc, 0x87, 0x92, 0x82, 0x2b, 0xab, 0xc6, 0xbe, 0x37, 0x95, 0xd4, 0xfe, 0xdd, 0xa6, 0x60, 0xdb, - 0xda, 0x46, 0x2f, 0xae, 0x3f, 0x2a, 0x91, 0xf9, 0xfa, 0xdd, 0x34, 0xee, 0x76, 0x76, 0xdb, 0x82, 0x68, 0x84, 0x95, - 0x3b, 0x26, 0x96, 0xd3, 0x6f, 0x9a, 0x74, 0x73, 0x43, 0xe8, 0x23, 0x8a, 0x7f, 0x9b, 0x94, 0xe3, 0xb3, 0xc3, 0xf3, - 0x6b, 0xe8, 0x41, 0x13, 0xa6, 0xaa, 0xc7, 0xe9, 0x0e, 0x16, 0x89, 0xe2, 0x09, 0xaf, 0x88, 0x44, 0xf6, 0xea, 0x87, - 0x43, 0xc6, 0x12, 0x85, 0x21, 0xd2, 0x98, 0xc7, 0x0f, 0xbb, 0x74, 0xd8, 0x79, 0x18, 0xc6, 0x09, 0x70, 0xd9, 0x97, - 0x94, 0xbc, 0xb1, 0x86, 0xdf, 0x7e, 0x0e, 0x4c, 0xfb, 0x7e, 0x7b, 0x9f, 0xe9, 0xad, 0x78, 0x69, 0x6c, 0xbc, 0xde, - 0xa1, 0x10, 0x21, 0xa2, 0x9c, 0x36, 0x3e, 0xae, 0x7f, 0xa4, 0xd8, 0xb0, 0x65, 0x59, 0xae, 0x18, 0xdd, 0xe2, 0xd7, - 0xc0, 0x26, 0x34, 0x6c, 0x87, 0x90, 0x3e, 0xb2, 0x6b, 0x5e, 0x09, 0x68, 0x55, 0x0f, 0x4b, 0xbd, 0xa2, 0x0b, 0x68, - 0x39, 0xc7, 0x48, 0xd9, 0x40, 0x19, 0x28, 0xf8, 0x17, 0x67, 0xd0, 0x55, 0x36, 0xb3, 0xcc, 0xd6, 0xc8, 0x82, 0x7f, - 0x10, 0x4e, 0xe7, 0x4f, 0xa2, 0xd5, 0x84, 0x2c, 0xe1, 0x52, 0xf1, 0x16, 0x14, 0xd8, 0x4a, 0x31, 0x05, 0x06, 0xb4, - 0x7d, 0x22, 0x8d, 0x5f, 0x8c, 0x69, 0x05, 0xd4, 0xd1, 0xe3, 0x32, 0xca, 0xe0, 0x33, 0xad, 0x2b, 0x16, 0x97, 0x41, - 0x7b, 0xa0, 0x31, 0xfc, 0x6b, 0x6b, 0xec, 0x5b, 0xdb, 0x65, 0xfe, 0x3d, 0xe0, 0x35, 0xb5, 0xa7, 0x14, 0x62, 0x05, - 0xd1, 0x01, 0xb2, 0x76, 0x0d, 0x9d, 0xbd, 0x67, 0xcf, 0xc7, 0xd6, 0x72, 0x05, 0x53, 0xe8, 0xa0, 0x62, 0x78, 0x83, - 0xcd, 0xfd, 0x23, 0x85, 0x33, 0x0d, 0xe9, 0x3c, 0xb3, 0x5a, 0x91, 0xcb, 0x14, 0xd4, 0x88, 0x7f, 0x9d, 0x3b, 0x58, - 0x24, 0x51, 0x3d, 0xe2, 0x14, 0x91, 0xa6, 0x93, 0x05, 0x26, 0xa1, 0x8e, 0xd4, 0xd0, 0x76, 0xbb, 0x82, 0x27, 0xca, - 0x4f, 0x38, 0xfd, 0x9b, 0xa5, 0x6b, 0xd4, 0x16, 0x7c, 0x0e, 0xcd, 0xe2, 0x0f, 0x51, 0x4b, 0x7f, 0xfd, 0xf1, 0xc1, - 0x00, 0x01, 0xc4, 0xdb, 0xb3, 0x41, 0x08, 0x13, 0x4f, 0xc7, 0xd6, 0x99, 0x7c, 0xc8, 0x40, 0x30, 0x9b, 0x6a, 0x84, - 0x6c, 0x84, 0xb9, 0xb5, 0x77, 0xd3, 0x3a, 0xf9, 0x03, 0xa7, 0xc0, 0x14, 0xe2, 0x84, 0xed, 0xa0, 0xc0, 0xfc, 0x61, - 0x1c, 0x45, 0x08, 0xf5, 0xe5, 0xd7, 0x22, 0x19, 0xc9, 0xf9, 0x36, 0x98, 0x8b, 0x18, 0x25, 0xd8, 0x5a, 0xf1, 0x5a, - 0x3f, 0x20, 0xaa, 0xda, 0xef, 0x4d, 0x86, 0xed, 0x8c, 0x3e, 0xbe, 0x1b, 0x4f, 0x8a, 0x6f, 0x1c, 0xd7, 0x73, 0x18, - 0xca, 0xfb, 0x67, 0x48, 0xa2, 0x65, 0xde, 0xff, 0xc4, 0xb9, 0xdb, 0xd5, 0xb1, 0x09, 0x2f, 0x6a, 0x03, 0xc3, 0x84, - 0xb0, 0xc1, 0xed, 0x79, 0x9b, 0xec, 0x34, 0x58, 0x9c, 0x4e, 0x17, 0xbc, 0xe1, 0x1a, 0x85, 0x7d, 0xb6, 0x33, 0x29, - 0xee, 0x5d, 0xfb, 0xd7, 0x71, 0x23, 0x1a, 0xf7, 0x19, 0x93, 0x90, 0x7f, 0x67, 0x39, 0x53, 0x9a, 0x3e, 0xad, 0x0a, - 0x4f, 0xfa, 0xce, 0xd9, 0xcd, 0x7c, 0x04, 0x17, 0xed, 0x6f, 0x80, 0xe5, 0x4e, 0xb6, 0x39, 0x27, 0x79, 0x46, 0xf3, - 0x0b, 0xbc, 0xd4, 0xd2, 0xcf, 0xed, 0xb4, 0xea, 0x40, 0x74, 0xb7, 0x00, 0x15, 0x0c, 0xd4, 0xe1, 0x81, 0xb7, 0x63, - 0x3b, 0xc4, 0xa7, 0x1a, 0x8c, 0x41, 0x60, 0xfa, 0x0f, 0xdf, 0xcd, 0xf5, 0x2e, 0x14, 0xa2, 0xcf, 0xa2, 0xe5, 0x2e, - 0xa3, 0x2f, 0xec, 0x84, 0x28, 0x23, 0x17, 0x31, 0xfa, 0x39, 0xba, 0x4b, 0xc8, 0x0d, 0x32, 0x17, 0x11, 0x54, 0xdc, - 0x93, 0xef, 0x88, 0x1f, 0xb0, 0x0b, 0x20, 0x1a, 0xc4, 0x39, 0x87, 0x8a, 0xfe, 0x26, 0x94, 0xa2, 0xd9, 0x61, 0x3c, - 0xff, 0xbb, 0x2c, 0x42, 0xe4, 0xcf, 0xa3, 0x78, 0x57, 0xc8, 0xf7, 0xee, 0xb1, 0xc5, 0x48, 0xf0, 0xc5, 0xb7, 0x41, - 0x2f, 0xe4, 0xc9, 0x9e, 0xc8, 0x20, 0xba, 0xf1, 0x0b, 0xa9, 0x56, 0x89, 0x5c, 0x5d, 0x64, 0x2c, 0x98, 0x5f, 0x21, - 0xa7, 0x3f, 0x6d, 0xef, 0xfc, 0xf2, 0x0f, 0x0c, 0xea, 0x98, 0xc5, 0x7f, 0x36, 0xee, 0x9b, 0x50, 0xa4, 0xef, 0xc5, - 0xe3, 0x03, 0xe2, 0x07, 0xd1, 0xf5, 0x2e, 0x41, 0xb1, 0x95, 0xcc, 0x09, 0x41, 0xa2, 0x70, 0x7c, 0x51, 0x7b, 0xff, - 0x9d, 0xde, 0x85, 0x9b, 0xa8, 0x3d, 0x08, 0xe8, 0x27, 0xff, 0xf0, 0xcb, 0x1f, 0x10, 0x1f, 0x88, 0x2c, 0xb8, 0xbe, - 0x9b, 0x67, 0xab, 0x3f, 0x71, 0x9e, 0xbb, 0x18, 0x44, 0x9f, 0x80, 0x0a, 0x12, 0x56, 0xa9, 0x9e, 0xc1, 0x03, 0xf6, - 0x3f, 0x2c, 0x5c, 0x8d, 0x78, 0xfd, 0xf8, 0xf4, 0x26, 0x5e, 0x43, 0xe7, 0x0a, 0xab, 0x0e, 0x5f, 0x80, 0xc8, 0x21, - 0xb9, 0x54, 0x5d, 0xec, 0x38, 0xd3, 0xff, 0x55, 0x02, 0x36, 0xde, 0x11, 0xc1, 0xe9, 0xfc, 0xc3, 0xcb, 0x17, 0x1b, - 0x7b, 0xb2, 0x9b, 0xdb, 0x61, 0xfc, 0x93, 0x06, 0x96, 0x70, 0x5f, 0xd3, 0xf4, 0x47, 0xc6, 0xe4, 0xd3, 0xfc, 0xf6, - 0x49, 0x3f, 0x1f, 0x4b, 0xbe, 0xfd, 0xe8, 0x17, 0xfe, 0xa8, 0x5f, 0xf3, 0xec, 0x57, 0xb2, 0x26, 0x3b, 0xec, 0x35, - 0xc0, 0xa7, 0xbd, 0xf1, 0xa5, 0xe5, 0xfa, 0x5a, 0xc5, 0xf8, 0x8b, 0x51, 0xe8, 0xd3, 0xef, 0x2e, 0x1f, 0xbc, 0x92, - 0x77, 0x0b, 0x25, 0xcd, 0x54, 0x50, 0xe7, 0xd6, 0xa6, 0xb6, 0x15, 0xda, 0x4d, 0x30, 0x09, 0xf6, 0x06, 0x05, 0x91, - 0x46, 0x15, 0x9e, 0xc8, 0xa2, 0x6d, 0x19, 0x94, 0x0a, 0x86, 0xd2, 0x1c, 0x47, 0x5d, 0x0f, 0x89, 0x03, 0x46, 0xf4, - 0x8c, 0x68, 0x55, 0xab, 0x38, 0x1d, 0x1d, 0x2c, 0x04, 0x9c, 0x42, 0x84, 0x11, 0xc8, 0xf7, 0xea, 0x84, 0x0a, 0x74, - 0x21, 0x69, 0x08, 0xf1, 0x3b, 0xe9, 0x58, 0x8a, 0xe2, 0xda, 0x0a, 0x5f, 0xef, 0x3f, 0xc9, 0xc6, 0xca, 0x47, 0x01, - 0x16, 0xe5, 0x1d, 0x4a, 0xa9, 0x0e, 0x29, 0x98, 0x5c, 0xa4, 0x2e, 0x47, 0xcc, 0x9c, 0x8f, 0x64, 0xb3, 0xe0, 0xb0, - 0x9a, 0x5b, 0xd1, 0x6e, 0x9c, 0xe5, 0xe0, 0xd0, 0x2a, 0xe3, 0x30, 0x86, 0x24, 0x37, 0xf9, 0x35, 0x0a, 0x28, 0x27, - 0xeb, 0x53, 0xdc, 0x02, 0xdf, 0x72, 0xfb, 0x8c, 0x5c, 0xa5, 0xd0, 0xd9, 0x23, 0xdf, 0x33, 0xfc, 0xc1, 0xe3, 0xfd, - 0xee, 0x73, 0x78, 0x34, 0x65, 0xd5, 0x84, 0xb5, 0x7f, 0xb4, 0x21, 0x21, 0x94, 0x02, 0x55, 0x04, 0x08, 0x53, 0x65, - 0x0d, 0xac, 0xeb, 0x90, 0x9a, 0x43, 0x4d, 0xd7, 0x9f, 0x58, 0xe4, 0x88, 0x77, 0x98, 0x38, 0xbf, 0x61, 0x60, 0x89, - 0xa5, 0x0c, 0xf6, 0x06, 0xbc, 0xd6, 0xc2, 0x3e, 0x8b, 0x02, 0x75, 0x26, 0xe7, 0x8a, 0x23, 0x08, 0xba, 0xa5, 0x66, - 0x26, 0x2a, 0x9d, 0x65, 0x8f, 0x34, 0x3f, 0xc5, 0xbc, 0x62, 0xbf, 0x2a, 0x93, 0x86, 0x74, 0xd0, 0x99, 0xdc, 0x9a, - 0x9a, 0x02, 0x57, 0x21, 0x55, 0xb5, 0x4e, 0xec, 0x38, 0xf1, 0xc2, 0xcf, 0xd3, 0x11, 0xc7, 0x36, 0x3e, 0x0f, 0x45, - 0x7d, 0x92, 0xf7, 0x69, 0xe9, 0xfa, 0xd0, 0x25, 0xd7, 0x06, 0x69, 0x7a, 0x3b, 0xa2, 0x2b, 0x3f, 0xbc, 0xa6, 0x31, - 0x4d, 0x5f, 0x39, 0xba, 0x4f, 0x73, 0xf3, 0x49, 0xdb, 0x58, 0xb2, 0xf9, 0xd1, 0x5f, 0xf2, 0xca, 0xac, 0x43, 0x28, - 0x72, 0x99, 0x82, 0xfb, 0x7d, 0x3e, 0xaa, 0xc9, 0xf6, 0x3b, 0x78, 0x14, 0x88, 0x2f, 0x1b, 0x81, 0x30, 0xfd, 0xe2, - 0xc1, 0x70, 0x23, 0xaf, 0x06, 0xe6, 0x6a, 0x82, 0xeb, 0x75, 0x7d, 0x02, 0xe9, 0xd9, 0x1a, 0x03, 0x1b, 0x21, 0x53, - 0x57, 0xc1, 0x7b, 0xf6, 0x2e, 0x68, 0x6f, 0xe0, 0x37, 0x7b, 0xc0, 0x08, 0xb3, 0x7a, 0xcb, 0x08, 0x28, 0x0c, 0x29, - 0xd4, 0x4d, 0x93, 0x14, 0x0d, 0xa1, 0x02, 0x06, 0xfc, 0xfc, 0x45, 0xe8, 0xc2, 0xd3, 0x12, 0xe8, 0x7f, 0x70, 0x3e, - 0xd4, 0x8a, 0x32, 0xce, 0x2f, 0x5a, 0x6c, 0x69, 0xee, 0x34, 0x4f, 0x4c, 0x7e, 0xec, 0x23, 0x3c, 0x4f, 0xe5, 0x38, - 0x9c, 0xdd, 0xd7, 0xe9, 0x4a, 0x7b, 0xa9, 0x39, 0x9e, 0x34, 0xff, 0x6a, 0xe3, 0xcb, 0xbc, 0x13, 0x91, 0x38, 0xc1, - 0x5d, 0x80, 0x7f, 0x3d, 0x8f, 0x24, 0x61, 0x38, 0x5d, 0x34, 0xdf, 0x14, 0xef, 0x56, 0x13, 0x6f, 0x71, 0xd5, 0x22, - 0x8d, 0xdb, 0x43, 0xdc, 0xf7, 0x7e, 0x0d, 0x9e, 0x3b, 0xdb, 0xf5, 0x7c, 0xd8, 0x0a, 0x1e, 0x90, 0xc9, 0xe5, 0x14, - 0x08, 0x5e, 0xc4, 0x62, 0x32, 0x0f, 0xa9, 0x57, 0xb6, 0x0e, 0xcb, 0xd2, 0x79, 0xa5, 0xb6, 0x89, 0x7a, 0xc5, 0xb8, - 0x96, 0x6f, 0x76, 0xeb, 0x45, 0x5c, 0x12, 0x0b, 0x2d, 0xae, 0x95, 0x56, 0xaa, 0x59, 0x9f, 0x18, 0x5b, 0x8e, 0xda, - 0x76, 0xff, 0x7e, 0x83, 0xc8, 0x6a, 0x9f, 0x5f, 0x3e, 0x2e, 0x88, 0x81, 0x0f, 0x99, 0xa3, 0xf4, 0xf8, 0x02, 0xad, - 0xb2, 0x6e, 0xad, 0xbd, 0x3a, 0xed, 0x4e, 0xa6, 0xdf, 0x96, 0xf5, 0x61, 0x17, 0x8c, 0xd7, 0x05, 0xb1, 0xed, 0x51, - 0xe8, 0x27, 0xd6, 0xe7, 0x7b, 0xaa, 0x10, 0xfe, 0x6d, 0x7a, 0xff, 0xb3, 0xb7, 0xcd, 0x73, 0xa9, 0x22, 0x8e, 0x90, - 0x79, 0xa2, 0x36, 0x8c, 0x95, 0x92, 0xbd, 0xa0, 0x43, 0x8a, 0xd5, 0x8c, 0x42, 0x03, 0x81, 0x54, 0x37, 0xbd, 0x93, - 0x57, 0x03, 0x80, 0x29, 0x66, 0xb0, 0xe1, 0x70, 0x17, 0xf0, 0x0e, 0xb5, 0x82, 0x70, 0x9c, 0x33, 0xaa, 0x96, 0x2e, - 0xb5, 0xde, 0x8e, 0x9f, 0xc2, 0x51, 0x1d, 0x70, 0xd1, 0xfe, 0x78, 0x2c, 0xd8, 0x8a, 0x44, 0x0d, 0x71, 0x2e, 0x4d, - 0x5a, 0xa8, 0x0f, 0x51, 0x8f, 0x7d, 0x37, 0x68, 0x33, 0xbc, 0x05, 0x5f, 0x11, 0xb8, 0xc2, 0x2f, 0x71, 0x70, 0xcb, - 0x74, 0xb8, 0x87, 0xad, 0xeb, 0x9a, 0xe8, 0x8b, 0xfa, 0x33, 0x66, 0x59, 0x08, 0x72, 0x7a, 0xc2, 0x3f, 0xa8, 0x85, - 0x4a, 0x41, 0xf0, 0x72, 0x2e, 0xe0, 0xfe, 0x1c, 0x46, 0x4f, 0x48, 0xf9, 0xa1, 0x88, 0x04, 0x69, 0x1d, 0x99, 0x1a, - 0x1c, 0xf7, 0x58, 0x97, 0x18, 0x66, 0x2f, 0x82, 0x83, 0xc5, 0xac, 0x11, 0x59, 0xd5, 0x23, 0xf8, 0xcd, 0x93, 0xa6, - 0x75, 0x88, 0x25, 0x85, 0x1a, 0xd6, 0x54, 0xfa, 0x5b, 0x10, 0xa9, 0x4d, 0x97, 0x7f, 0x02, 0x74, 0x6d, 0x4f, 0x94, - 0x9e, 0xf6, 0x92, 0x5a, 0x54, 0x1d, 0xda, 0x46, 0xc2, 0xdc, 0xa5, 0xc0, 0xd0, 0x38, 0xf0, 0x00, 0xb1, 0xf6, 0xae, - 0xc8, 0xe4, 0x3d, 0x74, 0x99, 0x3c, 0x44, 0xd5, 0x4e, 0x8d, 0xed, 0x72, 0xca, 0x0f, 0x52, 0x6d, 0x61, 0xe4, 0x14, - 0x75, 0x4a, 0x95, 0x17, 0x46, 0x08, 0xea, 0xd6, 0x57, 0xc7, 0xba, 0x08, 0xcd, 0xc3, 0x6a, 0xed, 0x44, 0x2f, 0xb1, - 0xcc, 0xfe, 0xd1, 0x20, 0xce, 0xcc, 0xc2, 0x40, 0x73, 0xfe, 0x53, 0xb7, 0x18, 0xa2, 0xfd, 0x5f, 0xf2, 0xb0, 0x5e, - 0x77, 0xfe, 0x74, 0x5c, 0x78, 0x69, 0xb7, 0x4b, 0x77, 0x1b, 0xbd, 0x37, 0xe0, 0x1a, 0x8c, 0xf9, 0x93, 0x7c, 0xa6, - 0x8d, 0x08, 0xa8, 0xf8, 0x36, 0x7c, 0x7c, 0x3f, 0xda, 0x47, 0xe4, 0x21, 0x72, 0x98, 0x3f, 0x46, 0xbf, 0x13, 0x6c, - 0x51, 0x6b, 0x44, 0xb2, 0x8a, 0xb0, 0x20, 0x35, 0x77, 0xf8, 0xd6, 0x23, 0xdf, 0x5c, 0x57, 0x3b, 0xf1, 0x79, 0x0d, - 0x02, 0xa8, 0x58, 0x4d, 0x1b, 0x07, 0xfa, 0xdc, 0xf6, 0x19, 0xcf, 0x41, 0x13, 0x1d, 0x85, 0x43, 0xfc, 0xf3, 0x9c, - 0x73, 0xb4, 0xa3, 0x9d, 0x1c, 0x87, 0xc7, 0xd8, 0x2b, 0xc5, 0xb9, 0xff, 0x8c, 0x42, 0x13, 0x96, 0x9f, 0xe5, 0x3b, - 0xd4, 0x07, 0xfc, 0x3c, 0xe5, 0x7f, 0x5c, 0xf5, 0x40, 0x88, 0x3d, 0x21, 0x00, 0xce, 0x9f, 0xfe, 0x23, 0x14, 0xf2, - 0xa7, 0x12, 0x2e, 0xfc, 0x07, 0x86, 0x84, 0x17, 0xc1, 0x3f, 0xc1, 0xef, 0x2c, 0x31, 0x3a, 0x4c, 0x51, 0xa1, 0xfc, - 0xa3, 0x03, 0x21, 0x5f, 0x73, 0x76, 0x6d, 0x0e, 0x9f, 0xcf, 0x99, 0xe5, 0x0b, 0xae, 0x09, 0xf5, 0x79, 0x2b, 0x30, - 0xff, 0xa6, 0xc9, 0x3e, 0x09, 0x48, 0x2e, 0xfc, 0x56, 0xdc, 0xad, 0x56, 0x93, 0x3c, 0x8a, 0x14, 0xfd, 0x66, 0x1a, - 0x2b, 0x6f, 0xbc, 0x45, 0x89, 0xb6, 0x43, 0x2f, 0x4d, 0x9f, 0xcb, 0x17, 0x84, 0xd9, 0x56, 0xc7, 0x89, 0xd9, 0x1f, - 0xdc, 0x5d, 0xa7, 0x4b, 0x2c, 0x41, 0x64, 0x18, 0x77, 0xc7, 0x60, 0x1d, 0xbe, 0x5a, 0x19, 0x2a, 0x63, 0x11, 0x4a, - 0x15, 0x2d, 0x3d, 0xfc, 0x42, 0x37, 0x71, 0x51, 0xba, 0x99, 0x72, 0xcc, 0xf4, 0x77, 0x68, 0xfd, 0x6b, 0x35, 0x3a, - 0xbb, 0x24, 0x7c, 0xf0, 0x78, 0x2f, 0xe8, 0x6f, 0x3a, 0x64, 0x17, 0xe1, 0x2f, 0x1f, 0x5f, 0xaa, 0x25, 0x0b, 0xa3, - 0x9b, 0xce, 0xa7, 0x34, 0x7b, 0xbb, 0xaf, 0x32, 0x0a, 0x4d, 0x0d, 0x85, 0x91, 0x38, 0x2b, 0xc7, 0x65, 0xef, 0x4c, - 0xd6, 0xf5, 0x73, 0xcf, 0xaa, 0x94, 0x5d, 0x48, 0xb0, 0xa8, 0x97, 0x7b, 0xf7, 0x0d, 0x5a, 0x48, 0xa1, 0x06, 0xd2, - 0x16, 0x03, 0x1d, 0xba, 0x67, 0x38, 0xd1, 0x25, 0x94, 0x40, 0xa4, 0x0f, 0x57, 0x59, 0xd4, 0xf4, 0x45, 0x4c, 0xa0, - 0x4f, 0x3d, 0x5b, 0xec, 0x6c, 0xd7, 0x28, 0x3b, 0x8c, 0x02, 0x72, 0xf7, 0x86, 0x67, 0x46, 0x1f, 0xef, 0xdf, 0xc8, - 0x6a, 0xf9, 0x7f, 0xa3, 0x46, 0xdb, 0x3b, 0x47, 0xa0, 0xe1, 0x99, 0xb7, 0x4b, 0x22, 0x12, 0x24, 0x2c, 0x7e, 0x3e, - 0x79, 0xf6, 0x7d, 0x17, 0x4a, 0xa4, 0xe0, 0xd0, 0x57, 0x63, 0xba, 0x7c, 0xa9, 0x26, 0xca, 0x47, 0x62, 0xc0, 0x4f, - 0x3a, 0x0f, 0x12, 0x5d, 0x4d, 0x73, 0xb0, 0x43, 0x39, 0x70, 0x7b, 0x73, 0xc6, 0xf9, 0x63, 0xbe, 0xc1, 0xca, 0xc1, - 0x93, 0xed, 0x9f, 0x7a, 0xb9, 0x8d, 0x51, 0xc5, 0x4f, 0x44, 0x63, 0x19, 0xf0, 0xf0, 0xd9, 0xe9, 0x08, 0xed, 0x8c, - 0x64, 0x01, 0xca, 0x7b, 0xbb, 0x3f, 0x86, 0x4b, 0xf8, 0x99, 0x1a, 0xef, 0x59, 0xdb, 0xa1, 0xa5, 0xdb, 0xf8, 0xa6, - 0xe4, 0x71, 0x78, 0x60, 0x2d, 0xc5, 0x6a, 0x6c, 0x0d, 0x10, 0x97, 0xb8, 0xa3, 0x6c, 0xad, 0xe2, 0xe2, 0xfe, 0x5f, - 0x1e, 0x9e, 0x39, 0x07, 0x81, 0x2a, 0xe1, 0x60, 0x22, 0x35, 0x23, 0xb6, 0x91, 0x63, 0xc7, 0x6b, 0x46, 0x1c, 0x5c, - 0x01, 0x69, 0x23, 0x26, 0x9a, 0x53, 0xb9, 0x0f, 0xc6, 0xf3, 0xe8, 0x8d, 0xaa, 0x8f, 0x73, 0xe6, 0x81, 0x6d, 0x70, - 0x27, 0x55, 0x1b, 0x16, 0x26, 0xbe, 0xd9, 0xad, 0xa5, 0xe9, 0xcb, 0x8e, 0xac, 0x17, 0x6c, 0xcf, 0x4a, 0x10, 0xfa, - 0x54, 0xfa, 0x37, 0x1a, 0xe2, 0xb9, 0xae, 0x5f, 0x47, 0x17, 0xed, 0x87, 0xb9, 0xc3, 0xfe, 0xee, 0xf8, 0xb4, 0x61, - 0x62, 0x1d, 0x7d, 0x1e, 0x3b, 0x2b, 0xcc, 0xb3, 0x6b, 0x4d, 0x3f, 0xb5, 0xf1, 0xd0, 0xc7, 0xbe, 0xb4, 0x56, 0x66, - 0xb0, 0x2a, 0x28, 0xbb, 0x53, 0x53, 0x03, 0x61, 0x0d, 0xea, 0x3a, 0x99, 0x64, 0x33, 0x65, 0xbf, 0x3c, 0x03, 0xb3, - 0xdf, 0x45, 0xc9, 0x15, 0xfa, 0xeb, 0x7d, 0x69, 0x52, 0xe7, 0x3b, 0xda, 0x22, 0x47, 0xb4, 0xc5, 0xa0, 0x16, 0x11, - 0xef, 0xd4, 0xd7, 0x29, 0xc9, 0x47, 0x2f, 0x5a, 0x82, 0x30, 0xb5, 0xa4, 0xdd, 0x15, 0x28, 0x61, 0x99, 0x91, 0xcf, - 0xf6, 0x13, 0xe3, 0xfd, 0xd3, 0xf8, 0xa5, 0x63, 0xd2, 0x76, 0xb5, 0x6b, 0x07, 0x23, 0xd7, 0xd0, 0x54, 0x41, 0xe3, - 0x16, 0xdf, 0x61, 0xa0, 0x9f, 0xe2, 0x48, 0xdb, 0xaf, 0x35, 0x4f, 0x5f, 0xda, 0xd6, 0xf3, 0xea, 0xf6, 0x89, 0x5a, - 0xeb, 0xc0, 0xb1, 0x33, 0xb4, 0x27, 0x6f, 0x4c, 0x90, 0x0f, 0x7d, 0x3e, 0x3c, 0x0d, 0xa7, 0x26, 0x1f, 0x9d, 0xa5, - 0x90, 0xc8, 0x1e, 0x15, 0x5f, 0x60, 0x3e, 0x1f, 0x28, 0x15, 0x51, 0x1b, 0xef, 0xdd, 0xd6, 0x6e, 0xbe, 0x8f, 0x47, - 0xab, 0x76, 0x8d, 0xd1, 0x46, 0xc2, 0x02, 0x3c, 0x54, 0x89, 0xd2, 0x21, 0x0e, 0xfc, 0x67, 0x92, 0x76, 0x16, 0x75, - 0x8d, 0xb7, 0x65, 0xc3, 0xa4, 0xf9, 0x3c, 0x95, 0x7a, 0x19, 0x77, 0xd8, 0x56, 0x6e, 0xf6, 0xd1, 0x13, 0xd1, 0xbe, - 0x66, 0x6d, 0x3e, 0x41, 0x50, 0x76, 0xb5, 0xc3, 0xbd, 0xea, 0x88, 0x1d, 0x27, 0x6c, 0xbf, 0xd9, 0x7c, 0xe7, 0xa8, - 0x14, 0xa5, 0xc6, 0x09, 0x6b, 0xdd, 0xd4, 0x4e, 0x34, 0x87, 0x30, 0xfc, 0xd2, 0x37, 0xf1, 0x12, 0x52, 0x37, 0x1c, - 0xf3, 0xf6, 0xfe, 0x79, 0x58, 0xd7, 0xc2, 0x09, 0x45, 0xb2, 0x26, 0xf6, 0xde, 0x20, 0xdd, 0xc1, 0x2a, 0x0c, 0x9f, - 0x90, 0x5b, 0x67, 0x75, 0xf2, 0x26, 0x78, 0xa1, 0x21, 0xb2, 0x93, 0x21, 0xdf, 0x32, 0x0e, 0x2c, 0xdd, 0xc0, 0xfe, - 0x5a, 0x95, 0x64, 0x95, 0x27, 0x6a, 0xaf, 0x52, 0xa6, 0x69, 0x49, 0xc1, 0xf2, 0x29, 0xb3, 0x07, 0x47, 0x5e, 0xf3, - 0x65, 0x73, 0xeb, 0x9b, 0x77, 0x4f, 0x9d, 0xf5, 0xd0, 0x2e, 0x76, 0xbd, 0xb5, 0x29, 0x9c, 0xe0, 0x23, 0x49, 0xfc, - 0x50, 0xfb, 0xd9, 0x7e, 0xb0, 0x71, 0xff, 0xa4, 0xf6, 0x03, 0xce, 0xec, 0x53, 0x74, 0x98, 0x87, 0x49, 0x9f, 0x15, - 0x24, 0x1c, 0xd0, 0xba, 0x8f, 0x45, 0xa6, 0xc0, 0x4e, 0x03, 0x9c, 0x40, 0x8d, 0xd8, 0xe3, 0x22, 0x07, 0xf4, 0xa6, - 0x6a, 0x6a, 0x31, 0xdf, 0xd3, 0x91, 0x3b, 0x9c, 0x62, 0x06, 0xbf, 0x68, 0xd8, 0xd2, 0xbc, 0xfa, 0xb8, 0xad, 0x1b, - 0xf4, 0x1c, 0xa4, 0x48, 0xdc, 0x20, 0xa6, 0x49, 0xf7, 0x15, 0x7a, 0xea, 0xeb, 0x37, 0xb9, 0x1d, 0xf7, 0x1d, 0xa7, - 0x8d, 0x76, 0x1b, 0xee, 0x62, 0x95, 0x4d, 0x3b, 0xa4, 0xa3, 0x06, 0xea, 0x4b, 0xff, 0x64, 0x45, 0xa7, 0xa7, 0x29, - 0x42, 0x57, 0x62, 0xdb, 0x04, 0x60, 0x72, 0x50, 0xd8, 0x59, 0x20, 0x09, 0x36, 0x38, 0x71, 0x2c, 0x13, 0x8d, 0xec, - 0x85, 0xbe, 0xda, 0xed, 0x18, 0x18, 0xf8, 0xb9, 0x27, 0xd1, 0x6f, 0xef, 0x2c, 0x52, 0x34, 0x6b, 0x19, 0x7e, 0x65, - 0x22, 0x45, 0x1f}; + 0x5b, 0x25, 0x30, 0x31, 0xd8, 0x36, 0xe9, 0x61, 0xe3, 0x00, 0x60, 0x50, 0x5d, 0x4d, 0x51, 0xd4, 0x92, 0x56, 0xab, + 0xc8, 0x00, 0xb5, 0x2e, 0xe0, 0x86, 0x0c, 0xde, 0x40, 0xed, 0x0b, 0x51, 0x9e, 0x7c, 0xa9, 0xe3, 0x15, 0x8f, 0x68, + 0x88, 0x06, 0x83, 0xb5, 0x60, 0x5c, 0xd1, 0xbd, 0xae, 0xb7, 0x83, 0xfd, 0x68, 0x41, 0x5d, 0xb4, 0x1a, 0xb5, 0x3e, + 0x51, 0x4a, 0xbd, 0xa5, 0x0a, 0xc9, 0xdf, 0x44, 0xc9, 0xeb, 0x2c, 0x5a, 0x0c, 0xac, 0xf7, 0x20, 0x87, 0x7a, 0xa3, + 0xd9, 0x05, 0xa2, 0x58, 0x3c, 0x31, 0xc4, 0x68, 0xa2, 0x64, 0x38, 0x42, 0x63, 0x9f, 0xe4, 0xfe, 0xaf, 0xa6, 0x65, + 0xd5, 0x92, 0x1a, 0x2d, 0x16, 0xdf, 0xfc, 0xa0, 0x44, 0xcf, 0x5e, 0xf9, 0xd4, 0x27, 0xd6, 0x73, 0x7b, 0x8f, 0xcb, + 0xce, 0xa9, 0xd1, 0xe8, 0xd3, 0x12, 0xac, 0xe1, 0x5b, 0x99, 0x54, 0x08, 0xf8, 0x0a, 0x88, 0x14, 0x5d, 0x91, 0xa2, + 0xca, 0xff, 0xb6, 0xd4, 0xce, 0x93, 0xcb, 0x09, 0x3b, 0x79, 0x19, 0x68, 0x40, 0x48, 0xc2, 0xce, 0xae, 0x2c, 0xaf, + 0xe9, 0xbe, 0x92, 0xe5, 0xcb, 0x20, 0xb0, 0xc6, 0xf0, 0xc5, 0x48, 0x22, 0x76, 0x4a, 0xb8, 0x5f, 0x6a, 0xef, 0xbf, + 0xce, 0xfe, 0xeb, 0x77, 0xbd, 0xaf, 0xd9, 0x5b, 0x61, 0x5f, 0x47, 0x72, 0xa4, 0xd6, 0x80, 0xb4, 0xa2, 0x15, 0xf7, + 0xc6, 0x0c, 0xe4, 0x04, 0x33, 0x97, 0x1c, 0x0f, 0xa4, 0x58, 0x81, 0xaf, 0x57, 0xb5, 0xca, 0x2f, 0x89, 0x34, 0x5a, + 0xc7, 0x12, 0xff, 0x3a, 0xd7, 0x3d, 0x18, 0x9c, 0xcb, 0x7d, 0x74, 0x7b, 0x7c, 0x02, 0xc7, 0x9b, 0x08, 0x2c, 0xdf, + 0xf6, 0x5a, 0x7e, 0xfd, 0x3a, 0xe9, 0x9a, 0x3c, 0x14, 0x21, 0x10, 0xc6, 0xeb, 0xd9, 0x71, 0x4a, 0x6b, 0xdb, 0xcf, + 0xbe, 0xde, 0x82, 0x95, 0xa9, 0xd9, 0xeb, 0xeb, 0xc8, 0x42, 0x2f, 0x7a, 0xc7, 0xe9, 0x47, 0xaa, 0x85, 0xcb, 0x9f, + 0x0f, 0x8d, 0x2a, 0xd3, 0xa7, 0xd9, 0x3b, 0x39, 0x80, 0x2a, 0x08, 0xce, 0x1a, 0x5b, 0x9e, 0x49, 0x64, 0x91, 0xbc, + 0x51, 0xd4, 0x5d, 0x75, 0x05, 0xc1, 0x76, 0x1b, 0xe0, 0x6c, 0x53, 0x5b, 0x80, 0xfc, 0xff, 0xa6, 0x69, 0x5f, 0x5a, + 0x00, 0xd9, 0x24, 0xff, 0x5f, 0x67, 0xc3, 0xd9, 0xd8, 0xd8, 0x20, 0x21, 0xa9, 0xef, 0x4d, 0x94, 0x12, 0xf7, 0xde, + 0xf7, 0xee, 0x74, 0xd9, 0xdf, 0x55, 0x30, 0x5f, 0x70, 0x3d, 0x42, 0xbb, 0xa3, 0x66, 0x93, 0x5c, 0xfa, 0x73, 0x28, + 0xb3, 0xf7, 0xbd, 0x57, 0x80, 0x0a, 0x85, 0x6e, 0x2e, 0x80, 0xa6, 0xe6, 0xa0, 0xbb, 0xa9, 0x3d, 0x4d, 0x8e, 0xa3, + 0xf8, 0x1d, 0x45, 0x31, 0xd0, 0x68, 0xbd, 0xec, 0x1a, 0x67, 0xa2, 0x84, 0xb3, 0xc6, 0xd8, 0x24, 0xdb, 0x20, 0xd2, + 0x64, 0xbb, 0xd9, 0xa6, 0x6b, 0x2a, 0x47, 0x41, 0xd7, 0xc1, 0x0f, 0x6b, 0xaf, 0x77, 0x92, 0xe4, 0x5f, 0x62, 0xea, + 0x75, 0x4b, 0xd2, 0x7f, 0xbb, 0x8b, 0x65, 0x3d, 0x08, 0x01, 0x42, 0xe8, 0x71, 0xe2, 0x76, 0x5f, 0x74, 0xf6, 0x8f, + 0x2b, 0xa3, 0x47, 0xa0, 0xdc, 0x6f, 0x12, 0x0f, 0x79, 0xc4, 0x53, 0x96, 0x65, 0xc3, 0xb7, 0x6d, 0x04, 0xbb, 0xaf, + 0x8a, 0x4c, 0xac, 0x3d, 0x0e, 0x00, 0xa7, 0xe5, 0x88, 0xb6, 0x10, 0x32, 0x20, 0x89, 0x73, 0x0f, 0xdf, 0x9b, 0x46, + 0x30, 0x1d, 0xed, 0x21, 0xde, 0x9b, 0xc3, 0x81, 0x1d, 0x68, 0x94, 0x38, 0x76, 0xe0, 0x10, 0x7e, 0xfc, 0x06, 0xbd, + 0x75, 0x08, 0x0c, 0x18, 0xda, 0xb4, 0x83, 0x12, 0x6c, 0x75, 0x23, 0x18, 0x9e, 0xd5, 0x55, 0x4a, 0xff, 0xbd, 0xf6, + 0xf9, 0xf5, 0xd9, 0x15, 0x97, 0xa5, 0xe0, 0x5f, 0xe8, 0x2c, 0xd3, 0x8e, 0xb0, 0x24, 0x5f, 0x0a, 0xb6, 0x01, 0x2f, + 0x95, 0x50, 0x1f, 0x16, 0x20, 0x0e, 0xc3, 0xdb, 0xf2, 0xd2, 0xb5, 0xe3, 0x3c, 0x33, 0x76, 0x6a, 0x74, 0x25, 0xf9, + 0xc0, 0xcf, 0xea, 0xe6, 0xd9, 0x55, 0x28, 0xe9, 0xb1, 0x8b, 0xd4, 0xba, 0x4d, 0x77, 0xe8, 0x02, 0x17, 0xfd, 0xf1, + 0xa0, 0xd2, 0xd7, 0xfd, 0x1c, 0x2f, 0x68, 0x2a, 0xbc, 0x24, 0x32, 0xe2, 0x87, 0x0e, 0xa3, 0x06, 0x45, 0x47, 0xb7, + 0x87, 0x25, 0x29, 0x77, 0x46, 0xf3, 0xdd, 0xd5, 0x2f, 0xb3, 0xf4, 0x27, 0x9c, 0x73, 0xb6, 0xc4, 0x1f, 0x73, 0x49, + 0x3c, 0xfe, 0x3f, 0x0e, 0x8f, 0x07, 0x63, 0xde, 0xd1, 0x1f, 0x5f, 0x9f, 0x5d, 0x79, 0xba, 0x3d, 0xb3, 0x6b, 0xc6, + 0x3d, 0x74, 0xeb, 0xc1, 0xa1, 0xdb, 0xaf, 0xfd, 0xd6, 0x78, 0x16, 0xee, 0x1b, 0xd9, 0xd6, 0xe8, 0x1f, 0x23, 0x99, + 0xe9, 0x59, 0xd8, 0x5d, 0xbd, 0xfc, 0xc2, 0xed, 0x74, 0x3e, 0x42, 0xa6, 0x57, 0x73, 0x18, 0xcf, 0xd5, 0x61, 0xd0, + 0x69, 0x43, 0x52, 0x3c, 0x26, 0xf8, 0xa4, 0xc9, 0xd7, 0x4b, 0xba, 0xe8, 0xf5, 0xc8, 0x20, 0x3f, 0xdd, 0x44, 0x6e, + 0xa4, 0x5a, 0x20, 0x5e, 0x9d, 0x94, 0x43, 0x30, 0xf9, 0xdd, 0x94, 0xf8, 0xd8, 0xb5, 0xf7, 0x52, 0xf5, 0xf5, 0x62, + 0xed, 0xce, 0xba, 0x59, 0x30, 0xcf, 0x27, 0xb7, 0xa9, 0x07, 0x4d, 0x08, 0xc8, 0x73, 0x5d, 0xe7, 0x49, 0x64, 0x02, + 0xc2, 0x4c, 0xcc, 0x26, 0x30, 0xf1, 0xe6, 0x6d, 0x57, 0xaf, 0x6d, 0xa7, 0x21, 0xbf, 0x03, 0xd0, 0xa4, 0x46, 0x6b, + 0x22, 0xbd, 0x44, 0x40, 0x66, 0xd2, 0x26, 0xe2, 0x89, 0x88, 0xea, 0xea, 0xdc, 0x08, 0x7b, 0x47, 0x32, 0x51, 0xd0, + 0x5a, 0x72, 0x91, 0x35, 0x76, 0xd7, 0xa1, 0x32, 0xf0, 0xf7, 0xab, 0xc5, 0xba, 0x19, 0x59, 0x04, 0x21, 0xfc, 0xd3, + 0x40, 0x90, 0x94, 0x83, 0xdf, 0x08, 0xf1, 0x08, 0x59, 0x44, 0xf6, 0x5e, 0x53, 0xdd, 0xda, 0x99, 0x42, 0x76, 0xb4, + 0x8e, 0xab, 0x75, 0x2e, 0x92, 0xce, 0xbe, 0xe6, 0x31, 0x6b, 0x68, 0xad, 0x6c, 0xdf, 0x31, 0x5b, 0x96, 0xb2, 0xc4, + 0x6b, 0x0c, 0x00, 0x2b, 0xc8, 0x08, 0xab, 0x02, 0x1e, 0xe2, 0xb2, 0x44, 0xbc, 0x8e, 0x2d, 0x44, 0x10, 0x85, 0x87, + 0x8d, 0xdf, 0xac, 0xae, 0xbd, 0xf9, 0x3b, 0xa1, 0x70, 0x59, 0x0a, 0x5f, 0x5c, 0xfe, 0x38, 0x60, 0x0d, 0xc4, 0xe8, + 0x56, 0xcf, 0xd5, 0x04, 0xa4, 0x6d, 0x81, 0x3c, 0x79, 0x0d, 0xfd, 0x43, 0xc2, 0x3b, 0x02, 0xd7, 0xc6, 0x01, 0xd7, + 0xb0, 0xdb, 0x7c, 0x3b, 0x65, 0x22, 0x3e, 0xea, 0x2c, 0x9d, 0x33, 0xdc, 0x16, 0x0f, 0x20, 0xab, 0x60, 0xf4, 0x92, + 0x42, 0xaa, 0x39, 0xfa, 0xf1, 0xc7, 0x22, 0x3d, 0x2c, 0x3f, 0xd2, 0x84, 0x4e, 0x1b, 0xbb, 0x72, 0x41, 0x11, 0x84, + 0x28, 0xfe, 0xf9, 0x05, 0x30, 0xc1, 0xea, 0x73, 0xf8, 0x25, 0xb5, 0x9d, 0xab, 0x8d, 0x90, 0x4a, 0x46, 0xa9, 0x93, + 0x86, 0xde, 0xd7, 0x35, 0x82, 0x06, 0xfc, 0xa1, 0x48, 0x28, 0xe1, 0xd6, 0x64, 0x21, 0x73, 0x16, 0x29, 0x9d, 0xee, + 0x74, 0xd8, 0x54, 0x52, 0xc9, 0xce, 0x1e, 0xe6, 0x3c, 0x41, 0x96, 0x15, 0x2d, 0xf7, 0x83, 0xd4, 0x99, 0xa9, 0x90, + 0xca, 0x0a, 0x07, 0x4c, 0x5e, 0x86, 0xc7, 0xcc, 0x4c, 0x50, 0x57, 0x83, 0xed, 0x98, 0x84, 0xf1, 0x8f, 0x02, 0x02, + 0x6c, 0xed, 0x4a, 0x35, 0x05, 0xbb, 0x1e, 0x55, 0xf9, 0x7a, 0x5a, 0x72, 0xea, 0xe1, 0xd7, 0xe7, 0xe6, 0x28, 0x0f, + 0xd4, 0xf0, 0xb0, 0x61, 0xa4, 0xf1, 0x6e, 0x1c, 0x8b, 0x39, 0x8f, 0x26, 0x7b, 0x48, 0xa8, 0x5c, 0x18, 0xd5, 0x05, + 0x0f, 0xd6, 0xbc, 0xe1, 0xd7, 0xc9, 0x3c, 0x8f, 0x22, 0xda, 0x67, 0xf0, 0x41, 0x2a, 0x5e, 0x0f, 0xe7, 0x07, 0x53, + 0x57, 0x80, 0x70, 0xe8, 0xe8, 0x2b, 0x51, 0xce, 0x70, 0xeb, 0xfc, 0x41, 0x69, 0x50, 0x05, 0xf5, 0x32, 0x05, 0xc1, + 0x29, 0xb9, 0xee, 0x2e, 0xea, 0x55, 0xd9, 0x0c, 0x7e, 0x4b, 0x9f, 0x9e, 0x2b, 0x4c, 0x55, 0x35, 0xa6, 0x38, 0x62, + 0x02, 0x78, 0xbb, 0xfd, 0x88, 0x2b, 0xb5, 0xda, 0xcb, 0x04, 0x77, 0x85, 0xbd, 0x82, 0x58, 0xd6, 0x19, 0xa8, 0x90, + 0x7f, 0xbc, 0x8d, 0xb4, 0x1f, 0x5d, 0xdb, 0x13, 0x84, 0x12, 0x9c, 0xb4, 0x81, 0xa0, 0xae, 0xa3, 0x82, 0xda, 0x0b, + 0x41, 0x1c, 0xd0, 0x36, 0x0e, 0x94, 0x05, 0xcf, 0xa9, 0xca, 0x5b, 0xdb, 0xba, 0x79, 0xd5, 0x5e, 0xe2, 0xc6, 0x47, + 0xbb, 0xdb, 0x67, 0x0d, 0xd6, 0xf6, 0xa9, 0x95, 0x6c, 0xc9, 0x63, 0x21, 0xdd, 0x8f, 0xb0, 0x80, 0xe1, 0xf1, 0xd0, + 0xc7, 0x5c, 0x5e, 0xa8, 0xf2, 0x05, 0x0f, 0x27, 0xe5, 0xdb, 0x3b, 0x21, 0xed, 0x7a, 0x0b, 0x1a, 0x80, 0xf8, 0x3a, + 0xf5, 0xe7, 0x48, 0xc1, 0x8a, 0xfa, 0x0f, 0xc0, 0x89, 0x4a, 0x4d, 0x16, 0x19, 0x61, 0x9c, 0xa0, 0xbe, 0xcc, 0x30, + 0xaf, 0xd8, 0xcb, 0x76, 0x8e, 0x1f, 0xb7, 0x40, 0xe7, 0x36, 0xe6, 0x63, 0x40, 0xd9, 0x92, 0xa2, 0x0c, 0x49, 0x66, + 0x25, 0x38, 0xdd, 0x73, 0x63, 0xa4, 0x15, 0x75, 0xe6, 0x9b, 0x29, 0xab, 0x58, 0x5e, 0x9d, 0x6e, 0x08, 0x2e, 0xbd, + 0x87, 0xcd, 0xaf, 0xfa, 0xb7, 0x4e, 0xaf, 0x91, 0xb4, 0xe1, 0x97, 0x15, 0x29, 0x54, 0xad, 0x4d, 0x6b, 0xab, 0x9f, + 0x38, 0x38, 0x0f, 0x04, 0x78, 0xe0, 0x2f, 0x4d, 0x4d, 0xc9, 0xcf, 0xde, 0x8d, 0xea, 0xc9, 0xaf, 0xeb, 0xd5, 0xf0, + 0xbe, 0x8a, 0x52, 0xbd, 0x80, 0xa0, 0x7e, 0x28, 0xb2, 0x08, 0xa3, 0x7d, 0x61, 0x21, 0x9e, 0xf6, 0xa3, 0xab, 0x01, + 0x61, 0x51, 0xaf, 0xb9, 0x76, 0xde, 0x5a, 0x2a, 0x10, 0xd2, 0x37, 0xd6, 0xc5, 0xf2, 0xdd, 0x4f, 0xe9, 0x46, 0x3d, + 0xc0, 0xc1, 0xa1, 0x7a, 0xd1, 0x9a, 0x8c, 0x18, 0x53, 0x6d, 0x13, 0xd4, 0x9d, 0xc9, 0xb9, 0x8f, 0xbe, 0xaf, 0x0b, + 0x6e, 0xb7, 0x3f, 0x4c, 0x6a, 0xfd, 0x8d, 0x10, 0x27, 0x38, 0x13, 0x2c, 0xcd, 0x62, 0xfa, 0x20, 0xb1, 0xa2, 0xb3, + 0x08, 0xa8, 0xee, 0x8a, 0x5e, 0xa9, 0xe2, 0xa3, 0x16, 0xb9, 0xa2, 0x94, 0x96, 0x21, 0x7e, 0x81, 0xb3, 0x2a, 0xfe, + 0xd8, 0xd2, 0xe2, 0xf5, 0x8f, 0x17, 0x1f, 0x36, 0xcf, 0x7b, 0x1d, 0x0d, 0x54, 0x52, 0xc4, 0x68, 0x5a, 0x86, 0x5d, + 0xd1, 0x82, 0xde, 0x1c, 0x88, 0x65, 0x63, 0xcf, 0xd9, 0x32, 0x1e, 0xa5, 0x57, 0x89, 0x41, 0xd4, 0x20, 0xbf, 0xa8, + 0xe8, 0x77, 0xb2, 0x60, 0xdc, 0x95, 0xd8, 0x68, 0x10, 0x8c, 0xa6, 0xa2, 0x80, 0x71, 0x10, 0x77, 0xdb, 0x64, 0xc4, + 0x7b, 0x6b, 0x90, 0x14, 0xd2, 0x05, 0xe3, 0x9c, 0xfb, 0x04, 0xf7, 0x13, 0x11, 0x74, 0x18, 0xd7, 0xee, 0xa8, 0x3a, + 0x22, 0x53, 0x5f, 0x8e, 0xa4, 0x7f, 0xd8, 0xe4, 0x6c, 0x3c, 0x90, 0x45, 0x19, 0xc7, 0xd7, 0x46, 0xb5, 0xdf, 0x96, + 0xc2, 0x19, 0xac, 0x55, 0x1d, 0x0c, 0x4b, 0x9d, 0xdc, 0x36, 0x0a, 0xc2, 0x42, 0x50, 0x44, 0x1b, 0x69, 0xc6, 0x1c, + 0x44, 0x79, 0x79, 0xb4, 0x29, 0xaa, 0xd9, 0x56, 0x34, 0x97, 0x06, 0x0a, 0x69, 0x4a, 0xbd, 0xa4, 0xe5, 0x24, 0xbf, + 0xbe, 0x06, 0x23, 0x09, 0xb3, 0xac, 0x7c, 0x76, 0x73, 0xe4, 0x92, 0x08, 0x07, 0x34, 0x24, 0x17, 0x67, 0x4e, 0x55, + 0x33, 0x6d, 0x5a, 0x03, 0x6a, 0x77, 0x91, 0x54, 0xa6, 0x90, 0xc5, 0x66, 0xef, 0x31, 0x11, 0x19, 0xb0, 0x02, 0x66, + 0x2b, 0xff, 0xc3, 0x47, 0x3a, 0x44, 0xb4, 0x21, 0x20, 0x35, 0x48, 0x49, 0x3d, 0x8a, 0xe6, 0xb9, 0x1c, 0x03, 0xfd, + 0x2e, 0xc2, 0xea, 0x32, 0xa3, 0x4b, 0x5a, 0x8b, 0x94, 0x6b, 0xd5, 0x5d, 0x55, 0x9a, 0x41, 0xa6, 0xf4, 0xfb, 0x75, + 0xaf, 0x63, 0x3f, 0xb3, 0x12, 0xa7, 0x94, 0x1b, 0x74, 0xfd, 0xa7, 0xb8, 0x07, 0x59, 0x87, 0x50, 0xfb, 0x91, 0x7a, + 0x6d, 0xcc, 0xe0, 0x8e, 0x6f, 0xec, 0x94, 0x7f, 0x53, 0x29, 0x14, 0x7b, 0x33, 0x54, 0x06, 0x07, 0x55, 0x02, 0xb4, + 0xa5, 0xc7, 0x74, 0x09, 0x98, 0x6a, 0xd1, 0x4c, 0x08, 0x66, 0x63, 0xd8, 0xf7, 0x20, 0xb1, 0xb2, 0xca, 0x11, 0x97, + 0xad, 0xa5, 0x9a, 0xbf, 0x81, 0x5d, 0x4b, 0x72, 0xad, 0x6a, 0xba, 0x44, 0x9a, 0x2a, 0x60, 0xcc, 0x29, 0xa3, 0x3f, + 0x12, 0x18, 0x3b, 0x6b, 0x90, 0xf5, 0x35, 0x37, 0xb3, 0xae, 0x12, 0x96, 0x34, 0xba, 0x3c, 0x0a, 0x75, 0x34, 0x27, + 0xe4, 0xbe, 0x69, 0xb6, 0xd6, 0x5f, 0xed, 0x65, 0x02, 0xe3, 0x9e, 0x4d, 0x8e, 0x9d, 0xd5, 0xd6, 0x31, 0xc7, 0x47, + 0x8b, 0xc2, 0x8e, 0x73, 0x29, 0x91, 0x7b, 0x55, 0x93, 0xb2, 0x65, 0x50, 0x82, 0xe9, 0x2d, 0x06, 0x76, 0x82, 0x3b, + 0x9c, 0x61, 0x6d, 0xd5, 0x29, 0xed, 0x7a, 0xbf, 0x46, 0x50, 0x20, 0x62, 0xbe, 0xfc, 0xb3, 0xec, 0xc2, 0x79, 0xb7, + 0xd9, 0xe8, 0xbe, 0x5d, 0xea, 0x77, 0xe4, 0xa4, 0x55, 0xa8, 0xd0, 0xaa, 0xf0, 0xd8, 0xb1, 0x65, 0x7b, 0x2a, 0xcc, + 0x7e, 0x15, 0x4f, 0x60, 0x1d, 0x6f, 0x0c, 0xd9, 0x42, 0x31, 0x4f, 0x3e, 0xb4, 0x3a, 0x14, 0x0b, 0x4a, 0xc6, 0x84, + 0x4a, 0x5f, 0x8a, 0x61, 0xe5, 0x3f, 0xcd, 0xab, 0x3a, 0x38, 0x2c, 0x31, 0x46, 0xa1, 0x01, 0x17, 0xa9, 0x8d, 0xef, + 0xdb, 0xcf, 0x2a, 0xba, 0xd9, 0x3e, 0xad, 0x17, 0x11, 0xc5, 0x98, 0x9b, 0x55, 0x59, 0xd1, 0x1b, 0xcf, 0xb2, 0x1e, + 0x89, 0x16, 0x70, 0x93, 0x63, 0xdd, 0xae, 0x62, 0x27, 0xfc, 0xad, 0x71, 0xdc, 0xe7, 0xac, 0xa2, 0x7f, 0xda, 0x09, + 0xec, 0x71, 0xba, 0x0a, 0xe6, 0xe4, 0xc7, 0x4e, 0xeb, 0xab, 0x54, 0xf8, 0x2e, 0x57, 0x7f, 0xc1, 0x19, 0x72, 0xd5, + 0x9a, 0xc5, 0xa0, 0x49, 0xe2, 0x4e, 0x6a, 0x80, 0x63, 0xa4, 0x90, 0x50, 0x02, 0x88, 0x9a, 0x17, 0x47, 0x04, 0xc6, + 0x11, 0x7b, 0x23, 0xa7, 0x58, 0x54, 0x3b, 0x64, 0xfe, 0xae, 0x2d, 0xeb, 0x52, 0x56, 0xfb, 0x38, 0x3d, 0x07, 0x35, + 0x74, 0x12, 0x40, 0x97, 0xe4, 0xf9, 0xb4, 0x37, 0x2e, 0x84, 0xc7, 0xaa, 0x39, 0xce, 0xaf, 0xfd, 0xa1, 0xb5, 0x65, + 0x2f, 0x9f, 0x5c, 0x70, 0xac, 0x81, 0x21, 0x33, 0x00, 0x34, 0x9a, 0xad, 0x94, 0xda, 0xb2, 0xeb, 0x44, 0xab, 0xb6, + 0x52, 0xee, 0x71, 0x06, 0xb1, 0xe3, 0x8e, 0x2d, 0xc3, 0xc2, 0xcd, 0x7f, 0x4b, 0xa2, 0xe2, 0x42, 0xbf, 0xe5, 0x28, + 0x5d, 0xc0, 0xd9, 0x53, 0x72, 0x83, 0x33, 0x5e, 0xae, 0x9c, 0xd9, 0x99, 0xca, 0x26, 0x40, 0x54, 0xbd, 0x3f, 0x51, + 0x62, 0x2a, 0x23, 0x1a, 0xfd, 0xc4, 0x59, 0xf0, 0x06, 0x52, 0x25, 0xa4, 0xab, 0x45, 0xbb, 0xa5, 0x89, 0x47, 0x3a, + 0x14, 0x37, 0x12, 0x99, 0x08, 0xa3, 0x0b, 0x58, 0x28, 0xc5, 0x7f, 0xe0, 0xc3, 0xd6, 0xec, 0x4d, 0x1a, 0xc3, 0x42, + 0x66, 0xad, 0xa3, 0x6d, 0x65, 0x45, 0x32, 0x1e, 0x94, 0xea, 0xac, 0xc8, 0x20, 0xaa, 0x5e, 0x62, 0xd6, 0x38, 0xa2, + 0x49, 0x28, 0x4f, 0x93, 0xfd, 0xb7, 0x00, 0x84, 0x7d, 0x4b, 0xcf, 0xdd, 0x22, 0x42, 0xd3, 0xe5, 0x45, 0xb0, 0x10, + 0x74, 0x0e, 0xd8, 0x27, 0x41, 0x79, 0x91, 0x56, 0x50, 0xa8, 0x74, 0x4c, 0xf2, 0x71, 0x95, 0xed, 0x1c, 0x39, 0x06, + 0xf8, 0x38, 0xf3, 0x7e, 0xe8, 0x04, 0x2d, 0x77, 0xc4, 0x38, 0x27, 0xd3, 0x7c, 0x67, 0xf6, 0x27, 0xf5, 0x95, 0x23, + 0xd3, 0xaa, 0x89, 0xe6, 0x8e, 0xe0, 0x50, 0x12, 0x03, 0xe9, 0x8c, 0x9d, 0xcb, 0x0f, 0x27, 0xf6, 0xdc, 0xf5, 0xfb, + 0x7c, 0xdc, 0xbf, 0x16, 0xc9, 0x01, 0xeb, 0x87, 0xa2, 0xff, 0xc7, 0xb6, 0x79, 0xc4, 0x93, 0xd3, 0x42, 0xe9, 0x5d, + 0x31, 0xe5, 0x34, 0x5d, 0x7c, 0xda, 0x96, 0x0d, 0x9e, 0x98, 0x43, 0x2f, 0xd6, 0x87, 0xd9, 0xdf, 0x39, 0x30, 0xd0, + 0x22, 0x1f, 0x07, 0xd4, 0x14, 0xa4, 0x08, 0xe9, 0x81, 0xd6, 0xd6, 0x40, 0x77, 0x62, 0x20, 0x11, 0xac, 0xe3, 0x88, + 0x0f, 0xb3, 0xb1, 0xfb, 0x30, 0xa7, 0x41, 0x0a, 0x65, 0xc9, 0x48, 0xca, 0x8b, 0x1a, 0xb0, 0x38, 0x51, 0x35, 0x43, + 0x18, 0xb1, 0x66, 0x9a, 0xe3, 0xac, 0xe1, 0x89, 0x73, 0xe6, 0x24, 0x53, 0xa7, 0x2e, 0x3b, 0x30, 0x09, 0x60, 0x91, + 0xdf, 0x3e, 0x97, 0xc1, 0xee, 0x70, 0x50, 0x6c, 0x6c, 0x93, 0x15, 0xc9, 0xeb, 0x58, 0x72, 0xc8, 0x6c, 0xf9, 0xe9, + 0xc4, 0xa4, 0xfc, 0x92, 0x28, 0xab, 0xfb, 0xa2, 0x44, 0xc6, 0x16, 0x98, 0xd1, 0x7b, 0x36, 0x6e, 0x5d, 0x7b, 0x2d, + 0xb1, 0xd8, 0xaf, 0xec, 0xb1, 0xe4, 0xfb, 0xf1, 0x8e, 0x6a, 0x5b, 0xdc, 0x59, 0x75, 0x4d, 0x34, 0xd3, 0x80, 0x98, + 0x4f, 0x0d, 0xff, 0x44, 0xb5, 0xa6, 0xf4, 0x57, 0x3b, 0x72, 0x01, 0x99, 0x58, 0x63, 0xed, 0xf8, 0xa4, 0xb4, 0xe9, + 0x2a, 0xbf, 0xaf, 0xa8, 0x82, 0xc5, 0x72, 0xc4, 0xa1, 0x87, 0x47, 0x32, 0x9d, 0xd3, 0x1a, 0x6c, 0xcf, 0x67, 0xed, + 0x33, 0x06, 0xa3, 0xb0, 0x4c, 0xbd, 0xb5, 0xea, 0x9a, 0x4a, 0x11, 0x61, 0x2d, 0x7d, 0x48, 0xa7, 0xb2, 0xcc, 0x14, + 0x36, 0x41, 0xe2, 0x5c, 0xf2, 0x09, 0x7c, 0x14, 0x22, 0x65, 0x0b, 0x25, 0x0f, 0xff, 0x44, 0x9b, 0x6c, 0x15, 0x18, + 0x66, 0x67, 0x95, 0x27, 0xa5, 0x60, 0x72, 0x96, 0xa4, 0x7f, 0xcc, 0xa9, 0x14, 0xbe, 0xd8, 0xb6, 0x39, 0x13, 0xb6, + 0x45, 0x1b, 0xce, 0x36, 0xcf, 0x73, 0x91, 0x05, 0x11, 0x9d, 0x93, 0xca, 0x35, 0xc0, 0xb1, 0x95, 0xf0, 0x3e, 0x00, + 0x8b, 0xa0, 0x0b, 0x1f, 0x4a, 0xc5, 0x82, 0x22, 0xc3, 0x77, 0x42, 0xe0, 0x7b, 0x65, 0xcb, 0x1d, 0x2e, 0xed, 0x36, + 0xb5, 0x45, 0xb0, 0xba, 0x4c, 0xba, 0x9e, 0xa4, 0xb8, 0xc8, 0xd9, 0xac, 0x9f, 0xdb, 0xd3, 0xd4, 0x7f, 0xeb, 0x70, + 0x09, 0x37, 0x6e, 0x72, 0x41, 0xfc, 0x54, 0x60, 0x06, 0xd5, 0x17, 0x01, 0xd6, 0x84, 0xa7, 0x8a, 0x31, 0x93, 0x3b, + 0xf8, 0x08, 0x21, 0xbb, 0xe8, 0xca, 0x42, 0xba, 0x4c, 0x13, 0x80, 0x1f, 0xbb, 0xfe, 0x18, 0x91, 0xf4, 0x02, 0x02, + 0x53, 0xa9, 0x01, 0x51, 0x79, 0xd8, 0xf3, 0x19, 0x0d, 0xe5, 0x56, 0x3f, 0x78, 0x30, 0x45, 0x8a, 0x5c, 0x3d, 0x64, + 0x78, 0x4c, 0xaa, 0x75, 0xa5, 0xa2, 0x3e, 0x12, 0xcc, 0xd2, 0x2f, 0x4d, 0x51, 0x98, 0xed, 0x1d, 0xd5, 0xed, 0xa2, + 0xf7, 0x97, 0xd8, 0x0d, 0x29, 0xdd, 0x1d, 0xb3, 0x6c, 0x1f, 0x94, 0x65, 0xa8, 0xc6, 0x80, 0xa3, 0xab, 0x80, 0xa8, + 0x62, 0x9d, 0x8b, 0xae, 0x35, 0xf3, 0x5e, 0x55, 0xfc, 0x87, 0x16, 0x2d, 0xba, 0x19, 0xe1, 0x6a, 0x58, 0x59, 0x0f, + 0xd0, 0xea, 0xea, 0x9c, 0x35, 0xfc, 0x93, 0x0a, 0xd1, 0xc4, 0xd5, 0xb4, 0xda, 0x46, 0x14, 0x56, 0x57, 0x2d, 0xd6, + 0x20, 0x49, 0xce, 0x83, 0x85, 0xc8, 0x2a, 0x2a, 0x8e, 0xfd, 0x04, 0x8a, 0x8f, 0x12, 0x99, 0x80, 0xa1, 0x75, 0x4d, + 0x10, 0xa2, 0x5e, 0x98, 0x28, 0x0a, 0xa4, 0x06, 0x05, 0x36, 0xf5, 0xfe, 0x28, 0x8c, 0xff, 0x46, 0x02, 0x28, 0x1a, + 0x3a, 0x62, 0x78, 0x4f, 0xfe, 0xba, 0x98, 0x7c, 0xe2, 0x3f, 0xfa, 0x8e, 0x97, 0x41, 0x9b, 0x8a, 0x6b, 0xaf, 0xaf, + 0x0b, 0x72, 0x8b, 0xd4, 0x95, 0x4e, 0x80, 0x49, 0x3f, 0x5b, 0x28, 0x8e, 0x28, 0x7f, 0xe5, 0x62, 0x9b, 0x5c, 0x30, + 0x1c, 0x58, 0xa5, 0xc3, 0x2e, 0xd8, 0x18, 0x12, 0xa0, 0x78, 0x7f, 0x35, 0x49, 0xc3, 0xc1, 0x93, 0xdc, 0x94, 0x5c, + 0x9d, 0x9c, 0xc7, 0xf0, 0x2d, 0x8d, 0xcc, 0xb0, 0x63, 0x68, 0x38, 0x27, 0x76, 0x55, 0xd8, 0xad, 0x99, 0x63, 0x8f, + 0x04, 0xc5, 0xa1, 0xfb, 0x2e, 0x6d, 0xb4, 0x5f, 0x23, 0x95, 0xfd, 0xf5, 0x12, 0xd9, 0xdd, 0x1d, 0x8e, 0xd9, 0xd6, + 0x2c, 0xb5, 0x18, 0x9e, 0xb6, 0xf2, 0xa5, 0x9f, 0x9c, 0x59, 0x5e, 0xac, 0x4e, 0x8a, 0xb7, 0x0d, 0x84, 0xd1, 0x0e, + 0x52, 0x57, 0xb4, 0x64, 0x9b, 0x11, 0x25, 0x26, 0xf2, 0xdf, 0x64, 0x7e, 0x1c, 0x31, 0xc4, 0x8e, 0x87, 0x39, 0xef, + 0x1b, 0x80, 0x5f, 0x22, 0xbf, 0xe1, 0x5e, 0x8f, 0x4c, 0x79, 0x78, 0x92, 0xa0, 0xff, 0x18, 0xc0, 0x70, 0x71, 0xbd, + 0x24, 0xee, 0x57, 0xd3, 0x44, 0x3c, 0x61, 0x94, 0x7c, 0x71, 0x4b, 0xdf, 0xd8, 0xfb, 0x14, 0x75, 0x29, 0xc3, 0xe1, + 0xb3, 0xc1, 0xf7, 0xa9, 0x69, 0x11, 0x40, 0x6e, 0x07, 0xd6, 0xab, 0x2d, 0x18, 0xf6, 0xbc, 0x1b, 0xe1, 0x9c, 0x3d, + 0xeb, 0xbc, 0x1b, 0x77, 0xdc, 0x7b, 0xe1, 0xda, 0xda, 0x99, 0x84, 0x9e, 0x82, 0xd2, 0xd9, 0xba, 0xf1, 0xd9, 0x33, + 0x9e, 0xf4, 0x5a, 0x92, 0x1c, 0xf4, 0x6b, 0xc6, 0xb8, 0x0d, 0xc7, 0x73, 0x30, 0x9d, 0x85, 0x5d, 0xc1, 0x76, 0x27, + 0x3c, 0xd9, 0x51, 0x88, 0x28, 0x8e, 0x86, 0xdd, 0x55, 0x70, 0xce, 0x30, 0x27, 0x5f, 0x33, 0x17, 0x7c, 0x11, 0x6c, + 0xcc, 0xce, 0xe3, 0xc2, 0x23, 0x99, 0xdf, 0x4f, 0x72, 0x6a, 0x76, 0x44, 0xe7, 0xcb, 0xea, 0x45, 0x4e, 0x56, 0xfc, + 0x95, 0x56, 0xce, 0x60, 0xa5, 0x78, 0x62, 0xe3, 0x0c, 0xab, 0x9d, 0x58, 0x78, 0x6a, 0x1a, 0x9e, 0xf5, 0x45, 0xbc, + 0x06, 0x9f, 0xb2, 0x8e, 0xca, 0xd9, 0x3f, 0x70, 0xa9, 0x9f, 0x1a, 0xf4, 0x45, 0x10, 0xe0, 0x39, 0x33, 0xca, 0x3a, + 0xdc, 0x9c, 0x26, 0x45, 0xa8, 0x9b, 0x33, 0xf4, 0xc9, 0x2e, 0x8a, 0x52, 0xee, 0xac, 0x12, 0x3d, 0x88, 0x4b, 0xe7, + 0xa6, 0x77, 0x86, 0x25, 0x5a, 0xfc, 0x27, 0x7a, 0x12, 0x51, 0x35, 0x6d, 0x69, 0xe4, 0xf8, 0x06, 0x6c, 0xb8, 0xb1, + 0x0d, 0xc3, 0xb8, 0xe1, 0x0f, 0x6f, 0xf2, 0x77, 0x09, 0xd6, 0xc1, 0x3f, 0x5b, 0xd7, 0xc7, 0x6f, 0xc7, 0x2a, 0x78, + 0xce, 0x8b, 0x55, 0x78, 0x4e, 0xf9, 0xc4, 0x98, 0xe9, 0xe3, 0x62, 0x7d, 0xdb, 0xde, 0xff, 0xe7, 0xf7, 0xe4, 0xf7, + 0x46, 0x8b, 0x46, 0x7e, 0x89, 0x5d, 0x5f, 0x28, 0xed, 0x34, 0xff, 0xfb, 0x7a, 0x76, 0xfb, 0x23, 0xcf, 0x41, 0x6f, + 0x0f, 0xec, 0x9c, 0x53, 0x63, 0x9a, 0xac, 0xd2, 0xc2, 0xad, 0xfe, 0x8c, 0x7f, 0x19, 0x20, 0xef, 0x80, 0x66, 0x99, + 0xc7, 0xca, 0x53, 0xd4, 0x17, 0xd4, 0xde, 0xc7, 0x57, 0x3e, 0xf9, 0xb2, 0x29, 0xe9, 0x66, 0x84, 0x61, 0x57, 0xfd, + 0x8c, 0xef, 0xd6, 0x28, 0x17, 0x6c, 0x3b, 0xbb, 0x7e, 0x7c, 0xdb, 0x83, 0x73, 0x81, 0xf7, 0xf7, 0xe0, 0xa3, 0xac, + 0xce, 0xca, 0xcd, 0xa2, 0xa7, 0xd3, 0x97, 0xb0, 0x80, 0x96, 0x39, 0x34, 0x0c, 0x87, 0x77, 0xc0, 0x83, 0x73, 0xfa, + 0xe5, 0xe2, 0xc0, 0x3a, 0xae, 0xcc, 0x2a, 0x77, 0xcb, 0x9f, 0xbe, 0x40, 0xd6, 0xc7, 0x60, 0xb2, 0x5d, 0xc4, 0x53, + 0x67, 0x76, 0x30, 0x75, 0x2a, 0xff, 0x75, 0xc1, 0x7c, 0xd1, 0xf1, 0x8a, 0xb5, 0xd2, 0xd9, 0xe0, 0x49, 0x08, 0x41, + 0xf0, 0xd9, 0x30, 0xdc, 0xcd, 0x8f, 0xe7, 0x40, 0x37, 0x1b, 0x73, 0x02, 0x7f, 0x84, 0x77, 0x75, 0xcf, 0x1f, 0x5c, + 0xdb, 0x6b, 0x31, 0x40, 0x03, 0x23, 0x86, 0xb6, 0x53, 0xe0, 0x46, 0xa2, 0xa4, 0x7a, 0xbf, 0xeb, 0x59, 0x0f, 0x17, + 0x60, 0xe6, 0x41, 0x75, 0xa7, 0xd7, 0x6c, 0x76, 0xe5, 0xfd, 0xb1, 0xcd, 0x4b, 0xa6, 0x00, 0x58, 0xce, 0x04, 0xd6, + 0xf5, 0xf8, 0x14, 0x37, 0xea, 0x2f, 0xc8, 0xb4, 0xa1, 0xec, 0x5c, 0x0b, 0x5e, 0x55, 0x46, 0xaa, 0x43, 0x55, 0x69, + 0x96, 0xe7, 0x66, 0xe2, 0x77, 0x86, 0x71, 0x7b, 0x14, 0x50, 0x37, 0x5d, 0xd6, 0xb5, 0xa1, 0x00, 0x7a, 0xb4, 0x9c, + 0xca, 0x13, 0x4e, 0x0d, 0x4c, 0x44, 0x01, 0x28, 0x26, 0xa5, 0xf8, 0x11, 0x3f, 0x1b, 0x2f, 0xf9, 0x01, 0x04, 0x38, + 0x5a, 0xe6, 0x63, 0xef, 0x48, 0x50, 0xaa, 0xbf, 0xee, 0x81, 0xfc, 0xeb, 0x30, 0x15, 0xac, 0xf2, 0x1b, 0x8c, 0x52, + 0x5e, 0x42, 0xf0, 0x0e, 0x56, 0xee, 0xeb, 0xa1, 0x11, 0x72, 0xa9, 0x64, 0x30, 0xf0, 0xa2, 0xd6, 0x6e, 0x0b, 0x82, + 0x49, 0x5f, 0x9b, 0xd5, 0x9f, 0x28, 0xd1, 0xd6, 0x1f, 0x70, 0xf1, 0xb9, 0x80, 0x68, 0xff, 0x08, 0xab, 0xaf, 0xd8, + 0xb0, 0x60, 0xa3, 0xa3, 0xd3, 0x8b, 0x06, 0xd8, 0x38, 0x59, 0x1e, 0x30, 0xbd, 0x47, 0x95, 0xd2, 0xc6, 0x1e, 0xb0, + 0xcf, 0x9f, 0x96, 0x7b, 0x16, 0x32, 0x86, 0xef, 0x6e, 0xa7, 0x11, 0x58, 0x99, 0xe8, 0x8e, 0xd7, 0xc5, 0x93, 0xbc, + 0xfe, 0xa5, 0xa3, 0x91, 0x10, 0x5f, 0x6d, 0xb1, 0xb2, 0x49, 0x11, 0x02, 0x72, 0x63, 0xc4, 0x0e, 0xea, 0x9c, 0x5c, + 0x55, 0xde, 0x0f, 0x16, 0x2b, 0x77, 0x99, 0xc9, 0x26, 0xf6, 0xd3, 0x57, 0x19, 0x3d, 0x83, 0xc8, 0xef, 0xdc, 0xa0, + 0x12, 0xf0, 0x1f, 0x48, 0x11, 0xd7, 0x24, 0x3d, 0x58, 0xa5, 0x52, 0xec, 0x41, 0x8a, 0xcc, 0x44, 0x90, 0xed, 0xa4, + 0xd6, 0x09, 0x80, 0xca, 0xb3, 0x13, 0xf4, 0x43, 0x9a, 0x66, 0xb5, 0x91, 0x2e, 0xf6, 0x3a, 0x9f, 0x65, 0x04, 0x47, + 0x0d, 0x7f, 0xe0, 0x7c, 0x14, 0x36, 0x39, 0xf0, 0x4d, 0xcc, 0x0a, 0x05, 0x6d, 0x74, 0x0a, 0xd3, 0x26, 0x09, 0x44, + 0x11, 0xb4, 0xf1, 0x8c, 0xdc, 0x3e, 0x04, 0x66, 0x62, 0x0f, 0x4e, 0x4b, 0x87, 0xb4, 0x07, 0xb5, 0x4f, 0xd3, 0xfd, + 0xeb, 0x96, 0x6e, 0x07, 0x3d, 0x73, 0x5e, 0xea, 0xaa, 0x6d, 0xfa, 0x95, 0xf2, 0xd6, 0x44, 0xad, 0xc8, 0x62, 0xb3, + 0x27, 0x1b, 0x0b, 0xec, 0x57, 0xa9, 0x5d, 0xb7, 0xfa, 0x5c, 0x4d, 0xce, 0x43, 0x11, 0x9c, 0xaa, 0xd9, 0x3f, 0x29, + 0x2c, 0x9a, 0x06, 0x55, 0x32, 0x88, 0x20, 0x75, 0xcc, 0x8c, 0xdc, 0x8f, 0xc4, 0x7c, 0x74, 0x6a, 0x8e, 0x4c, 0xbb, + 0xd0, 0x4a, 0xe9, 0x0d, 0x07, 0xa4, 0x30, 0x7c, 0x1d, 0x45, 0x83, 0xc2, 0x7b, 0xe1, 0x56, 0xf3, 0xab, 0x9e, 0xf2, + 0x1e, 0xc4, 0xf0, 0x93, 0x74, 0x23, 0x21, 0x92, 0xf3, 0xce, 0xcf, 0x65, 0x27, 0x5b, 0xb0, 0x26, 0xf7, 0xb6, 0xcc, + 0xda, 0x28, 0xfb, 0x09, 0xd3, 0x24, 0xab, 0xf3, 0xa6, 0xc1, 0xa8, 0x69, 0xab, 0x24, 0xbd, 0x26, 0xe9, 0xf5, 0xf5, + 0x20, 0xbc, 0x26, 0x5e, 0xbc, 0xff, 0xc8, 0x1c, 0xe0, 0x50, 0x18, 0x58, 0x59, 0x72, 0xf8, 0x06, 0x03, 0xbd, 0xc9, + 0x4d, 0xda, 0x20, 0x8c, 0x4e, 0x81, 0x2a, 0x50, 0xb5, 0xfe, 0xde, 0x8b, 0xc2, 0x88, 0xc2, 0xc9, 0x13, 0xfb, 0x54, + 0x21, 0xcf, 0x1f, 0x87, 0x79, 0xc3, 0xbe, 0xf2, 0xc2, 0xb5, 0x6f, 0xd9, 0x2b, 0x63, 0xea, 0x3c, 0x56, 0x7d, 0xcc, + 0x37, 0x35, 0xb4, 0xc0, 0xf5, 0x93, 0x5b, 0x04, 0x6b, 0x12, 0x45, 0xec, 0x5d, 0x9d, 0xbc, 0xa2, 0x14, 0x31, 0x93, + 0xed, 0xff, 0x8f, 0x7d, 0xe6, 0x08, 0x2e, 0xbb, 0x3f, 0x52, 0x6e, 0xb0, 0x4f, 0xb9, 0x59, 0xab, 0x31, 0x09, 0x58, + 0x34, 0x68, 0xd3, 0xc7, 0xe1, 0x3b, 0x10, 0x7f, 0xc7, 0x43, 0xe2, 0x9c, 0x41, 0xae, 0x75, 0xf9, 0x58, 0x1a, 0x61, + 0xc7, 0x25, 0x1d, 0x69, 0x87, 0x95, 0xfc, 0x68, 0x97, 0xa7, 0xce, 0xca, 0x2d, 0x62, 0xc5, 0xd7, 0x8f, 0x92, 0x12, + 0xf0, 0xb2, 0xc1, 0x42, 0x30, 0x67, 0xa3, 0xad, 0x07, 0x66, 0x2f, 0xd3, 0x30, 0x3b, 0x66, 0x0f, 0xd8, 0x11, 0x4f, + 0xdb, 0x6d, 0x16, 0x49, 0x2f, 0xee, 0xa2, 0xed, 0xe9, 0xa5, 0xef, 0x1c, 0x2c, 0xc2, 0xef, 0xa7, 0x5f, 0x4d, 0x2e, + 0x36, 0x50, 0x61, 0x7b, 0x5a, 0x61, 0xe4, 0xe1, 0x5f, 0xcc, 0x06, 0xe8, 0x4a, 0x75, 0x4e, 0xce, 0xbf, 0xdf, 0xa8, + 0x6a, 0xf2, 0x04, 0xde, 0x72, 0xf6, 0x86, 0x47, 0x5d, 0x8d, 0xe6, 0xc4, 0x5e, 0xca, 0x8c, 0x55, 0x73, 0x9e, 0x35, + 0x70, 0x1a, 0xf9, 0x74, 0x81, 0x7d, 0x67, 0x3a, 0x5d, 0xbe, 0x29, 0x59, 0xde, 0x0d, 0x72, 0x56, 0xbf, 0x52, 0x82, + 0x7d, 0x74, 0x17, 0xcf, 0x9e, 0x75, 0xed, 0x7d, 0xef, 0xbd, 0x7d, 0x7c, 0xff, 0x5d, 0x98, 0x2d, 0x24, 0x86, 0x95, + 0xd9, 0x20, 0x7e, 0xff, 0x85, 0xe1, 0x4d, 0x68, 0x4e, 0xfd, 0x93, 0x27, 0x22, 0x24, 0x0a, 0x2d, 0x32, 0xb6, 0xcd, + 0xb4, 0x1d, 0x50, 0xc5, 0x9d, 0x17, 0x63, 0x36, 0x74, 0x40, 0x60, 0xa2, 0x28, 0xc9, 0x8a, 0x54, 0xf5, 0xe0, 0xf1, + 0x9d, 0xba, 0x7f, 0x52, 0x64, 0x6c, 0x3d, 0xe8, 0x2c, 0x57, 0x2b, 0xfc, 0x0d, 0x3c, 0x68, 0x61, 0x74, 0x36, 0x0a, + 0x01, 0xd9, 0x29, 0x65, 0x53, 0x91, 0x36, 0x68, 0x62, 0x9c, 0x2c, 0x2d, 0xfd, 0x58, 0xf9, 0x5c, 0xf4, 0x62, 0x06, + 0x3f, 0xa9, 0xba, 0x8d, 0x19, 0x2b, 0xc9, 0x2c, 0xfd, 0x07, 0xfd, 0x1f, 0xef, 0x9a, 0xcb, 0xb2, 0x72, 0x88, 0x1a, + 0x6e, 0x10, 0x87, 0xc2, 0x40, 0xfd, 0x6b, 0x25, 0xdc, 0xbb, 0x39, 0x14, 0x5c, 0x2c, 0xfc, 0xba, 0xfd, 0x42, 0xe4, + 0x8a, 0x5e, 0xc1, 0x9f, 0x25, 0xbe, 0xb3, 0xfe, 0xad, 0x5d, 0x2d, 0x7e, 0x41, 0xd6, 0x15, 0x7b, 0xce, 0x45, 0xaf, + 0x9c, 0xc9, 0x7e, 0x86, 0xa9, 0xaa, 0xf4, 0x6c, 0xe4, 0x87, 0xae, 0x18, 0x45, 0x55, 0x58, 0xe4, 0x02, 0xbe, 0x4f, + 0x60, 0x90, 0xe1, 0x6a, 0x38, 0x7c, 0x34, 0x6a, 0x34, 0x85, 0x91, 0x52, 0x97, 0x54, 0x96, 0xc3, 0x22, 0x6c, 0x5d, + 0x8b, 0xe1, 0xae, 0xe0, 0x62, 0x19, 0xac, 0x60, 0x9d, 0xd7, 0xf5, 0x7c, 0xf7, 0xd3, 0x53, 0x29, 0x73, 0xaf, 0x44, + 0x3d, 0x27, 0xa1, 0xb3, 0x21, 0x30, 0x71, 0x44, 0xc7, 0xfb, 0xdb, 0xec, 0x1e, 0xdc, 0x1c, 0x90, 0x19, 0x2b, 0xed, + 0xcf, 0x41, 0xce, 0x65, 0xac, 0x6c, 0xfc, 0xd2, 0x5c, 0x19, 0x0c, 0x6d, 0x19, 0xf6, 0x1d, 0x17, 0x62, 0x5a, 0x5a, + 0x7e, 0x77, 0x22, 0x37, 0xdd, 0xe2, 0x9a, 0x98, 0x00, 0x2c, 0x40, 0xe7, 0x5c, 0xa3, 0xed, 0x38, 0x5f, 0x80, 0xb6, + 0x2e, 0x9b, 0xf3, 0x77, 0xd2, 0xad, 0xc1, 0x92, 0xf5, 0xa0, 0x01, 0xeb, 0x30, 0xf4, 0x95, 0x6d, 0x8c, 0xad, 0x72, + 0x16, 0xea, 0xc4, 0x3d, 0xd5, 0x98, 0x18, 0x6f, 0x20, 0xc5, 0xc0, 0x3b, 0x73, 0x0f, 0x27, 0x13, 0x2d, 0x2c, 0xff, + 0x52, 0x3d, 0xd0, 0x0e, 0xd1, 0x20, 0x09, 0x76, 0x5c, 0xdd, 0x62, 0x6c, 0x47, 0xfd, 0xb1, 0x5f, 0xcd, 0xc5, 0x26, + 0x29, 0xcd, 0x56, 0x13, 0xf9, 0x2b, 0x94, 0x3e, 0x30, 0x40, 0x0d, 0x9f, 0x78, 0xe1, 0x15, 0xf6, 0xf5, 0xd2, 0x53, + 0x6a, 0x8f, 0x6f, 0xe0, 0x13, 0xb5, 0x92, 0x74, 0x8d, 0x14, 0x88, 0xf0, 0x2d, 0x62, 0x14, 0x50, 0x6e, 0x41, 0x57, + 0x8e, 0xf2, 0x60, 0x4c, 0x71, 0xcd, 0xb4, 0x75, 0x6b, 0xaf, 0x8a, 0xf3, 0x32, 0x85, 0x00, 0x3d, 0x85, 0x98, 0x2d, + 0x95, 0xa2, 0x3c, 0xf2, 0xc2, 0x37, 0x99, 0x4b, 0xd4, 0x1e, 0xeb, 0x5c, 0x3b, 0x13, 0xb5, 0x27, 0x0d, 0x7a, 0x49, + 0xee, 0x42, 0x29, 0x86, 0x0d, 0xe5, 0x2b, 0x49, 0x99, 0x2d, 0x8d, 0x69, 0x11, 0x2b, 0xbb, 0x30, 0x8c, 0x42, 0xbb, + 0x88, 0x64, 0xb4, 0xd8, 0xaf, 0xbf, 0xb2, 0xf7, 0xc7, 0xae, 0x3f, 0xe0, 0x6b, 0x0b, 0x81, 0xf0, 0xbf, 0xd4, 0xcd, + 0x1a, 0x43, 0x7f, 0xdb, 0xd8, 0x3c, 0x8e, 0xd2, 0x1e, 0x36, 0x26, 0x1a, 0x1d, 0xc1, 0x82, 0x7f, 0x0a, 0x18, 0xbe, + 0xfd, 0xad, 0x44, 0x94, 0x9f, 0x96, 0x28, 0x35, 0x62, 0xbc, 0x4c, 0xc8, 0xc4, 0x55, 0x9f, 0x8b, 0xa1, 0x7a, 0xde, + 0xeb, 0x4d, 0x01, 0xb9, 0xf6, 0x05, 0x6b, 0x9e, 0x5b, 0xb9, 0x18, 0x23, 0x63, 0x41, 0xd1, 0x23, 0x67, 0x5f, 0x3c, + 0x6e, 0x7b, 0x06, 0x4b, 0x3a, 0x5d, 0x2a, 0x9c, 0xe8, 0x0c, 0x5c, 0x13, 0x5f, 0x4c, 0xf0, 0x2d, 0x94, 0x9b, 0x5d, + 0xec, 0x4b, 0xa4, 0x9e, 0x22, 0x77, 0xa1, 0x51, 0x09, 0x5b, 0x28, 0x73, 0x28, 0x2d, 0x16, 0xfc, 0xf3, 0x2c, 0xc1, + 0xe7, 0x14, 0x9b, 0x4a, 0x41, 0x5e, 0x92, 0x09, 0xec, 0x95, 0x4d, 0xb9, 0xb3, 0xaf, 0x57, 0x7d, 0x79, 0xca, 0x5a, + 0x4b, 0x74, 0x4d, 0x98, 0x4c, 0x7e, 0x7c, 0xdc, 0xe7, 0x1e, 0xcf, 0x48, 0xfc, 0xec, 0x75, 0x6f, 0x43, 0x92, 0x7b, + 0xc8, 0xed, 0x28, 0xb5, 0xaf, 0x5b, 0xce, 0xe4, 0x0f, 0xc8, 0x4b, 0xef, 0xd7, 0xc3, 0xad, 0xcd, 0x97, 0xac, 0xa1, + 0x44, 0xa9, 0xfe, 0x38, 0x7b, 0x7d, 0x15, 0xa5, 0x94, 0xe2, 0xfa, 0xaf, 0x44, 0xf1, 0xac, 0x2b, 0x35, 0x7e, 0xf0, + 0x7e, 0x50, 0x64, 0x51, 0x91, 0xd4, 0x01, 0xee, 0xc2, 0x1a, 0x30, 0x07, 0x27, 0x06, 0xeb, 0x9e, 0xee, 0x03, 0x6d, + 0x7f, 0x6b, 0x6c, 0xa4, 0x32, 0x22, 0x70, 0x76, 0xa0, 0x43, 0x8f, 0xa3, 0x2e, 0x7c, 0xbc, 0x6e, 0x3f, 0x27, 0xa0, + 0x02, 0xb0, 0x39, 0xbb, 0x4d, 0xae, 0x8d, 0x0b, 0x6e, 0x5b, 0x41, 0xac, 0x46, 0xed, 0x72, 0xce, 0x11, 0x66, 0xa4, + 0x03, 0xa7, 0xba, 0xc0, 0xfa, 0x8b, 0x08, 0xac, 0xec, 0x98, 0x2a, 0x75, 0x8b, 0x87, 0x41, 0x70, 0x10, 0x5c, 0xc1, + 0x94, 0x3d, 0x41, 0x4b, 0x05, 0x97, 0x7f, 0x76, 0x4f, 0xf7, 0x0e, 0x13, 0x86, 0xae, 0xce, 0x28, 0x1e, 0xde, 0x3a, + 0x7d, 0x5e, 0xf9, 0xf5, 0x4b, 0xf8, 0x8f, 0x1c, 0x28, 0xc9, 0x33, 0xcf, 0x49, 0x52, 0xc0, 0x05, 0x79, 0xf5, 0x5f, + 0x23, 0x8f, 0x1e, 0x76, 0xa1, 0xaf, 0xb8, 0x05, 0xc9, 0x1d, 0x2a, 0x6f, 0x43, 0x7a, 0xb3, 0xc2, 0x23, 0xaa, 0x5a, + 0x50, 0x21, 0x31, 0x84, 0x05, 0xd5, 0xc9, 0x31, 0xb2, 0xc1, 0xcd, 0x4c, 0xcd, 0xb8, 0x33, 0x40, 0x92, 0x7d, 0xc4, + 0x73, 0x69, 0x49, 0x82, 0xde, 0xaa, 0x2b, 0x43, 0xcd, 0x97, 0xa8, 0x77, 0x9c, 0xc7, 0x86, 0x72, 0xfa, 0x9d, 0x4d, + 0x0d, 0xde, 0x9c, 0xc6, 0xa7, 0x31, 0xb5, 0xe4, 0x56, 0xfa, 0xa2, 0x10, 0xa7, 0xaf, 0xde, 0x29, 0xb1, 0x46, 0xda, + 0xc3, 0x70, 0x50, 0x83, 0x15, 0x1a, 0x20, 0x65, 0x9a, 0xc1, 0x0b, 0x6d, 0x45, 0x01, 0x7d, 0x45, 0xec, 0xfe, 0x60, + 0xd9, 0x25, 0x69, 0x14, 0x64, 0x45, 0x0f, 0x13, 0x1f, 0xa5, 0x40, 0xeb, 0x74, 0x76, 0x99, 0xe2, 0xce, 0x12, 0x01, + 0x23, 0x50, 0x52, 0x42, 0x04, 0x44, 0xce, 0x85, 0x92, 0x54, 0xf5, 0x95, 0x77, 0x7b, 0x68, 0xc1, 0x22, 0xc6, 0x15, + 0xc8, 0x0c, 0xd6, 0x88, 0xe7, 0x34, 0x21, 0x4a, 0xd5, 0xe8, 0x05, 0xbd, 0x69, 0x5c, 0x18, 0x48, 0xa7, 0x97, 0x5e, + 0x58, 0x53, 0xcb, 0xe4, 0x40, 0xf5, 0x22, 0x97, 0x3e, 0xb5, 0xbd, 0x0a, 0x24, 0xea, 0xe3, 0xe8, 0x34, 0x89, 0x79, + 0x22, 0x5e, 0xc6, 0x99, 0xca, 0xb2, 0x31, 0x5c, 0xb7, 0xbd, 0xa4, 0xa6, 0xc1, 0xdd, 0x0d, 0x24, 0xaa, 0x41, 0x4d, + 0xcf, 0xba, 0x6d, 0xc3, 0xf3, 0xab, 0xc3, 0xc5, 0xd5, 0x2a, 0x2e, 0x4a, 0xbf, 0x4e, 0x04, 0x96, 0x8b, 0xda, 0xda, + 0xd9, 0x02, 0xbe, 0x35, 0x9f, 0xd4, 0x48, 0xc3, 0x66, 0x55, 0xd4, 0x37, 0x10, 0x62, 0x8d, 0x0d, 0xfe, 0x23, 0x45, + 0x92, 0xe9, 0x3f, 0x94, 0x35, 0x5e, 0x7b, 0x08, 0x8e, 0xd5, 0x18, 0x1f, 0x83, 0xed, 0x0c, 0x92, 0x93, 0x9b, 0x1b, + 0x75, 0x21, 0xf8, 0x86, 0x48, 0x23, 0x9e, 0xb0, 0x76, 0x25, 0x45, 0xfb, 0x39, 0x74, 0x01, 0xa4, 0xf0, 0x83, 0xf7, + 0x1c, 0x1b, 0x7c, 0x32, 0xd6, 0x27, 0x43, 0x21, 0x59, 0xa7, 0x41, 0x28, 0x90, 0xbb, 0xba, 0xa6, 0x5f, 0x3f, 0xe0, + 0x4d, 0x29, 0xe9, 0x93, 0xf5, 0x00, 0x2e, 0xa5, 0xc2, 0x0f, 0xa9, 0x76, 0x38, 0xeb, 0x8e, 0x19, 0xda, 0xeb, 0xb7, + 0xaf, 0xcb, 0x29, 0xd3, 0x7f, 0xaa, 0xd4, 0xcd, 0x97, 0xf3, 0x78, 0x62, 0x05, 0xe2, 0x37, 0xcd, 0xc8, 0x74, 0xed, + 0x18, 0x2f, 0xd2, 0x20, 0x9b, 0x5e, 0xd7, 0x26, 0x5b, 0xc9, 0x42, 0xd8, 0xd2, 0xd4, 0xa0, 0x7d, 0x9d, 0x93, 0x3e, + 0x64, 0x24, 0xa4, 0x67, 0x22, 0x1c, 0xae, 0x88, 0x17, 0x89, 0x80, 0xda, 0x22, 0xde, 0x5b, 0xc8, 0x56, 0xf4, 0x98, + 0x02, 0xae, 0x61, 0x54, 0xd6, 0x86, 0x29, 0xd8, 0xf0, 0x7c, 0xa3, 0x22, 0x68, 0xb3, 0x23, 0x6f, 0xc1, 0xa3, 0x35, + 0xcb, 0x29, 0xce, 0xfd, 0x2f, 0x7a, 0xaf, 0xe4, 0x53, 0xc9, 0xf3, 0x37, 0xb8, 0xc0, 0xc4, 0xd1, 0x19, 0xff, 0x1c, + 0x90, 0xad, 0x9d, 0x89, 0xa4, 0x4e, 0xa6, 0x83, 0xb5, 0x9e, 0x2e, 0xa7, 0x5c, 0xc0, 0x43, 0x9a, 0x7f, 0x02, 0x5f, + 0x99, 0x87, 0x8a, 0x98, 0x40, 0xa3, 0xba, 0x62, 0x4a, 0x37, 0xdf, 0x77, 0xac, 0x53, 0x15, 0xf1, 0x36, 0x81, 0x54, + 0x69, 0x3c, 0x6f, 0x7a, 0xc0, 0x70, 0x37, 0xce, 0x8a, 0xd3, 0x6c, 0x86, 0x08, 0xfe, 0x0f, 0xa2, 0x91, 0x39, 0x6f, + 0x8a, 0x15, 0x81, 0xb1, 0x5b, 0x53, 0xae, 0x26, 0xf1, 0x75, 0x6b, 0x69, 0x62, 0x9e, 0x54, 0xde, 0xf7, 0xe7, 0x3f, + 0xd6, 0x1d, 0xd5, 0xf3, 0x00, 0xb1, 0x19, 0xc5, 0x6c, 0x6f, 0x3c, 0x72, 0xa1, 0xcf, 0x42, 0xf8, 0x3d, 0xaa, 0xf1, + 0xf0, 0x96, 0x21, 0x20, 0x79, 0x9c, 0xcd, 0xb3, 0x0f, 0x9c, 0xdd, 0xb7, 0xdf, 0x0e, 0x47, 0x6a, 0x7d, 0x23, 0x8f, + 0xa6, 0x79, 0x0a, 0xa0, 0xcc, 0xf0, 0x4f, 0x20, 0x8d, 0x64, 0x93, 0x75, 0x4a, 0xd9, 0xa6, 0x00, 0xaf, 0x1b, 0x2f, + 0xbf, 0x80, 0x08, 0x73, 0x9e, 0xe4, 0x0b, 0xfc, 0x45, 0x67, 0x0d, 0xcd, 0x99, 0xd1, 0x6e, 0x96, 0x3b, 0xd2, 0xf0, + 0x67, 0xb9, 0xfd, 0x76, 0x6c, 0x33, 0xe3, 0x69, 0x38, 0xd8, 0xd1, 0xf8, 0x57, 0xf2, 0x37, 0x2d, 0xa3, 0x5a, 0x5e, + 0x96, 0x53, 0xe9, 0xf1, 0x6a, 0xff, 0x44, 0x43, 0xcf, 0x21, 0xa7, 0x09, 0x35, 0xeb, 0x93, 0xea, 0x1f, 0xeb, 0x33, + 0xea, 0xb4, 0xa9, 0x79, 0x79, 0xcc, 0x6d, 0xd8, 0xd5, 0x49, 0x6d, 0xf7, 0x06, 0x1b, 0xf8, 0x4f, 0xcd, 0x1a, 0x46, + 0x77, 0xb5, 0xdd, 0x47, 0x13, 0x85, 0x65, 0x54, 0x94, 0x9d, 0x11, 0x49, 0x45, 0x76, 0x82, 0xc1, 0x09, 0x64, 0x74, + 0x74, 0xf9, 0x69, 0x37, 0xa2, 0x8a, 0x98, 0xf2, 0x30, 0x60, 0x21, 0xef, 0x3f, 0x9e, 0xf6, 0x6f, 0x25, 0xa8, 0x11, + 0x69, 0x26, 0x1a, 0x7e, 0x60, 0x39, 0x51, 0xcd, 0xcf, 0xbe, 0xcc, 0xf1, 0x17, 0xbc, 0x87, 0x47, 0xd6, 0xb2, 0x64, + 0x0a, 0x6c, 0x37, 0xde, 0xb8, 0xa5, 0x78, 0x68, 0x8a, 0x88, 0x60, 0x66, 0x62, 0x50, 0xba, 0x4b, 0x5b, 0x8e, 0x32, + 0xb5, 0x90, 0xcb, 0x34, 0xa3, 0x34, 0xcb, 0xff, 0x91, 0xa3, 0x52, 0x58, 0x9e, 0x47, 0x7b, 0xa4, 0x0c, 0x27, 0xd2, + 0x68, 0xa0, 0x53, 0x03, 0xc2, 0xe6, 0x0d, 0xff, 0xf7, 0xab, 0xed, 0xf7, 0x1a, 0xc7, 0xe3, 0xde, 0x0b, 0xd7, 0x7b, + 0x95, 0xe3, 0x66, 0xaf, 0xcb, 0x51, 0xef, 0xde, 0xf1, 0xb4, 0x77, 0x06, 0x6e, 0xf5, 0xc6, 0x8e, 0x97, 0xbd, 0x47, + 0xee, 0xf7, 0x36, 0xc1, 0xbd, 0x5e, 0xff, 0xcb, 0xa0, 0x77, 0x0e, 0x5e, 0xf4, 0xb6, 0xc1, 0x8d, 0xde, 0xb3, 0xe3, + 0x4e, 0x6f, 0x0b, 0xc1, 0xcc, 0xd9, 0xbd, 0xac, 0xcf, 0xe1, 0x83, 0x3e, 0x1f, 0xe7, 0x37, 0xfc, 0x73, 0xd4, 0x33, + 0xb7, 0x65, 0xf8, 0xe2, 0xb8, 0x09, 0x90, 0x7b, 0x75, 0x77, 0x81, 0xad, 0xbc, 0x7c, 0xf3, 0x56, 0x2f, 0xde, 0x3a, + 0xa1, 0x49, 0xdb, 0xe6, 0x37, 0x5c, 0x2c, 0xdd, 0xe5, 0xa4, 0x88, 0xde, 0x68, 0x6d, 0xa0, 0xc9, 0x75, 0x62, 0x58, + 0x7f, 0xbb, 0x6c, 0x2e, 0x9c, 0x31, 0xe8, 0x0b, 0x00, 0xe7, 0x2c, 0x18, 0x9f, 0x4d, 0xb6, 0xa6, 0xe9, 0xb8, 0x54, + 0x5d, 0xd0, 0x36, 0xae, 0x00, 0x80, 0x1e, 0xeb, 0xad, 0x62, 0xe3, 0x7b, 0xb3, 0x30, 0x34, 0x5d, 0xa3, 0x82, 0x83, + 0xc1, 0x63, 0x97, 0x5d, 0xd9, 0x80, 0x9d, 0xef, 0xca, 0xbd, 0x24, 0x21, 0x68, 0xb9, 0x77, 0x12, 0xc8, 0x0d, 0xa9, + 0x2b, 0x4e, 0x04, 0xd0, 0x78, 0x93, 0xb2, 0x98, 0x73, 0x74, 0x1d, 0x26, 0x50, 0x5e, 0x7a, 0x61, 0x95, 0xcf, 0x91, + 0x98, 0x0d, 0x49, 0xd3, 0x0c, 0xb3, 0x6c, 0x13, 0xd1, 0x6f, 0xcb, 0xca, 0xa4, 0x8c, 0xe4, 0x48, 0x5d, 0x64, 0x27, + 0xb6, 0x3d, 0x11, 0xd9, 0xf8, 0xa3, 0x28, 0xa4, 0x63, 0x1d, 0x80, 0x9a, 0x93, 0x92, 0xf9, 0x7d, 0xe8, 0x3a, 0x92, + 0x86, 0x54, 0xba, 0xb0, 0x35, 0x19, 0x86, 0xf7, 0x51, 0xd4, 0x8e, 0xbd, 0x32, 0x91, 0xd9, 0x52, 0xaa, 0x5c, 0x9f, + 0xcb, 0x96, 0xf2, 0x61, 0xce, 0x08, 0xc9, 0xc3, 0x88, 0xfe, 0x7b, 0x15, 0x01, 0x2b, 0x98, 0x73, 0x67, 0xf8, 0xee, + 0x1c, 0x50, 0x20, 0x35, 0x1f, 0x68, 0x32, 0x62, 0xc9, 0x60, 0xf0, 0xf8, 0xc2, 0xa3, 0x97, 0x9e, 0x6e, 0xfe, 0xf0, + 0x7a, 0x1a, 0xdb, 0xe0, 0xf8, 0xaa, 0xb6, 0xb7, 0xda, 0xa3, 0xfd, 0x5d, 0x1a, 0xbc, 0x73, 0x8d, 0xd7, 0x37, 0x03, + 0x5a, 0xb9, 0xd1, 0xeb, 0xdb, 0x03, 0xcf, 0x92, 0x07, 0x73, 0x73, 0xe6, 0xea, 0x57, 0x6f, 0x78, 0xc7, 0x74, 0x76, + 0x5c, 0xf6, 0x2b, 0xd2, 0x9f, 0x02, 0xdb, 0x9b, 0x34, 0xdb, 0x55, 0xc5, 0x14, 0xfa, 0xb3, 0x6e, 0x87, 0x36, 0xb3, + 0xc3, 0x82, 0x36, 0xaf, 0xc5, 0xcf, 0xc3, 0xe7, 0x0c, 0xf4, 0xf3, 0x6d, 0x99, 0xc1, 0x4c, 0x1e, 0x73, 0xee, 0x4e, + 0xca, 0xb1, 0x08, 0x99, 0xd1, 0xe0, 0xdd, 0x8f, 0xa7, 0x18, 0xa2, 0xe9, 0x1c, 0xfd, 0x0e, 0x33, 0x34, 0x16, 0xc9, + 0xc8, 0xba, 0xbb, 0x2a, 0xc7, 0xbe, 0x9f, 0xb0, 0x62, 0x54, 0xc2, 0x87, 0x09, 0x58, 0x6d, 0x9a, 0x8c, 0x83, 0x03, + 0xc8, 0x5a, 0x79, 0x47, 0xf0, 0x1e, 0x82, 0x1b, 0x65, 0xd2, 0xcb, 0xf9, 0x70, 0x3e, 0x50, 0x34, 0x11, 0x15, 0x22, + 0xf5, 0x4f, 0x3e, 0x80, 0xb1, 0x50, 0x9a, 0xb5, 0xd4, 0x5b, 0xd0, 0x8f, 0xc2, 0x99, 0x22, 0x18, 0x8c, 0x55, 0x57, + 0x80, 0xde, 0x98, 0x26, 0x82, 0xfa, 0x96, 0xfc, 0xff, 0xc2, 0xfc, 0x4f, 0xcb, 0x69, 0x04, 0xb3, 0x25, 0x84, 0xb1, + 0xd6, 0x05, 0x2d, 0x74, 0x93, 0x8b, 0x1a, 0xcc, 0xb3, 0xe4, 0x64, 0x05, 0x79, 0x92, 0xc2, 0x3e, 0x7b, 0xd0, 0x19, + 0xce, 0x05, 0x2e, 0x4f, 0xaf, 0x94, 0x30, 0xd3, 0xc0, 0xc3, 0xbb, 0x98, 0x60, 0x8e, 0xbb, 0x67, 0xb8, 0xf5, 0x57, + 0xae, 0xfa, 0x20, 0x1e, 0xac, 0x5a, 0x73, 0x18, 0x17, 0x64, 0x7d, 0x22, 0x7d, 0x80, 0x62, 0x84, 0xf9, 0xdb, 0xdb, + 0xd1, 0xf9, 0x53, 0x74, 0xcd, 0xe6, 0x00, 0x1e, 0x91, 0xd0, 0xb3, 0xbf, 0xa1, 0x2e, 0x9a, 0x1b, 0x79, 0xa5, 0x54, + 0xae, 0xe1, 0xd2, 0x42, 0xce, 0x1a, 0xe6, 0x6e, 0xd7, 0xcc, 0x8c, 0x0d, 0xe0, 0x85, 0x0a, 0x72, 0xcd, 0x5e, 0x44, + 0xb0, 0xf4, 0x10, 0xfc, 0x48, 0xe9, 0x27, 0xce, 0xc0, 0xe9, 0x7d, 0xc8, 0x8c, 0xdf, 0x76, 0x97, 0xad, 0xb3, 0x19, + 0x2d, 0xcf, 0x48, 0x06, 0xaa, 0x57, 0xee, 0xea, 0x2e, 0xee, 0x54, 0xaa, 0x07, 0x06, 0xda, 0x4c, 0xa0, 0x0a, 0x67, + 0xb4, 0x57, 0x76, 0x53, 0xbf, 0x53, 0xba, 0x0a, 0x95, 0x89, 0x1b, 0x99, 0x31, 0xa6, 0xd1, 0x1a, 0x2a, 0x1b, 0x96, + 0x19, 0x99, 0x94, 0x14, 0x9a, 0x3d, 0x04, 0xc4, 0x88, 0x49, 0xc6, 0x38, 0xe9, 0xae, 0x0a, 0x99, 0x5e, 0x3c, 0xa0, + 0xb5, 0xc7, 0xa1, 0x70, 0xf8, 0xb4, 0x00, 0x68, 0xd1, 0x00, 0x50, 0x97, 0x42, 0x54, 0xdc, 0x68, 0x45, 0x11, 0xf3, + 0xac, 0x4e, 0xc0, 0x93, 0x82, 0xae, 0xe8, 0x25, 0x77, 0x6b, 0x3f, 0x5b, 0xb1, 0x3a, 0x4f, 0x26, 0xc6, 0x84, 0x30, + 0x5d, 0x48, 0xae, 0x59, 0x58, 0x4b, 0x58, 0x92, 0x07, 0x4f, 0xb8, 0x88, 0x83, 0x46, 0x75, 0x00, 0xe0, 0x29, 0x3c, + 0x0f, 0x18, 0x60, 0x92, 0x65, 0xbf, 0xe3, 0x34, 0x18, 0xd5, 0x15, 0x7d, 0x6c, 0x92, 0xf3, 0xb1, 0x65, 0xd0, 0x3a, + 0x1e, 0x70, 0xce, 0x4b, 0x45, 0xfa, 0xef, 0x5e, 0x30, 0x2c, 0xa7, 0xad, 0x76, 0xa8, 0x98, 0xc1, 0x2b, 0x96, 0xb1, + 0x77, 0xd4, 0x6b, 0xd7, 0xcf, 0x7f, 0x72, 0x42, 0x1d, 0xea, 0xf2, 0xac, 0x87, 0xfb, 0xf4, 0x83, 0x67, 0x1e, 0xfc, + 0x3c, 0xf4, 0x27, 0x1b, 0xc3, 0x5f, 0x7f, 0x7a, 0x7b, 0xf1, 0xcb, 0xf6, 0x25, 0xfb, 0x8b, 0xe7, 0x21, 0xdc, 0xa3, + 0xbf, 0xf9, 0xa1, 0x05, 0x5d, 0x47, 0xff, 0x98, 0x53, 0x48, 0x7a, 0x35, 0x2b, 0x7b, 0xde, 0xd0, 0x76, 0xe9, 0x34, + 0x09, 0xc3, 0x46, 0x3c, 0xed, 0xcf, 0x9b, 0x7e, 0xfb, 0xe6, 0xd1, 0xb5, 0xd2, 0xb2, 0xf3, 0x31, 0xea, 0x73, 0x5e, + 0xab, 0xeb, 0x24, 0xe6, 0xbe, 0x4d, 0x13, 0xa3, 0xcf, 0xc6, 0x8c, 0x53, 0x29, 0x0e, 0xf8, 0xb7, 0xe8, 0xed, 0x09, + 0x5d, 0xdf, 0xa1, 0x4c, 0xfd, 0x29, 0x6c, 0xda, 0xfd, 0xde, 0x06, 0xa2, 0x0c, 0xc1, 0xcb, 0x91, 0x55, 0xde, 0x1e, + 0x90, 0x8b, 0x1e, 0xc1, 0xe4, 0x1a, 0xb9, 0x54, 0x7e, 0xa4, 0x91, 0x96, 0xc3, 0x48, 0xed, 0x99, 0xb4, 0xca, 0xa2, + 0xf9, 0x27, 0x23, 0xf9, 0x04, 0xe2, 0x15, 0x84, 0x11, 0x6a, 0xb2, 0xd0, 0x43, 0x36, 0x90, 0x5c, 0xe5, 0x5c, 0xd9, + 0x43, 0xf3, 0x2c, 0xcf, 0xae, 0x3e, 0x08, 0xad, 0x5f, 0x9a, 0x0e, 0x8e, 0x90, 0x68, 0xcb, 0x0a, 0xe3, 0x8e, 0x41, + 0x1f, 0x93, 0xba, 0x39, 0x7c, 0x00, 0x51, 0x4f, 0x08, 0x73, 0x62, 0x09, 0x4e, 0x0c, 0x46, 0x21, 0x5e, 0xeb, 0x8c, + 0x8d, 0x92, 0xe3, 0xbe, 0xb2, 0x00, 0x85, 0xb5, 0x0c, 0x85, 0x20, 0x6e, 0xd5, 0x95, 0xf2, 0x39, 0xd0, 0x82, 0xd9, + 0x91, 0xc6, 0x18, 0x27, 0x83, 0xb2, 0x8d, 0xf9, 0xa5, 0xae, 0xa1, 0x0a, 0x12, 0x19, 0xbf, 0xce, 0x7f, 0x59, 0x43, + 0x3d, 0xb7, 0xd9, 0x95, 0x23, 0xb3, 0x82, 0x89, 0x59, 0xbe, 0x7d, 0x4e, 0xcb, 0x2e, 0x4a, 0x20, 0xc7, 0x10, 0x5a, + 0x37, 0x4a, 0x98, 0x8f, 0x00, 0xb8, 0x80, 0xda, 0x77, 0xae, 0x84, 0x5b, 0xaa, 0x0b, 0x6f, 0xd1, 0x91, 0xad, 0xf9, + 0x32, 0x77, 0x21, 0x38, 0x65, 0x78, 0x78, 0x6b, 0x76, 0x18, 0xa5, 0xa9, 0xfc, 0xd8, 0xf6, 0x76, 0x84, 0x79, 0x6a, + 0x71, 0x98, 0x73, 0xd4, 0xa8, 0x96, 0xfa, 0xa8, 0xc5, 0x0e, 0x25, 0x17, 0xcb, 0x05, 0xdc, 0x1b, 0x4a, 0xc1, 0xe2, + 0x98, 0x18, 0xeb, 0xbf, 0x1f, 0x0f, 0x0e, 0xa0, 0x53, 0x24, 0xfd, 0x7f, 0xf6, 0xcd, 0xaf, 0x34, 0x7d, 0x56, 0x35, + 0xe3, 0x43, 0x8c, 0xbb, 0x07, 0x8c, 0x75, 0x8e, 0x60, 0x6c, 0x6b, 0x19, 0xeb, 0x44, 0xbf, 0x6c, 0x0c, 0xc5, 0x62, + 0x81, 0x36, 0xf9, 0x28, 0x8f, 0x17, 0xfd, 0x29, 0x2c, 0xfb, 0x7e, 0x49, 0xc0, 0x87, 0x23, 0x2f, 0x74, 0x2b, 0x2c, + 0x94, 0xe7, 0xd5, 0x03, 0x9a, 0x55, 0xc8, 0x1b, 0x2e, 0xa1, 0xab, 0x6f, 0x70, 0xf7, 0x93, 0x78, 0xa7, 0x98, 0x0c, + 0xb4, 0x55, 0x79, 0x00, 0xe3, 0x4f, 0xea, 0xa5, 0x4a, 0xf2, 0x52, 0x3b, 0x31, 0xba, 0x05, 0xbc, 0x6d, 0x92, 0x72, + 0x21, 0x53, 0x95, 0x58, 0x48, 0x23, 0x4f, 0x24, 0x49, 0xd3, 0x42, 0xf5, 0x25, 0x88, 0x4c, 0x96, 0x64, 0x38, 0xc3, + 0x67, 0x50, 0x06, 0x14, 0xbc, 0x1b, 0xe4, 0x56, 0x8d, 0x78, 0xa3, 0x16, 0x04, 0x2f, 0x1a, 0x04, 0xb6, 0xe8, 0xfb, + 0x26, 0x71, 0x4c, 0x18, 0x22, 0x80, 0x01, 0xd6, 0x96, 0x59, 0x79, 0x9e, 0x36, 0xe5, 0xc4, 0xc5, 0xc0, 0x06, 0x65, + 0x76, 0x1b, 0x4e, 0xae, 0xa8, 0xe6, 0xa6, 0x54, 0x77, 0x9e, 0xa3, 0xc6, 0x1e, 0x4b, 0xa6, 0x18, 0xd8, 0xda, 0xb6, + 0x82, 0x03, 0xf0, 0xd7, 0xed, 0xb2, 0x24, 0xd2, 0xfe, 0xc0, 0xf1, 0x4a, 0x54, 0x6a, 0xb7, 0x5b, 0x89, 0xb6, 0x8e, + 0x1a, 0x9c, 0x1b, 0xeb, 0x72, 0xc3, 0xe3, 0xb3, 0xba, 0xfb, 0x62, 0x6f, 0x95, 0x06, 0xdc, 0x77, 0xba, 0xfa, 0x75, + 0xb7, 0x26, 0x09, 0x5d, 0x98, 0xab, 0xcc, 0xba, 0xdb, 0xc0, 0x41, 0x90, 0xf1, 0xe7, 0x68, 0x52, 0x8c, 0x8e, 0xcb, + 0x9c, 0xd3, 0xf1, 0x22, 0x26, 0xcf, 0x51, 0x88, 0x6a, 0x7b, 0xb2, 0xad, 0x56, 0x95, 0xf6, 0x67, 0x9a, 0x98, 0x24, + 0x9e, 0xc7, 0x6f, 0xbe, 0x9c, 0x2a, 0x5f, 0x3a, 0xca, 0x81, 0x15, 0x58, 0xad, 0x02, 0x5e, 0x28, 0x41, 0x4b, 0x14, + 0x13, 0x2a, 0xf0, 0x4e, 0x56, 0xf4, 0x82, 0x31, 0x82, 0x3b, 0xa5, 0x6f, 0x40, 0x6b, 0xf6, 0x90, 0x7c, 0x70, 0xc3, + 0xff, 0xbb, 0xd0, 0x60, 0x87, 0x2d, 0xe0, 0x72, 0xfb, 0x4e, 0x87, 0x25, 0x56, 0x00, 0xd4, 0xb5, 0x1e, 0xc2, 0x1a, + 0x00, 0x1f, 0x68, 0x37, 0xaf, 0xe2, 0x41, 0x35, 0xa8, 0x72, 0x63, 0x1a, 0x80, 0x4c, 0xc3, 0x20, 0x95, 0xa8, 0x08, + 0x6c, 0xea, 0xb5, 0xdf, 0x04, 0xa7, 0x46, 0x93, 0x55, 0x0d, 0xe1, 0x25, 0xc8, 0xd3, 0x5c, 0x50, 0xa3, 0x39, 0x32, + 0x9f, 0xa0, 0x54, 0x66, 0x2a, 0xe5, 0x77, 0x9b, 0x80, 0xca, 0xa2, 0x7a, 0xcb, 0xf5, 0x76, 0x62, 0x5c, 0x7d, 0x83, + 0xd0, 0xa4, 0xbc, 0x95, 0x2d, 0x8e, 0xfc, 0x02, 0xf9, 0x02, 0x05, 0x02, 0xdb, 0xaf, 0xf5, 0x99, 0x16, 0x7b, 0x37, + 0xf6, 0x3c, 0x4a, 0xd2, 0x8a, 0xd2, 0xaf, 0x56, 0x6e, 0x25, 0x90, 0x97, 0x82, 0x37, 0x18, 0x3a, 0x76, 0x6f, 0x9b, + 0xfe, 0x80, 0xea, 0xaf, 0x02, 0x1c, 0x8e, 0x21, 0x6e, 0x02, 0xb5, 0x3b, 0xed, 0xf9, 0x0a, 0xff, 0xb0, 0x91, 0xe3, + 0xe2, 0x81, 0x10, 0x3f, 0x82, 0xa8, 0x44, 0xda, 0x28, 0x40, 0x72, 0x42, 0xbd, 0x98, 0x24, 0x74, 0x89, 0x0a, 0x86, + 0x87, 0xec, 0x77, 0x08, 0x8b, 0xa3, 0x21, 0xb6, 0xb4, 0x84, 0xae, 0xef, 0xbb, 0xa4, 0x1d, 0x70, 0x98, 0x8b, 0x78, + 0xa2, 0x34, 0xf4, 0x27, 0x30, 0x7d, 0x17, 0xbf, 0x44, 0xf3, 0xe0, 0x7c, 0x57, 0xb4, 0x71, 0xd7, 0x6e, 0xff, 0xdc, + 0x43, 0xfc, 0x61, 0x73, 0x79, 0x70, 0x88, 0xdf, 0x16, 0xa7, 0x18, 0xee, 0x63, 0xf2, 0x46, 0x62, 0xba, 0x52, 0xd4, + 0x8c, 0x10, 0x1c, 0x27, 0xc1, 0x8e, 0x7b, 0x5d, 0x7e, 0x4d, 0x92, 0xf8, 0x1a, 0xc2, 0x08, 0x84, 0x8f, 0x23, 0x8b, + 0xd0, 0x47, 0x42, 0x46, 0x96, 0x6f, 0x07, 0xa9, 0xd3, 0x1b, 0xfa, 0xde, 0x3b, 0x5f, 0x53, 0x51, 0x8a, 0xcc, 0xfb, + 0xd5, 0xbc, 0xcd, 0x58, 0x9a, 0x40, 0xd0, 0xca, 0xaf, 0x03, 0xbf, 0xc4, 0xcc, 0xab, 0x0a, 0xd2, 0x6f, 0x02, 0x32, + 0x12, 0x63, 0x27, 0x94, 0xac, 0x68, 0xfd, 0x0e, 0x63, 0xdb, 0xb2, 0xeb, 0x1d, 0x51, 0x9b, 0x32, 0x29, 0x2c, 0x4d, + 0x25, 0x87, 0xc4, 0x9b, 0x2a, 0x64, 0x10, 0x75, 0xf2, 0x75, 0xb4, 0x2b, 0x0e, 0xd6, 0x44, 0xd6, 0xe7, 0x22, 0xc5, + 0x4c, 0x21, 0xe1, 0x72, 0xa3, 0xd1, 0xd4, 0xd7, 0x2e, 0x06, 0xaa, 0xcc, 0xed, 0xed, 0x83, 0xe1, 0xdf, 0xe9, 0x10, + 0x6c, 0x6b, 0xdd, 0x94, 0xf7, 0x36, 0x33, 0xd2, 0x60, 0xc7, 0xea, 0x11, 0x05, 0x31, 0x3c, 0xd3, 0x6a, 0x69, 0xb4, + 0x8e, 0x21, 0x55, 0xab, 0x97, 0xf2, 0x96, 0x5d, 0xba, 0x4e, 0xe4, 0xc2, 0x41, 0x2a, 0x12, 0x3a, 0x73, 0x2c, 0xcf, + 0x98, 0xe7, 0xc5, 0x41, 0x34, 0xbb, 0x92, 0x36, 0x03, 0x14, 0xff, 0xe6, 0x70, 0xb1, 0x1f, 0xa0, 0xdb, 0x25, 0x7d, + 0x80, 0x55, 0x9b, 0x97, 0x32, 0x12, 0x8e, 0x47, 0xf5, 0x16, 0xfd, 0x64, 0xb0, 0x2e, 0xd1, 0x04, 0xbe, 0x56, 0x8b, + 0xb1, 0xf7, 0x73, 0xe1, 0x61, 0x34, 0xcd, 0xaf, 0x07, 0xd9, 0x51, 0xdf, 0x7a, 0x23, 0xef, 0x44, 0x79, 0xf5, 0x09, + 0x91, 0x0e, 0x6e, 0x38, 0xfa, 0xfa, 0x09, 0x11, 0x7e, 0xa1, 0x4d, 0xd1, 0x20, 0x20, 0x8b, 0xae, 0xbb, 0x41, 0xa0, + 0xe4, 0xac, 0x6a, 0xf8, 0x5a, 0xda, 0xeb, 0x56, 0x49, 0x90, 0x1d, 0xf5, 0x2d, 0xbc, 0x5e, 0x24, 0x07, 0xd6, 0xb3, + 0x54, 0x2a, 0x31, 0x61, 0x20, 0xc7, 0xdb, 0x4c, 0x25, 0x7f, 0xa4, 0xcf, 0xf3, 0x6c, 0xec, 0xb0, 0x8e, 0xd5, 0xd1, + 0x6d, 0x0c, 0x91, 0xb8, 0x1a, 0x1c, 0xd4, 0xe2, 0x03, 0x43, 0x2c, 0x4c, 0xc9, 0xba, 0x54, 0xb7, 0x1d, 0x1a, 0x0d, + 0x80, 0x3a, 0x9a, 0xe3, 0x58, 0xf2, 0x8f, 0x3b, 0x65, 0x79, 0x6c, 0x62, 0xee, 0x7d, 0xdd, 0x55, 0x13, 0xfc, 0x94, + 0xd7, 0xd6, 0x60, 0x00, 0x40, 0x33, 0x8b, 0xb9, 0xe8, 0xca, 0xa8, 0x87, 0xcf, 0x2f, 0x86, 0xc8, 0x8b, 0x84, 0xe1, + 0xb3, 0x99, 0x0c, 0xb1, 0xa3, 0xf8, 0x1e, 0xf9, 0xb6, 0x74, 0xbe, 0xf8, 0x77, 0x86, 0x2d, 0x24, 0x42, 0xf7, 0x27, + 0x83, 0xae, 0x7a, 0x36, 0xbf, 0x97, 0x45, 0xa2, 0x64, 0x44, 0x47, 0xcd, 0x90, 0x92, 0x35, 0x54, 0x7a, 0x48, 0x5a, + 0x69, 0xef, 0xf8, 0x6e, 0x66, 0xb1, 0x0e, 0x4d, 0x7f, 0x42, 0xce, 0x0c, 0x4c, 0x77, 0xf1, 0xb4, 0x25, 0x5a, 0x49, + 0x65, 0x1f, 0x06, 0xad, 0x33, 0x2b, 0xfc, 0x63, 0xcd, 0x25, 0x24, 0xe7, 0x80, 0x32, 0x93, 0x90, 0x68, 0xbf, 0x91, + 0xfa, 0x4c, 0x26, 0xee, 0x55, 0xea, 0xd3, 0xb1, 0x3b, 0xf9, 0xce, 0x6b, 0x72, 0xe1, 0x0a, 0xee, 0xd8, 0xbd, 0xf2, + 0x1e, 0xbe, 0x9d, 0x0c, 0x9a, 0x6b, 0xe8, 0xad, 0xcd, 0xf0, 0x01, 0xce, 0x56, 0x8a, 0x9c, 0xb9, 0x00, 0xf2, 0x32, + 0x69, 0x36, 0x54, 0x82, 0xee, 0x1b, 0x73, 0xb9, 0x53, 0x93, 0x39, 0x8c, 0x0d, 0x9a, 0x16, 0x86, 0xb9, 0x91, 0xa1, + 0x4e, 0x67, 0xc2, 0xf1, 0xbd, 0x71, 0x31, 0x7d, 0x41, 0xce, 0x9f, 0x74, 0x2f, 0x12, 0x87, 0xca, 0xda, 0x0d, 0x85, + 0xff, 0x83, 0xcb, 0x2f, 0x61, 0x48, 0xe5, 0xe2, 0xdc, 0xb7, 0xe3, 0xf3, 0xd6, 0x7b, 0xef, 0x87, 0x71, 0x3b, 0x3c, + 0xdc, 0xc6, 0xc0, 0xa5, 0xbb, 0x78, 0x59, 0xe6, 0xce, 0x93, 0x82, 0x12, 0x74, 0x78, 0x5a, 0x55, 0x0a, 0xa2, 0x5a, + 0x36, 0x78, 0x14, 0x31, 0x3f, 0x74, 0x07, 0x79, 0x68, 0x2b, 0x63, 0x50, 0xe8, 0x91, 0x74, 0x84, 0xe2, 0x41, 0x62, + 0x25, 0x76, 0x07, 0x8a, 0x91, 0x3b, 0xe2, 0x55, 0x2a, 0xe4, 0x26, 0x7b, 0x6e, 0xea, 0x8a, 0x56, 0x40, 0x21, 0x00, + 0xe9, 0x0d, 0x96, 0x6d, 0x11, 0x81, 0x24, 0xf8, 0x82, 0xa8, 0x1b, 0xdb, 0xbe, 0xf2, 0x74, 0xd2, 0x1b, 0x18, 0x41, + 0x04, 0x5a, 0x4a, 0x6f, 0x43, 0x3d, 0x7a, 0x88, 0x74, 0x4c, 0x64, 0xc6, 0x93, 0xef, 0x63, 0x0e, 0x05, 0x92, 0x48, + 0x5c, 0xd2, 0x0c, 0xa9, 0xaa, 0xbf, 0x6e, 0x95, 0x7e, 0xbb, 0x61, 0x50, 0x96, 0x85, 0x86, 0xc6, 0x00, 0x1f, 0x49, + 0x8c, 0xad, 0x6f, 0xeb, 0xfe, 0xea, 0x46, 0x03, 0x39, 0x05, 0xbc, 0xb9, 0x82, 0xfa, 0x79, 0xb3, 0xb5, 0x30, 0x19, + 0x88, 0xb3, 0xe2, 0x2f, 0x47, 0x77, 0x2a, 0x09, 0x55, 0x1a, 0xdb, 0x93, 0xef, 0x5e, 0x3e, 0xfa, 0x0f, 0x0c, 0x2a, + 0x95, 0x07, 0xfa, 0xb6, 0xa6, 0x3e, 0x88, 0xc0, 0xd8, 0x28, 0x8c, 0xd3, 0x76, 0x23, 0xaa, 0xf3, 0x66, 0x6e, 0x27, + 0x40, 0x53, 0x32, 0x5d, 0x42, 0x15, 0xf6, 0x4e, 0x11, 0xa7, 0xad, 0x98, 0xc7, 0x08, 0x2d, 0x5a, 0xdd, 0xa6, 0x92, + 0x14, 0x09, 0xc5, 0x1b, 0x35, 0x98, 0x44, 0xdc, 0xb1, 0x65, 0x5c, 0x17, 0xa2, 0x1b, 0x05, 0xbc, 0x5e, 0x4a, 0x1f, + 0xb2, 0xce, 0xcf, 0x96, 0x8e, 0xd4, 0x9b, 0x1f, 0x55, 0x66, 0xb6, 0xe8, 0x34, 0xf4, 0xde, 0x54, 0x49, 0xd6, 0x04, + 0x6e, 0x60, 0x64, 0x2d, 0xe3, 0x32, 0xaa, 0x00, 0x0f, 0x85, 0x59, 0x42, 0x18, 0x66, 0x41, 0x89, 0x0d, 0x80, 0x1f, + 0x6b, 0x50, 0x9b, 0xff, 0x44, 0xee, 0xc8, 0xb4, 0x75, 0xf7, 0x06, 0x06, 0x23, 0xb5, 0xba, 0xb6, 0x14, 0x6d, 0xa9, + 0xd0, 0x2c, 0xd7, 0x9a, 0x24, 0x41, 0x76, 0x5c, 0x01, 0xa5, 0x6a, 0x00, 0xae, 0x5c, 0x01, 0x2c, 0x53, 0x9b, 0x87, + 0xac, 0x71, 0xee, 0xeb, 0xee, 0x6e, 0x5b, 0xb0, 0x46, 0x72, 0x33, 0x8c, 0x05, 0x3e, 0xef, 0x0b, 0x81, 0x8f, 0x12, + 0xfc, 0xa8, 0x6a, 0x3a, 0x77, 0x00, 0xc5, 0x82, 0xb2, 0xba, 0x49, 0xd7, 0xad, 0x20, 0x89, 0xd0, 0xf6, 0xbe, 0x0d, + 0x99, 0xbe, 0xd1, 0x57, 0x9d, 0x20, 0xad, 0xcc, 0xe8, 0x6d, 0xac, 0xa3, 0x88, 0xa4, 0x4c, 0x47, 0x89, 0xbd, 0x47, + 0xe5, 0x22, 0xaa, 0x80, 0xbf, 0x50, 0x63, 0x84, 0x29, 0x0a, 0x55, 0x2a, 0x7f, 0x9d, 0xf5, 0x3e, 0x19, 0x13, 0xfe, + 0xba, 0x83, 0xea, 0x06, 0xf2, 0x6a, 0x32, 0x47, 0x28, 0x14, 0x95, 0x2b, 0x0b, 0x5a, 0xb1, 0xbe, 0x60, 0xdc, 0x17, + 0x80, 0x12, 0x2b, 0x6d, 0x1d, 0xca, 0xc1, 0xa6, 0xbe, 0x3c, 0xd9, 0x58, 0x35, 0x3c, 0x16, 0xf5, 0xa7, 0x6c, 0x29, + 0xb4, 0x54, 0x6b, 0xae, 0x6b, 0x64, 0x73, 0x57, 0x0a, 0xed, 0xc2, 0xe6, 0xd8, 0x55, 0xb7, 0xa8, 0xcc, 0x96, 0x60, + 0x42, 0x6d, 0xb6, 0x9e, 0x41, 0xe1, 0x18, 0x62, 0xf6, 0x05, 0x81, 0xa4, 0x53, 0xa3, 0xa6, 0x6b, 0xb6, 0xa3, 0x8a, + 0xc4, 0xf2, 0x2f, 0x0b, 0x85, 0xaf, 0x34, 0x2c, 0xa2, 0xb0, 0x30, 0xd1, 0x7c, 0x85, 0xcb, 0x8b, 0x4b, 0x36, 0xbf, + 0x61, 0xc9, 0x7e, 0x3e, 0x6e, 0x33, 0xd3, 0x05, 0x5d, 0xee, 0x6d, 0x7a, 0x09, 0x64, 0x17, 0x23, 0xd4, 0xa7, 0x8f, + 0x8d, 0x06, 0x50, 0xfd, 0x51, 0x76, 0x7d, 0x67, 0xd8, 0x05, 0x07, 0x69, 0x4b, 0xc1, 0x94, 0x8a, 0x30, 0x0c, 0x22, + 0x8d, 0x75, 0x4a, 0x2a, 0x76, 0x45, 0xea, 0x2c, 0x11, 0x36, 0x22, 0xec, 0xcd, 0xcf, 0xbd, 0xbf, 0x8b, 0xb8, 0xf1, + 0x17, 0x6f, 0x4f, 0x5b, 0x26, 0xd0, 0x1e, 0x39, 0xef, 0xd1, 0x54, 0x1d, 0x13, 0x79, 0x18, 0x1e, 0x49, 0xab, 0x14, + 0x9d, 0xc6, 0xdb, 0x48, 0x27, 0x11, 0xea, 0x52, 0x74, 0xc9, 0xcc, 0x58, 0x92, 0xfc, 0xb7, 0x25, 0xef, 0xc6, 0x79, + 0x2e, 0x70, 0xc2, 0xe3, 0xb2, 0x53, 0xc3, 0x68, 0x7d, 0x1f, 0xb0, 0xe8, 0xef, 0xfe, 0xa2, 0xa3, 0xb9, 0x3a, 0x5b, + 0x32, 0x8f, 0xa6, 0x1d, 0xe3, 0x17, 0x38, 0x19, 0xec, 0x1c, 0xd7, 0x6e, 0x49, 0x53, 0x37, 0x7c, 0x1d, 0x64, 0x20, + 0x6f, 0x63, 0x0f, 0x59, 0xb6, 0x2e, 0x31, 0x2a, 0x5b, 0x20, 0x44, 0xec, 0xfe, 0x79, 0x4d, 0xfb, 0x6f, 0xae, 0x76, + 0x9d, 0xef, 0x86, 0x5e, 0xcf, 0xa8, 0x96, 0x4f, 0x3a, 0x31, 0x5b, 0x38, 0xe3, 0xae, 0x2a, 0x0d, 0x34, 0xae, 0x9b, + 0xc5, 0xaa, 0x62, 0x6a, 0x71, 0xbf, 0x6b, 0xca, 0xf8, 0x1e, 0xb6, 0x27, 0x6d, 0x5b, 0xc1, 0x56, 0xe3, 0x34, 0xe8, + 0x4c, 0x6e, 0xfb, 0x55, 0xda, 0xf0, 0x34, 0x59, 0x95, 0x79, 0xf9, 0x6f, 0xef, 0x66, 0x47, 0x66, 0xb6, 0x78, 0x31, + 0x09, 0x6f, 0xf8, 0x46, 0xc4, 0x03, 0x7b, 0xae, 0xdb, 0xbb, 0xdd, 0x7e, 0x7c, 0x0e, 0xe8, 0xe9, 0xe3, 0xe9, 0x1d, + 0xcd, 0x8f, 0x06, 0x76, 0xf1, 0xb5, 0xb4, 0xce, 0xee, 0x4b, 0xe2, 0x43, 0x43, 0x17, 0x17, 0xa5, 0x13, 0xc7, 0xdf, + 0x10, 0x95, 0x6c, 0xfb, 0x31, 0x0e, 0x7f, 0x2a, 0x16, 0xa7, 0x97, 0xb0, 0x69, 0xce, 0x64, 0xd0, 0xb0, 0xdd, 0x6c, + 0xbf, 0x77, 0x9e, 0x00, 0xf1, 0xe6, 0x3c, 0x62, 0x50, 0x55, 0xd6, 0x5b, 0x67, 0x7d, 0x90, 0xdf, 0x1d, 0x13, 0xa2, + 0x76, 0x71, 0xc3, 0x9c, 0xdc, 0xa3, 0x72, 0xab, 0x5b, 0x05, 0x7a, 0xb1, 0xdc, 0xe5, 0xe4, 0x9e, 0xd0, 0x6a, 0xf2, + 0xc0, 0x15, 0xfc, 0x02, 0x0e, 0x13, 0xea, 0x85, 0x74, 0x49, 0xf7, 0xf2, 0xe2, 0x03, 0xc9, 0x7f, 0x3d, 0xe8, 0x31, + 0x14, 0x94, 0xb6, 0xcd, 0xb5, 0x91, 0xe3, 0x94, 0x51, 0x3f, 0xf6, 0xad, 0x52, 0x65, 0x4e, 0x58, 0x78, 0x1c, 0xdd, + 0x6f, 0xa3, 0x6e, 0x7c, 0x2f, 0x61, 0x44, 0xfe, 0xb4, 0x0e, 0x5a, 0x73, 0xe5, 0x08, 0xd1, 0xad, 0xed, 0xda, 0x13, + 0xe9, 0x02, 0xc6, 0x0e, 0x20, 0x4b, 0xfa, 0x4c, 0x53, 0x89, 0xc1, 0x28, 0x36, 0x9d, 0x43, 0xb3, 0x24, 0x30, 0xa5, + 0x6e, 0x6b, 0x74, 0xd0, 0x6a, 0xc2, 0x43, 0xa8, 0x9d, 0xa6, 0x0e, 0x81, 0x71, 0x1c, 0x74, 0x6d, 0x9f, 0x67, 0xd9, + 0xd8, 0xb3, 0xaa, 0xe5, 0x63, 0x4c, 0x0d, 0x74, 0x22, 0xb5, 0xed, 0xf7, 0x13, 0x03, 0x63, 0x80, 0x8f, 0xa1, 0xa5, + 0x25, 0xe7, 0x86, 0xbe, 0x7b, 0x3e, 0xd1, 0x05, 0x8d, 0x73, 0x6f, 0x4b, 0x30, 0xa1, 0xd5, 0x7c, 0x13, 0x90, 0x40, + 0x2d, 0xc1, 0x35, 0x27, 0x56, 0x06, 0x6b, 0x6f, 0xfe, 0xa8, 0x83, 0xbb, 0x9e, 0x8c, 0xde, 0x8b, 0x5e, 0x03, 0x89, + 0x81, 0x3a, 0xa3, 0x13, 0xae, 0x1a, 0xe8, 0x4d, 0xce, 0xb8, 0xff, 0x04, 0x43, 0x91, 0x66, 0x14, 0x80, 0x44, 0xf8, + 0x68, 0x26, 0xdc, 0x1e, 0x9f, 0x8a, 0xf0, 0x70, 0x99, 0xdd, 0x3b, 0xcd, 0xae, 0xa7, 0xb8, 0xff, 0xa7, 0xd6, 0xa7, + 0x9e, 0x64, 0xb5, 0x51, 0x93, 0x94, 0x5e, 0x5e, 0x60, 0x32, 0x2d, 0x4e, 0xa9, 0x5d, 0xb1, 0x83, 0xb2, 0x9f, 0x8d, + 0x6b, 0xfa, 0x1d, 0xcf, 0xe1, 0x52, 0x17, 0x04, 0x5b, 0x0e, 0x14, 0x5b, 0x79, 0xf4, 0x4e, 0x30, 0x82, 0x6e, 0xa3, + 0xbe, 0x71, 0xbb, 0x36, 0x26, 0xa6, 0x98, 0x13, 0x99, 0xb2, 0xd0, 0xa2, 0xd2, 0x66, 0x5c, 0x5b, 0xa2, 0x7d, 0x51, + 0x62, 0xbd, 0xea, 0x7f, 0xce, 0x4f, 0xc6, 0xae, 0xa9, 0x3b, 0xe2, 0xc9, 0x66, 0x81, 0x41, 0xc2, 0xa1, 0x01, 0x9a, + 0x4c, 0xf4, 0xbf, 0xdb, 0x81, 0xb6, 0xd1, 0x51, 0xe6, 0x99, 0xbc, 0xed, 0x7d, 0x11, 0x8b, 0x75, 0xad, 0x09, 0x72, + 0xe3, 0xf5, 0xaf, 0x0b, 0x4a, 0x4f, 0xf9, 0x38, 0xff, 0x4b, 0x7c, 0x9f, 0x0b, 0x76, 0x39, 0xb2, 0x5d, 0x01, 0x15, + 0x94, 0xb3, 0x21, 0xd4, 0x72, 0xa1, 0x27, 0xf1, 0x3d, 0xe5, 0x8b, 0x39, 0x49, 0xdc, 0xd6, 0xfd, 0x1c, 0xc8, 0xde, + 0x0f, 0x3b, 0xd2, 0x23, 0x89, 0x41, 0xaf, 0x0d, 0x44, 0x09, 0xbe, 0xf4, 0xae, 0x36, 0x6d, 0xe7, 0x69, 0x96, 0x5c, + 0x37, 0x44, 0xfd, 0x46, 0x19, 0x40, 0x53, 0xb5, 0xbf, 0xa2, 0x50, 0xbf, 0x60, 0x4f, 0xfd, 0xdc, 0x8f, 0x99, 0x76, + 0x36, 0x69, 0x50, 0x87, 0x3a, 0x12, 0x68, 0x4e, 0xcf, 0xf3, 0x54, 0x83, 0xd3, 0xf5, 0xb5, 0xe7, 0xcd, 0xb8, 0xc0, + 0x49, 0xa3, 0x1e, 0xff, 0xd5, 0x5c, 0xb5, 0xd5, 0x62, 0xc0, 0x1a, 0x04, 0x9e, 0xe7, 0xc5, 0x57, 0xe1, 0x34, 0x54, + 0x47, 0x51, 0xae, 0xc4, 0x1a, 0xdd, 0x6b, 0x42, 0x30, 0xa2, 0x39, 0xc0, 0x93, 0x65, 0x26, 0xa9, 0xa5, 0x4c, 0x7e, + 0x96, 0x56, 0x51, 0xe9, 0x8a, 0x6d, 0x2f, 0x03, 0x17, 0xab, 0x67, 0x5c, 0xb2, 0x79, 0x91, 0x40, 0xba, 0xa8, 0x9b, + 0xe3, 0x31, 0xec, 0x86, 0xc2, 0xdd, 0xd4, 0x8f, 0x84, 0x54, 0x6f, 0x75, 0xc9, 0xd1, 0xac, 0x43, 0x5c, 0xfb, 0x46, + 0x74, 0x40, 0xd3, 0xc2, 0xf1, 0x1d, 0x4c, 0xb0, 0x91, 0x09, 0x5a, 0x4c, 0x1b, 0x28, 0xfd, 0x01, 0x76, 0xd2, 0x96, + 0xf8, 0x24, 0x76, 0x78, 0x89, 0xdd, 0xd0, 0x0f, 0x39, 0xf8, 0x42, 0x41, 0x03, 0x51, 0x8f, 0x64, 0x6f, 0x4a, 0x70, + 0xfb, 0xa9, 0x3b, 0x39, 0xef, 0x27, 0xcb, 0x00, 0xc4, 0xec, 0xda, 0x35, 0x2d, 0x78, 0x3d, 0xd1, 0x56, 0x47, 0x1d, + 0x9d, 0xe8, 0xd5, 0x8e, 0x26, 0x45, 0x22, 0xe6, 0xd3, 0xbc, 0xc2, 0xfa, 0x6c, 0x19, 0xa0, 0x7b, 0x98, 0xed, 0x57, + 0x3b, 0x97, 0x7d, 0x18, 0xc3, 0x72, 0x12, 0xbc, 0xd2, 0x1d, 0xe2, 0xd6, 0x5b, 0xa4, 0xe9, 0xa7, 0x59, 0xfb, 0xb7, + 0xbf, 0x74, 0x47, 0x93, 0x51, 0x27, 0x9b, 0xb7, 0xc3, 0x66, 0xbe, 0xc0, 0x3d, 0x5e, 0x9a, 0xa8, 0x09, 0xa2, 0x51, + 0x78, 0xa6, 0x0a, 0xbf, 0x03, 0x14, 0xba, 0x12, 0x04, 0xf1, 0xd5, 0x19, 0x4d, 0xa9, 0x44, 0x8d, 0x67, 0x49, 0x6f, + 0xae, 0xf8, 0xff, 0xc7, 0xed, 0x66, 0xf3, 0xb2, 0x9b, 0x81, 0x86, 0x94, 0x65, 0xd2, 0x67, 0xb5, 0x3a, 0x8a, 0xe2, + 0x59, 0x64, 0xe4, 0xe0, 0x67, 0x9a, 0x97, 0x71, 0x7e, 0x35, 0x6f, 0x86, 0xc7, 0x42, 0x35, 0x93, 0xf2, 0xf6, 0xc5, + 0x7e, 0xda, 0x3d, 0xd0, 0x05, 0xdc, 0xea, 0x47, 0xb5, 0xa7, 0xdc, 0x8a, 0xc3, 0xa4, 0xef, 0xea, 0x50, 0xe1, 0x6e, + 0x38, 0x7f, 0x48, 0xee, 0x21, 0x67, 0x90, 0xb6, 0x10, 0xd4, 0xf0, 0xaa, 0x49, 0xe5, 0x77, 0x43, 0x47, 0x18, 0xd1, + 0xb3, 0x18, 0x7d, 0xee, 0x7a, 0x80, 0x71, 0x1c, 0x51, 0x70, 0xd2, 0x94, 0x27, 0x58, 0x38, 0x5d, 0x91, 0x4e, 0x9c, + 0xf2, 0x4a, 0xe9, 0x45, 0x49, 0x87, 0xf2, 0x8c, 0x35, 0xe5, 0x25, 0x04, 0x90, 0x14, 0x8b, 0x93, 0x1a, 0x05, 0x8c, + 0x3b, 0xfa, 0x7a, 0x90, 0x78, 0xcb, 0x63, 0x6c, 0x2d, 0xf2, 0x55, 0xe2, 0x6f, 0x2b, 0x31, 0x1f, 0xcb, 0x27, 0xaf, + 0x95, 0x3c, 0xd7, 0x0b, 0xa7, 0x87, 0x16, 0x63, 0xc8, 0xc3, 0xc5, 0xb5, 0x93, 0x0f, 0x7b, 0x69, 0x0c, 0xf2, 0x54, + 0x56, 0xf1, 0x99, 0xf7, 0x60, 0x2c, 0x76, 0x0c, 0x4f, 0xf6, 0x2f, 0xf0, 0x4a, 0xea, 0x8b, 0xf1, 0x53, 0x37, 0x0e, + 0xf1, 0xd3, 0x34, 0x58, 0x87, 0x78, 0x66, 0x3f, 0xd3, 0x1e, 0x11, 0x73, 0x14, 0x55, 0xe5, 0x4d, 0xae, 0xa8, 0x05, + 0xbe, 0x6c, 0xb9, 0x5a, 0x42, 0xb2, 0x9d, 0x69, 0x90, 0xf7, 0x9a, 0x41, 0x7d, 0x0f, 0xc4, 0xa0, 0x14, 0xe8, 0x65, + 0xc7, 0xd2, 0x97, 0xea, 0x9e, 0x6a, 0x24, 0xfc, 0xc9, 0x90, 0xd2, 0xa4, 0xda, 0x24, 0x24, 0x27, 0xa5, 0x63, 0x4a, + 0x55, 0x5b, 0x0a, 0xef, 0xb9, 0x6b, 0x83, 0x26, 0xe4, 0x44, 0xf4, 0x36, 0x41, 0x48, 0x2b, 0xfb, 0x35, 0x89, 0x00, + 0xc6, 0x9e, 0x96, 0x43, 0xde, 0xe1, 0x6c, 0x09, 0xc1, 0x8a, 0xe3, 0x53, 0xb4, 0x6c, 0xb4, 0xef, 0x99, 0x49, 0xba, + 0xf5, 0x9c, 0xb3, 0xb0, 0x05, 0x43, 0x1b, 0x58, 0xfa, 0xad, 0x08, 0xd2, 0xe9, 0xd5, 0xa9, 0x15, 0x7f, 0x52, 0xfb, + 0xf0, 0x92, 0x2b, 0xcf, 0x21, 0x6a, 0x9e, 0x3c, 0x4d, 0x4b, 0x8d, 0x5a, 0x2e, 0x2d, 0xbd, 0xa8, 0x8e, 0x02, 0x8f, + 0x80, 0x76, 0x3f, 0xc2, 0x0e, 0x08, 0xde, 0xb9, 0x23, 0x05, 0x2c, 0x77, 0x5a, 0x06, 0x8e, 0xd8, 0x6c, 0xc0, 0xfd, + 0x5f, 0xe5, 0xc3, 0xfa, 0x58, 0x4b, 0x0b, 0xbf, 0x53, 0x22, 0x72, 0x98, 0x15, 0xba, 0xe2, 0x23, 0xca, 0x14, 0x7b, + 0x32, 0x95, 0x37, 0xb8, 0xd0, 0x25, 0x86, 0x4f, 0x1f, 0x17, 0x0d, 0x98, 0x04, 0xa4, 0x64, 0xd5, 0xcd, 0xca, 0x84, + 0xf3, 0xed, 0xb2, 0xc5, 0xa8, 0x56, 0xc2, 0xfb, 0xe9, 0xb2, 0x1d, 0x35, 0x0a, 0xa9, 0xc4, 0xd3, 0x65, 0x2a, 0xc2, + 0x3e, 0x11, 0xef, 0xb7, 0xa5, 0x24, 0xc0, 0x62, 0xf2, 0x12, 0x22, 0x60, 0x2a, 0x02, 0x98, 0xf1, 0x57, 0x8c, 0x10, + 0x79, 0x39, 0x96, 0x54, 0xe1, 0xf5, 0x51, 0x14, 0xac, 0x62, 0x2f, 0x8b, 0xa2, 0xeb, 0x17, 0x18, 0xf7, 0xb0, 0x3d, + 0x84, 0x8d, 0x5c, 0xc2, 0x1d, 0xf5, 0xb6, 0x69, 0xa5, 0x7c, 0x18, 0x4b, 0xf4, 0xf8, 0x1d, 0x04, 0xca, 0x5d, 0xc2, + 0xf5, 0xa8, 0x75, 0x79, 0x03, 0x6f, 0x89, 0xd2, 0xa9, 0x5a, 0xe2, 0xab, 0x17, 0xaf, 0xad, 0x56, 0x73, 0x2e, 0x44, + 0x27, 0x19, 0x31, 0x0a, 0xcd, 0x3c, 0x8e, 0xa9, 0x60, 0x64, 0x1d, 0x72, 0x91, 0x8e, 0xe2, 0x10, 0x18, 0xbd, 0x20, + 0x88, 0xe8, 0x2d, 0x6a, 0xdf, 0x01, 0x0e, 0x1c, 0x50, 0x47, 0x93, 0x58, 0x9e, 0xf8, 0x52, 0xa7, 0xe0, 0x05, 0xb7, + 0xc4, 0xb0, 0x26, 0xaa, 0x61, 0x94, 0x83, 0x51, 0xcf, 0x9c, 0xaa, 0x0a, 0x4b, 0xcc, 0x57, 0xce, 0xee, 0x05, 0x1d, + 0xdd, 0xcd, 0xdc, 0x21, 0x56, 0xf2, 0x75, 0x11, 0x85, 0x13, 0x49, 0x24, 0xc5, 0xf9, 0xa2, 0xab, 0x18, 0x90, 0x4a, + 0xc7, 0x59, 0x5a, 0x1c, 0x39, 0x66, 0xe8, 0xf0, 0xfb, 0x01, 0x69, 0x74, 0x29, 0x05, 0x61, 0x8c, 0x57, 0x71, 0x92, + 0x3b, 0x12, 0x57, 0x08, 0x9e, 0xc4, 0xfd, 0xf5, 0xf5, 0x44, 0x23, 0x19, 0x0c, 0xf5, 0xf1, 0x23, 0x88, 0x56, 0x4d, + 0x9e, 0xe7, 0xa7, 0x6c, 0x4b, 0xca, 0xa7, 0xbc, 0xe2, 0x2d, 0x6c, 0x0e, 0xa6, 0x0d, 0x88, 0x71, 0x4b, 0x1f, 0x26, + 0x6e, 0xc1, 0xd4, 0x92, 0x5a, 0x98, 0x0b, 0x1a, 0x53, 0x9f, 0xf3, 0x36, 0xf3, 0x4b, 0xe0, 0x99, 0xe7, 0x31, 0x0c, + 0x48, 0x90, 0x4f, 0x8c, 0xba, 0x26, 0x13, 0x91, 0x36, 0x91, 0x18, 0x55, 0xfd, 0x58, 0xfb, 0xd5, 0x0a, 0x76, 0x85, + 0x54, 0xf8, 0x63, 0x17, 0x1c, 0x97, 0x6d, 0x8a, 0x71, 0x03, 0x7d, 0xdf, 0x09, 0x92, 0x90, 0x1e, 0xe9, 0x2a, 0xcf, + 0x70, 0x37, 0x2a, 0xd0, 0x49, 0x3e, 0x1e, 0x3b, 0x87, 0x17, 0x09, 0xec, 0x73, 0x42, 0x7d, 0x1e, 0x09, 0x47, 0xda, + 0x46, 0x85, 0x24, 0x20, 0x92, 0x0d, 0xce, 0x30, 0x28, 0x71, 0x69, 0xbd, 0x27, 0x09, 0x56, 0xdc, 0xfd, 0xfc, 0x9f, + 0x6c, 0x0b, 0xa8, 0x45, 0xf5, 0x67, 0x4a, 0x0d, 0x58, 0xec, 0xa7, 0x59, 0x7f, 0xca, 0xf8, 0xb1, 0x8d, 0xb3, 0x11, + 0x64, 0xcb, 0x25, 0xf7, 0xa3, 0x77, 0xfa, 0x3f, 0xab, 0x2a, 0xdd, 0x92, 0x3a, 0xe4, 0xcd, 0x79, 0xa4, 0x8f, 0x07, + 0xd6, 0xa8, 0x51, 0xe7, 0xb4, 0x36, 0x75, 0x25, 0x09, 0xe2, 0x0a, 0x28, 0xc6, 0x19, 0x1a, 0x91, 0x9d, 0x4f, 0x84, + 0xfd, 0xe9, 0xf8, 0x1e, 0x67, 0xa2, 0x91, 0x3b, 0x54, 0x50, 0x5f, 0x3a, 0x29, 0x56, 0x7c, 0x94, 0xe3, 0x00, 0x8c, + 0x4b, 0x1b, 0xd4, 0xda, 0x30, 0x43, 0xf7, 0xa2, 0x08, 0x85, 0xef, 0x0f, 0xf4, 0xb1, 0x4d, 0x01, 0xc6, 0x70, 0xd7, + 0x2f, 0x6a, 0xd7, 0x75, 0x59, 0xc8, 0xa1, 0x99, 0xab, 0x52, 0x73, 0xa8, 0x0c, 0xb9, 0xdc, 0x64, 0x5e, 0xc2, 0x9b, + 0x63, 0x23, 0xd4, 0xae, 0x27, 0xe9, 0xab, 0x12, 0xe0, 0x0a, 0x7d, 0x85, 0x5d, 0x7d, 0xde, 0x85, 0xb1, 0xec, 0x43, + 0x3e, 0xa8, 0xb5, 0x7b, 0x55, 0x84, 0xc0, 0xd0, 0x8a, 0xd2, 0xe6, 0x45, 0x2e, 0x7b, 0x6f, 0xa2, 0xd4, 0x99, 0x35, + 0x28, 0x5d, 0xcb, 0xea, 0x92, 0xf4, 0x49, 0x6d, 0x4c, 0x25, 0x38, 0xc4, 0x42, 0x2b, 0x4f, 0xaa, 0x85, 0x2d, 0x69, + 0x7a, 0x66, 0x36, 0xae, 0x0c, 0x05, 0xb2, 0x6b, 0xa1, 0x97, 0x82, 0x1a, 0xb7, 0x05, 0x02, 0x73, 0x8a, 0xac, 0xaa, + 0x0d, 0xca, 0x5b, 0xa5, 0x7d, 0x34, 0x01, 0xe7, 0x41, 0x44, 0xee, 0xa4, 0x4a, 0x3b, 0x61, 0xe9, 0x48, 0x49, 0xfe, + 0x4b, 0xeb, 0x6e, 0x71, 0xca, 0x30, 0x18, 0xf2, 0x53, 0x48, 0x0e, 0x1a, 0xa2, 0xc6, 0x50, 0x5d, 0x3b, 0x4d, 0x22, + 0xc0, 0xd5, 0x72, 0x9e, 0xb5, 0x99, 0xd5, 0x3e, 0x85, 0x73, 0x16, 0xe5, 0x24, 0xbf, 0x6b, 0x7a, 0xed, 0x6b, 0x8d, + 0x83, 0x60, 0x4d, 0x5a, 0xcf, 0xc1, 0x70, 0x88, 0x97, 0x8c, 0x48, 0x02, 0x00, 0xc6, 0x46, 0x0a, 0x21, 0x49, 0x87, + 0xd3, 0xf1, 0x79, 0xf3, 0x92, 0x56, 0xf5, 0xfe, 0xc4, 0xd0, 0xbe, 0x4b, 0xaa, 0x79, 0x7e, 0xad, 0x74, 0x31, 0x4e, + 0x6d, 0x2c, 0x58, 0xa8, 0xf8, 0x48, 0x3a, 0x69, 0x9e, 0x53, 0x85, 0xd8, 0x5f, 0xec, 0x37, 0xf8, 0xe0, 0x4b, 0x6a, + 0xc1, 0x64, 0x5c, 0xa8, 0x05, 0x86, 0x44, 0xaa, 0x0f, 0x74, 0x1d, 0x07, 0x63, 0x69, 0x70, 0xe9, 0xf8, 0x5c, 0xda, + 0x26, 0x1d, 0x78, 0xf5, 0xd1, 0xbe, 0xa7, 0xc9, 0xb4, 0xf8, 0xe2, 0x68, 0xb9, 0x6d, 0x3b, 0xe5, 0x5c, 0x0a, 0x28, + 0xf9, 0x5a, 0x39, 0x86, 0x74, 0xc2, 0xc5, 0xba, 0x81, 0x1c, 0x1c, 0x1e, 0x3e, 0x0f, 0x92, 0x9b, 0x73, 0x27, 0x0c, + 0x21, 0x96, 0x27, 0xb6, 0x13, 0x90, 0x9b, 0xcb, 0x37, 0xd1, 0xd8, 0x04, 0x81, 0x5d, 0x6e, 0x5d, 0x75, 0xfb, 0xac, + 0xa1, 0xd0, 0xa4, 0x4b, 0x42, 0x93, 0x4a, 0xd5, 0x88, 0xc7, 0xb3, 0x0a, 0x27, 0x8f, 0x29, 0xb4, 0xd2, 0x2b, 0x97, + 0xd0, 0x88, 0x63, 0x05, 0x8a, 0x2d, 0x22, 0x05, 0xa6, 0x8a, 0x3a, 0xa9, 0x1d, 0xe5, 0x6e, 0x85, 0x34, 0x4f, 0x48, + 0xbb, 0x5c, 0xa3, 0x4f, 0x95, 0xd6, 0x36, 0x25, 0x6b, 0x35, 0x71, 0x29, 0x00, 0xab, 0x39, 0x74, 0x3d, 0x55, 0xcd, + 0x19, 0x0b, 0xf7, 0xda, 0x8e, 0xab, 0x19, 0x14, 0xda, 0xa5, 0x9f, 0x42, 0x03, 0xac, 0x6c, 0x3c, 0xbd, 0x99, 0xa0, + 0xd9, 0x71, 0x34, 0x31, 0xe9, 0xea, 0x08, 0x4a, 0xc7, 0x68, 0x3c, 0xcf, 0x15, 0x19, 0x1f, 0xe4, 0x5c, 0x26, 0x25, + 0xf8, 0x4f, 0x7b, 0x9b, 0x7e, 0x51, 0xba, 0x43, 0x45, 0x66, 0x27, 0x40, 0x27, 0x3b, 0x5e, 0x67, 0x83, 0x8b, 0x24, + 0x01, 0x26, 0x76, 0xe6, 0xa8, 0xe5, 0xcb, 0x8d, 0xb2, 0xf8, 0x7e, 0x18, 0x83, 0x64, 0x55, 0xc3, 0xd2, 0x17, 0xa5, + 0xce, 0x30, 0x71, 0x9b, 0x6e, 0x7d, 0xe7, 0x8e, 0x72, 0x81, 0xa6, 0x81, 0x9e, 0x93, 0x2f, 0xd6, 0xac, 0x62, 0xcc, + 0x5f, 0x59, 0x80, 0x5d, 0xbf, 0x44, 0xb6, 0xcc, 0xd5, 0xa5, 0xd6, 0x4e, 0xe4, 0x55, 0x7d, 0x53, 0xcc, 0x40, 0x87, + 0x40, 0x40, 0x56, 0xc9, 0xa2, 0x8a, 0x36, 0x79, 0xc8, 0xc1, 0x28, 0x53, 0xd3, 0x34, 0x1d, 0xe6, 0x60, 0x84, 0x5b, + 0x4b, 0x63, 0x47, 0x46, 0x1a, 0xc2, 0x4c, 0x9f, 0xee, 0x7e, 0xaa, 0x11, 0xb0, 0x09, 0x80, 0xd2, 0xcb, 0xd1, 0x86, + 0x9a, 0x8b, 0x8f, 0xf3, 0x7c, 0xaf, 0x5b, 0xb2, 0x4c, 0xbb, 0x5b, 0x5c, 0x96, 0x72, 0x28, 0xda, 0x86, 0xad, 0xa6, + 0xbb, 0xd0, 0x36, 0x69, 0xf1, 0x89, 0xe4, 0x46, 0xee, 0xb7, 0xf4, 0x9b, 0xbe, 0x9b, 0x10, 0x81, 0xec, 0x5e, 0x68, + 0x17, 0x7d, 0x53, 0x02, 0xae, 0x6f, 0xda, 0x19, 0x81, 0x42, 0x6f, 0x6a, 0xe0, 0xd6, 0xf6, 0x7a, 0x2b, 0xc8, 0x55, + 0x8a, 0x23, 0x62, 0x91, 0xc0, 0x01, 0xea, 0x72, 0x59, 0x82, 0xbb, 0xa0, 0xd4, 0x98, 0x95, 0x25, 0xd0, 0x0e, 0xce, + 0xf7, 0x69, 0x68, 0xce, 0xee, 0xba, 0x30, 0x50, 0xd5, 0xf8, 0x38, 0x1d, 0x1b, 0x98, 0x52, 0xc0, 0x85, 0x5d, 0x42, + 0x53, 0xb7, 0x76, 0x61, 0x6a, 0xd9, 0x35, 0x54, 0x6a, 0xd6, 0xe8, 0x0d, 0xee, 0x76, 0xcb, 0x45, 0xde, 0xf6, 0xd8, + 0xae, 0x97, 0x5a, 0x49, 0x83, 0x0d, 0x2b, 0x66, 0x6d, 0xd8, 0xf0, 0xd6, 0xa0, 0x68, 0x48, 0x28, 0xdb, 0xb1, 0xe1, + 0x2f, 0xad, 0x21, 0x21, 0x62, 0x44, 0x40, 0x8b, 0x4b, 0x7c, 0xc5, 0x76, 0x89, 0x23, 0x47, 0xd6, 0xb3, 0xa6, 0xa5, + 0xea, 0x92, 0xf4, 0xd9, 0x6f, 0xcf, 0xe9, 0xd2, 0x5b, 0xfd, 0x54, 0x73, 0x12, 0x44, 0x2f, 0xba, 0xa1, 0x86, 0xa0, + 0x8f, 0x95, 0x65, 0x0a, 0xa7, 0x83, 0x28, 0x84, 0x27, 0x2e, 0x81, 0xf1, 0x41, 0x34, 0x6a, 0xde, 0xba, 0x87, 0xbb, + 0x9f, 0x85, 0x46, 0x88, 0xce, 0xa3, 0xa0, 0x74, 0x44, 0x5e, 0xa0, 0xc8, 0x30, 0x1f, 0x55, 0x2b, 0x78, 0x7a, 0x85, + 0x3d, 0x7e, 0x30, 0xda, 0xa2, 0xfc, 0xfc, 0x85, 0xa5, 0xfe, 0xb9, 0xf8, 0xa8, 0xbb, 0x9d, 0xc9, 0x46, 0xda, 0x4d, + 0x4b, 0x5f, 0x0f, 0xc7, 0x4c, 0xab, 0x41, 0x0a, 0x6b, 0x44, 0x4e, 0x0c, 0x96, 0x34, 0xa5, 0xef, 0x73, 0x0c, 0x6d, + 0x12, 0xcf, 0xc6, 0x5e, 0x0a, 0xbb, 0xfb, 0x47, 0x9c, 0x26, 0x59, 0x08, 0xce, 0xb7, 0xa7, 0xbf, 0x9e, 0xfe, 0x04, + 0xd3, 0xf7, 0x4d, 0xd3, 0xf4, 0xf5, 0x3b, 0x41, 0x37, 0x80, 0xb0, 0x4e, 0xec, 0x7c, 0xfb, 0x59, 0xa0, 0xea, 0xab, + 0x56, 0x51, 0x5b, 0x35, 0x7e, 0xf7, 0xe8, 0x0d, 0x2b, 0xa3, 0xc2, 0x0b, 0x6e, 0xa4, 0x5c, 0xa2, 0x97, 0xfa, 0xa2, + 0x32, 0xd8, 0xfd, 0xc1, 0x34, 0x2d, 0xe9, 0xd1, 0xc0, 0x47, 0x7f, 0x95, 0x5c, 0xc7, 0x64, 0x75, 0x5e, 0xce, 0xd5, + 0xfd, 0xca, 0x1e, 0x49, 0x30, 0xf9, 0x82, 0x10, 0xde, 0x81, 0x2b, 0xe9, 0x2e, 0x9c, 0x7e, 0x9b, 0x6e, 0x7b, 0xe9, + 0xce, 0x33, 0x79, 0xdb, 0x3f, 0x1c, 0x0e, 0x68, 0x39, 0x2b, 0xb8, 0xbf, 0xbf, 0x6c, 0xdd, 0xdb, 0x60, 0xc3, 0xae, + 0x4a, 0xba, 0x75, 0x25, 0x5b, 0x61, 0x23, 0x0b, 0x07, 0x3a, 0xae, 0xde, 0xec, 0x32, 0xad, 0xf4, 0x7a, 0xc3, 0xde, + 0x9b, 0x79, 0x7d, 0xaf, 0xb2, 0xad, 0x71, 0x95, 0x8d, 0x6f, 0x4a, 0xe1, 0x4e, 0x86, 0xc8, 0x8e, 0xf2, 0x82, 0xca, + 0x8e, 0x97, 0x3d, 0x25, 0x74, 0x5b, 0x00, 0x55, 0x63, 0xc6, 0xe8, 0xa4, 0x97, 0x27, 0x62, 0xad, 0x3a, 0xb3, 0x2b, + 0x49, 0xdc, 0x25, 0x87, 0x1a, 0xe8, 0x82, 0x92, 0x5a, 0x4d, 0x3c, 0x36, 0x36, 0xd3, 0x17, 0xa4, 0x5f, 0x42, 0xe5, + 0xb1, 0xf2, 0xc4, 0x7f, 0xd1, 0x97, 0xd8, 0xef, 0x1d, 0xf0, 0xc5, 0xd0, 0xfe, 0xa3, 0x8b, 0x05, 0x3f, 0x0f, 0xdc, + 0x48, 0xd0, 0x47, 0x3f, 0x8b, 0x50, 0x14, 0x7b, 0xff, 0xc7, 0xd1, 0x1b, 0xba, 0x00, 0x6a, 0x50, 0x7f, 0xe6, 0x67, + 0x55, 0xd1, 0x82, 0x76, 0x27, 0xb2, 0x74, 0xe2, 0x5a, 0x2e, 0x1d, 0x21, 0xc9, 0x59, 0x8e, 0x6b, 0xd1, 0xe4, 0x53, + 0xb4, 0x47, 0x0c, 0x35, 0x8b, 0xa3, 0xbf, 0xe9, 0x40, 0x4f, 0x34, 0x98, 0x45, 0x87, 0xa2, 0xa8, 0xcf, 0x95, 0xaa, + 0x5f, 0xa9, 0x1d, 0xee, 0xa7, 0x62, 0xe7, 0x4b, 0xf2, 0x7e, 0xc0, 0x71, 0xbe, 0xd4, 0x98, 0x97, 0xea, 0x99, 0x8a, + 0x1a, 0xb0, 0x89, 0x5d, 0xd6, 0xa2, 0x0b, 0x86, 0xcd, 0x87, 0xda, 0x1d, 0x17, 0xb2, 0xdb, 0xf2, 0x8d, 0xd2, 0x4e, + 0xb5, 0xb2, 0xe0, 0xa4, 0x04, 0x5d, 0x12, 0xa3, 0x70, 0x41, 0x0e, 0xe2, 0x57, 0x0d, 0xcb, 0x87, 0x1f, 0x8a, 0xd8, + 0x6b, 0xb9, 0x3f, 0xea, 0x82, 0x4a, 0x41, 0xa6, 0x5e, 0x14, 0xac, 0xd5, 0x19, 0x9d, 0x8f, 0xb5, 0x7f, 0x3a, 0x51, + 0x95, 0x8a, 0xf9, 0x24, 0xf1, 0x62, 0x1e, 0x30, 0xa1, 0xab, 0xd4, 0x29, 0x1f, 0x45, 0x27, 0xb3, 0xaf, 0x37, 0x4f, + 0x45, 0x1f, 0x4f, 0x8a, 0xf3, 0x13, 0x64, 0xdb, 0x1e, 0x83, 0x48, 0x25, 0x4d, 0x2d, 0x3f, 0x70, 0x17, 0x2a, 0x95, + 0xa9, 0xc3, 0xb2, 0x88, 0x99, 0x82, 0xb6, 0xf0, 0x0d, 0xba, 0xbd, 0x00, 0xf3, 0x54, 0x30, 0xb9, 0x85, 0x38, 0x35, + 0xeb, 0xb6, 0x90, 0xbc, 0x4b, 0x44, 0x90, 0x59, 0xe0, 0x8b, 0x14, 0x1b, 0xf0, 0x8e, 0xa7, 0x9a, 0x06, 0xf2, 0xd4, + 0x10, 0xd7, 0x17, 0x84, 0xd9, 0x4e, 0x90, 0xcb, 0x6d, 0x07, 0x71, 0x25, 0x2b, 0xc8, 0xd7, 0x35, 0xd4, 0x70, 0xb1, + 0x3d, 0x57, 0x5a, 0x5d, 0x12, 0x41, 0x68, 0x53, 0xc5, 0x49, 0x74, 0xaf, 0xef, 0x9c, 0xbf, 0x42, 0x0b, 0x54, 0xbb, + 0xa8, 0xd5, 0xbf, 0x9b, 0x34, 0x21, 0x4a, 0x3e, 0xd5, 0x84, 0x31, 0xb4, 0xa3, 0xe9, 0x87, 0xb0, 0x06, 0x23, 0x72, + 0xc2, 0x70, 0x24, 0xe0, 0x43, 0x04, 0x17, 0x68, 0x88, 0xd2, 0x58, 0x98, 0xf1, 0x65, 0xab, 0x01, 0x0e, 0x49, 0xf3, + 0xd9, 0xc0, 0xd7, 0xec, 0x2a, 0xb1, 0x15, 0x08, 0x87, 0x28, 0x1c, 0x1a, 0x37, 0x96, 0xce, 0xc6, 0x03, 0x13, 0x4d, + 0x9a, 0x32, 0xf8, 0x56, 0xa7, 0xea, 0xaf, 0xe3, 0x34, 0x8b, 0xd4, 0x43, 0xa7, 0xb2, 0xe4, 0x53, 0xe7, 0x0b, 0x1a, + 0xe0, 0xac, 0xdc, 0xad, 0xb5, 0x0f, 0x0a, 0xa7, 0x7e, 0x07, 0x1f, 0x68, 0x87, 0xee, 0x28, 0x25, 0xc0, 0x9f, 0x47, + 0xa0, 0x2f, 0xe5, 0x9c, 0xa6, 0x22, 0xbd, 0x84, 0xf6, 0x57, 0x23, 0xba, 0x35, 0x4d, 0x7d, 0x2b, 0x2f, 0xdb, 0xe7, + 0x54, 0x84, 0xc0, 0xb8, 0x02, 0x7d, 0x3d, 0x66, 0xa4, 0x0b, 0x32, 0x66, 0x3f, 0x87, 0xbc, 0x90, 0x64, 0x22, 0x77, + 0x3a, 0xfe, 0x55, 0xfd, 0x6b, 0xb5, 0x50, 0x47, 0x82, 0x55, 0xec, 0xd4, 0xd6, 0xed, 0x4c, 0xf8, 0x40, 0xe1, 0x20, + 0xc9, 0x8e, 0x02, 0x1c, 0xf7, 0x92, 0x0b, 0x5f, 0x8f, 0x63, 0x30, 0x5d, 0x3d, 0x2e, 0x27, 0x8d, 0x8a, 0xe6, 0x3c, + 0xe9, 0x82, 0xba, 0xfb, 0x87, 0x0e, 0x7e, 0x72, 0x4a, 0x18, 0x5c, 0x67, 0xf9, 0xa1, 0xd0, 0xc7, 0x6a, 0x00, 0x42, + 0x3e, 0xad, 0x4c, 0x06, 0xf9, 0x06, 0x74, 0xb4, 0x4c, 0x45, 0xcb, 0xa8, 0x91, 0x38, 0xa5, 0xc2, 0x8f, 0x5a, 0xda, + 0x16, 0xf2, 0x41, 0xe3, 0x62, 0x8a, 0x5c, 0xc1, 0xd7, 0x2b, 0x39, 0x0f, 0x56, 0xc9, 0xb8, 0x09, 0x2b, 0x5d, 0x6a, + 0x85, 0xe5, 0xed, 0xd4, 0xb9, 0x40, 0xe8, 0x9a, 0xaf, 0xac, 0xf7, 0x3f, 0x07, 0x30, 0x79, 0x8b, 0xd6, 0xd0, 0x61, + 0x23, 0xb4, 0x11, 0xe6, 0x18, 0x90, 0x63, 0xad, 0xec, 0xb6, 0x83, 0x36, 0xf8, 0xd5, 0x4f, 0xdf, 0x51, 0x81, 0x6d, + 0x4c, 0x76, 0xbb, 0x1f, 0x52, 0x74, 0x36, 0xb6, 0xf7, 0x4b, 0x05, 0x53, 0xc8, 0xf2, 0x88, 0xcc, 0x28, 0xae, 0x46, + 0x3d, 0x6d, 0x5f, 0x2b, 0x89, 0xae, 0x3a, 0x8b, 0xdb, 0x9e, 0x0a, 0x62, 0xb7, 0x10, 0xe6, 0x53, 0xd4, 0x9c, 0x94, + 0x5d, 0x2f, 0xcd, 0x49, 0xd1, 0x19, 0xc5, 0x9e, 0xe0, 0x74, 0xf3, 0xfa, 0x02, 0xc3, 0xd7, 0xe8, 0x43, 0x69, 0x5d, + 0x0d, 0xe2, 0x89, 0x78, 0x4c, 0x8d, 0xde, 0x76, 0x28, 0xb2, 0xf1, 0x75, 0x9a, 0x03, 0xb2, 0xf5, 0x2b, 0xba, 0xda, + 0x44, 0x30, 0xdd, 0x07, 0x65, 0xab, 0x5e, 0x02, 0x3c, 0x6e, 0xf8, 0xf1, 0xfb, 0x13, 0xb9, 0xf8, 0x58, 0x39, 0x51, + 0xc3, 0x5a, 0x77, 0x2f, 0xbf, 0x6a, 0xb9, 0x0d, 0x34, 0x9b, 0x7a, 0x9a, 0xcd, 0xbf, 0x35, 0x5e, 0xb1, 0xa2, 0xa7, + 0xe6, 0x9e, 0x26, 0x46, 0xf4, 0x53, 0x2f, 0xed, 0x2f, 0x01, 0xc5, 0x3f, 0x9f, 0xe8, 0xbe, 0xbf, 0xef, 0xf7, 0x6d, + 0xbf, 0x7b, 0xa6, 0x5b, 0x25, 0x75, 0xfb, 0xa3, 0x67, 0x29, 0x3a, 0xc7, 0x5b, 0xe3, 0x32, 0xa5, 0x45, 0xed, 0xd0, + 0x75, 0x75, 0xea, 0xe7, 0xdf, 0x68, 0x66, 0x94, 0x77, 0x7f, 0xca, 0xbf, 0x3e, 0x44, 0xe2, 0x44, 0x8b, 0x49, 0xd6, + 0x78, 0xbf, 0x6f, 0x71, 0x62, 0x3e, 0xb0, 0x5b, 0xe3, 0x98, 0x2b, 0x1a, 0x6c, 0x54, 0x3f, 0xaa, 0xb8, 0x4f, 0xed, + 0x81, 0xc9, 0x37, 0x10, 0xd4, 0xca, 0x6c, 0x31, 0xbe, 0x51, 0x49, 0x16, 0xed, 0x36, 0xf4, 0xf0, 0x36, 0x82, 0x74, + 0xff, 0x65, 0x62, 0xba, 0x9c, 0xd7, 0x34, 0x1f, 0xfb, 0x95, 0xe7, 0x16, 0x0d, 0x61, 0x07, 0xe1, 0x3f, 0x57, 0x89, + 0x57, 0x89, 0x46, 0x62, 0x28, 0x9a, 0xdf, 0x02, 0x2b, 0x1e, 0xa7, 0x8a, 0xee, 0x14, 0x78, 0x31, 0x28, 0x53, 0x05, + 0x3d, 0xb5, 0x0b, 0x36, 0xf2, 0x48, 0xf7, 0x9c, 0xf6, 0x1d, 0xbb, 0xc7, 0xac, 0xc2, 0x7a, 0x34, 0x66, 0x73, 0xf7, + 0x4c, 0x6c, 0x87, 0xd2, 0xbb, 0x37, 0xd8, 0x18, 0x69, 0xe4, 0x38, 0x2c, 0xff, 0x93, 0x16, 0x03, 0x6a, 0x98, 0x79, + 0xb4, 0x53, 0x9a, 0x10, 0xe8, 0x77, 0xb5, 0x5d, 0xdd, 0xda, 0x56, 0x91, 0x84, 0x17, 0x1f, 0x96, 0xb5, 0xc1, 0x82, + 0x2c, 0x52, 0x15, 0xbb, 0xf9, 0x97, 0xf0, 0xda, 0xcc, 0x41, 0x9b, 0x9c, 0x54, 0x7f, 0x64, 0xb5, 0x9e, 0x40, 0xa6, + 0xd0, 0x78, 0xef, 0xb0, 0xb9, 0xab, 0x1e, 0x6d, 0xc7, 0x72, 0x01, 0x11, 0x98, 0xdd, 0xeb, 0xd9, 0xb5, 0x25, 0x91, + 0xa5, 0x62, 0xc1, 0x65, 0x9a, 0x38, 0x9e, 0x8d, 0x3a, 0xda, 0x3e, 0x3e, 0x03, 0x7c, 0xb8, 0x00, 0x6f, 0xcf, 0x7a, + 0xab, 0xf4, 0x1b, 0xa9, 0x19, 0xfa, 0x8c, 0xc6, 0x90, 0x3a, 0x10, 0x4e, 0x6a, 0xdd, 0xd3, 0xdd, 0x47, 0xac, 0x11, + 0xbe, 0xc3, 0x37, 0xf1, 0x67, 0x79, 0xe1, 0x4a, 0x8a, 0xce, 0x41, 0x85, 0x62, 0x3d, 0xd5, 0x50, 0x36, 0xd3, 0xeb, + 0x54, 0x72, 0xe3, 0xec, 0x72, 0xae, 0x15, 0xba, 0x1e, 0x19, 0x2b, 0xfa, 0x45, 0x08, 0x47, 0xf8, 0x50, 0x26, 0x4d, + 0x62, 0x21, 0xe7, 0xfc, 0x1f, 0xec, 0x8f, 0x2d, 0x80, 0xa2, 0xd5, 0xbc, 0x24, 0xbd, 0x38, 0xa3, 0x09, 0x0c, 0x70, + 0x8f, 0x3a, 0xf0, 0x9c, 0xb9, 0x2f, 0x40, 0x56, 0x98, 0x34, 0xda, 0x03, 0x23, 0xb3, 0x2c, 0x42, 0xa9, 0x43, 0x0c, + 0xc2, 0xc5, 0xf7, 0xdc, 0xca, 0xea, 0x32, 0x70, 0xd2, 0xdb, 0xa0, 0x9e, 0x9a, 0xaf, 0xba, 0xf6, 0x95, 0x58, 0x81, + 0x44, 0x80, 0xb6, 0x22, 0x17, 0xb8, 0x46, 0x55, 0x9f, 0x38, 0x21, 0x79, 0x0e, 0x71, 0x94, 0x5a, 0x48, 0x58, 0x21, + 0xb9, 0xa5, 0x62, 0x2b, 0x56, 0x46, 0xa9, 0xe5, 0xb6, 0x74, 0x29, 0x14, 0x8e, 0x72, 0x1a, 0x73, 0x95, 0xa7, 0xa8, + 0xfc, 0x74, 0x7c, 0xe7, 0x14, 0x25, 0x36, 0xed, 0xa3, 0x34, 0x52, 0xa5, 0x52, 0x88, 0x52, 0x17, 0xec, 0x7e, 0x59, + 0x8b, 0x81, 0xc5, 0x46, 0x64, 0x25, 0xff, 0x55, 0x29, 0x62, 0x9a, 0x28, 0xdd, 0x32, 0x0f, 0x10, 0x83, 0x18, 0x09, + 0x43, 0x10, 0x3d, 0xfc, 0x94, 0x08, 0xd4, 0x80, 0x73, 0xce, 0x62, 0x85, 0x9e, 0x7c, 0xdd, 0xd4, 0x5b, 0xc8, 0x72, + 0x40, 0xcc, 0x08, 0xab, 0xde, 0xbc, 0xaa, 0x1d, 0x4f, 0xa1, 0x73, 0xa4, 0x64, 0x89, 0xa8, 0xf9, 0xa5, 0xa1, 0x52, + 0xa1, 0x2e, 0x06, 0xab, 0x05, 0x4f, 0xb5, 0x57, 0xa6, 0xb3, 0xa5, 0xe9, 0xdb, 0x4e, 0x42, 0x97, 0x26, 0x15, 0x12, + 0xcd, 0x33, 0x4d, 0x24, 0x6f, 0x26, 0x18, 0x61, 0x1b, 0xd9, 0xc4, 0x04, 0x05, 0xc0, 0x46, 0x36, 0xca, 0x7c, 0x77, + 0xfb, 0x9a, 0xa6, 0x3d, 0x37, 0x99, 0xd2, 0xe4, 0x88, 0x4c, 0x69, 0x94, 0x93, 0x42, 0x69, 0x2a, 0x2a, 0x1a, 0x4c, + 0x2f, 0x07, 0x95, 0x65, 0xc4, 0xfe, 0xe7, 0xa2, 0xc4, 0x94, 0xd1, 0xe4, 0x16, 0xf5, 0x05, 0x70, 0x5b, 0x27, 0xf4, + 0xee, 0xc0, 0xaa, 0xbb, 0xbb, 0x0d, 0x55, 0x2f, 0x0e, 0xdc, 0x85, 0xd6, 0xc1, 0x5b, 0xb7, 0x80, 0xcd, 0xbc, 0x38, + 0xab, 0x22, 0x80, 0xb4, 0x4d, 0x05, 0xa4, 0xbd, 0x51, 0xb6, 0x1d, 0x5e, 0x56, 0x34, 0xeb, 0xce, 0xb9, 0xb2, 0x3a, + 0x95, 0x68, 0x65, 0x86, 0x54, 0x2a, 0x84, 0x70, 0x6d, 0x03, 0xf0, 0x2d, 0xfc, 0x60, 0xad, 0x8d, 0x3f, 0x28, 0x4c, + 0x7b, 0xae, 0xe2, 0xe5, 0x02, 0xb9, 0xe6, 0xe6, 0xc7, 0x59, 0xe4, 0x41, 0xeb, 0x4a, 0x05, 0x36, 0xa0, 0x46, 0x57, + 0xe5, 0xb2, 0xb9, 0xf6, 0x37, 0x66, 0x08, 0xb6, 0x44, 0xdd, 0x18, 0x5a, 0xeb, 0xd5, 0x73, 0x2c, 0x6f, 0x7c, 0x9f, + 0xb3, 0x8a, 0x4c, 0x5d, 0x1f, 0xc9, 0x46, 0x74, 0xd6, 0x92, 0x7c, 0x64, 0x3a, 0x68, 0xfa, 0xce, 0x6f, 0x93, 0xab, + 0x58, 0xd1, 0x63, 0x62, 0x80, 0x70, 0x47, 0x7c, 0xd1, 0xee, 0x31, 0x74, 0x05, 0xe8, 0x4a, 0x75, 0x2a, 0x05, 0x75, + 0xf0, 0x05, 0x0e, 0x7c, 0xcd, 0x52, 0x8a, 0x33, 0xcb, 0x46, 0x55, 0xa9, 0xf9, 0xaa, 0xee, 0xcc, 0x9e, 0xca, 0x4b, + 0xa2, 0xae, 0xdf, 0x5d, 0xe7, 0x0a, 0xda, 0x47, 0x3e, 0x22, 0x28, 0xc6, 0xd8, 0x6b, 0xfe, 0xb8, 0xd5, 0x87, 0x9d, + 0x57, 0x41, 0x24, 0x5c, 0x84, 0x90, 0x11, 0x11, 0x8e, 0x83, 0x84, 0x40, 0xfb, 0xb0, 0x6b, 0x68, 0x88, 0x8c, 0xf1, + 0x0e, 0x86, 0x2c, 0x84, 0x18, 0x1a, 0x5d, 0xc7, 0x2d, 0x61, 0x62, 0xea, 0x94, 0x48, 0x97, 0x31, 0x57, 0x11, 0xd6, + 0x0e, 0x79, 0x35, 0xb5, 0x21, 0xf7, 0x2b, 0xee, 0x92, 0xc1, 0x11, 0xbd, 0x23, 0x42, 0x3d, 0xbf, 0x2e, 0xb9, 0xd6, + 0xb2, 0xc8, 0xbf, 0x66, 0xa4, 0x96, 0x87, 0x7a, 0xc4, 0x3e, 0xf5, 0x19, 0xea, 0x00, 0x17, 0xce, 0x58, 0x0f, 0x6c, + 0x8c, 0x59, 0x7d, 0x6a, 0x13, 0x89, 0xee, 0x49, 0x3a, 0x69, 0xf1, 0x08, 0x38, 0x53, 0x2d, 0x13, 0x1c, 0x55, 0x20, + 0x7b, 0x23, 0xc9, 0x98, 0x73, 0x0a, 0x02, 0x27, 0xa8, 0x57, 0x04, 0x4a, 0x59, 0xd6, 0x6f, 0xb3, 0xed, 0x7b, 0x0b, + 0x57, 0x47, 0xfb, 0xd7, 0x89, 0xff, 0x7a, 0x10, 0x5a, 0x8b, 0x6f, 0xce, 0xb7, 0xdd, 0x6d, 0xfe, 0x4f, 0x21, 0x6c, + 0x04, 0x49, 0x17, 0x49, 0xb1, 0x5a, 0xb0, 0xad, 0x94, 0x9e, 0xb4, 0x54, 0x03, 0x6b, 0x9e, 0xe1, 0xb8, 0x92, 0xdf, + 0xeb, 0x49, 0x45, 0x55, 0x55, 0xb9, 0x5f, 0x91, 0x14, 0x47, 0xf6, 0x50, 0x95, 0xc8, 0xa0, 0xd3, 0x90, 0x34, 0x43, + 0x33, 0x7a, 0xf3, 0x56, 0xaa, 0x31, 0x7a, 0x83, 0x35, 0x4e, 0xa3, 0xda, 0x00, 0x3d, 0x11, 0x9d, 0x59, 0xb6, 0x5d, + 0x7c, 0x12, 0xe2, 0xcd, 0x85, 0x6f, 0x8e, 0xa6, 0x89, 0x60, 0xa6, 0xf1, 0x7f, 0x8a, 0x51, 0x58, 0xf6, 0x2c, 0x6f, + 0x13, 0x33, 0x11, 0xf0, 0xc8, 0x80, 0x85, 0x47, 0xff, 0xf8, 0x57, 0xde, 0x1d, 0xb5, 0xba, 0x0b, 0x77, 0x3d, 0x16, + 0xbd, 0xe7, 0xab, 0x67, 0xf0, 0x12, 0x8c, 0x63, 0x99, 0xb5, 0xed, 0xac, 0xdb, 0x73, 0xd9, 0xe3, 0x6c, 0x92, 0xc5, + 0xc4, 0x28, 0x12, 0x8b, 0x66, 0xb8, 0x9e, 0xb4, 0x6c, 0xbd, 0x4d, 0xd4, 0x25, 0x5a, 0xdf, 0x13, 0xa5, 0x79, 0xa6, + 0x3b, 0xc2, 0x98, 0xc3, 0x28, 0x8a, 0xf0, 0x82, 0x3d, 0xc4, 0x5d, 0xa5, 0x4d, 0x44, 0x6b, 0x0e, 0x53, 0xa8, 0xb2, + 0x2b, 0x2d, 0x1a, 0x81, 0x34, 0xb4, 0x17, 0x14, 0xbf, 0xb8, 0x7e, 0x49, 0xa1, 0x3b, 0x3e, 0x59, 0x20, 0x93, 0x26, + 0xc3, 0x21, 0x7c, 0x62, 0x74, 0xab, 0x60, 0xef, 0xb7, 0x5e, 0x52, 0x9d, 0x6f, 0x03, 0x41, 0x97, 0x87, 0xe8, 0x41, + 0x11, 0x0c, 0xe2, 0x7b, 0x6b, 0x31, 0x7a, 0x8c, 0x99, 0xb0, 0x41, 0xd3, 0xd0, 0x75, 0x37, 0x64, 0x06, 0xe9, 0x45, + 0x51, 0x37, 0xdc, 0x49, 0xaa, 0xff, 0x8f, 0xad, 0xaf, 0xa2, 0x12, 0x0a, 0x50, 0xe6, 0x7c, 0x89, 0xcc, 0x33, 0x66, + 0x84, 0xf6, 0x31, 0x33, 0x7e, 0xeb, 0x8b, 0x3a, 0x57, 0x2c, 0x85, 0xd6, 0xdc, 0x02, 0xfb, 0xfa, 0x14, 0xf6, 0x1a, + 0x8f, 0xd7, 0x4d, 0x93, 0x2b, 0xca, 0x25, 0x82, 0xf9, 0xfa, 0x84, 0x6c, 0x5b, 0x50, 0x54, 0x56, 0x70, 0x62, 0x25, + 0x5a, 0xce, 0xb4, 0xad, 0xac, 0x64, 0x04, 0x0d, 0x56, 0x45, 0x63, 0x95, 0xae, 0x2f, 0x86, 0xd9, 0x17, 0x3a, 0x58, + 0xf2, 0x65, 0x53, 0xba, 0x0b, 0xd5, 0x51, 0xcd, 0xd4, 0x9a, 0xcc, 0x4b, 0xe8, 0xf3, 0x68, 0xba, 0x36, 0x8a, 0xbe, + 0xcb, 0xa6, 0xb8, 0x75, 0x22, 0x16, 0x00, 0xa5, 0x80, 0x48, 0xe8, 0xac, 0x33, 0x53, 0x28, 0x7a, 0xe3, 0xa3, 0xfd, + 0xde, 0x3b, 0xc1, 0x08, 0x1b, 0x6b, 0x85, 0xce, 0x32, 0x1e, 0x68, 0xa2, 0x63, 0x65, 0x63, 0x00, 0xdd, 0x45, 0x53, + 0x7b, 0x82, 0x14, 0xed, 0x57, 0x6c, 0x54, 0xb0, 0x82, 0x76, 0x46, 0x88, 0xb8, 0x1f, 0xd8, 0x93, 0x5f, 0xa1, 0x2d, + 0xeb, 0x09, 0xa3, 0x10, 0x6d, 0xd2, 0x3a, 0xa7, 0x63, 0x62, 0x46, 0x9c, 0x32, 0xe3, 0xa3, 0xf0, 0x29, 0xd1, 0x7b, + 0x04, 0xab, 0x35, 0xcf, 0xa8, 0xc2, 0x88, 0x8f, 0xab, 0xb1, 0x8c, 0x65, 0xc8, 0xcc, 0x47, 0x61, 0xe9, 0x7b, 0x01, + 0x98, 0x44, 0xdf, 0xd1, 0x50, 0x68, 0xad, 0x7d, 0x56, 0x74, 0xd0, 0x4d, 0x41, 0xc9, 0x8c, 0xc7, 0x9d, 0xa3, 0x64, + 0x30, 0x6a, 0xea, 0x34, 0xb0, 0x96, 0x9d, 0x9b, 0xd0, 0x00, 0x15, 0x71, 0x8a, 0xbc, 0x07, 0x49, 0x55, 0xf9, 0x1f, + 0x94, 0x10, 0xb2, 0x82, 0xef, 0x8e, 0x29, 0x85, 0x4f, 0x4a, 0x6f, 0x52, 0x3b, 0x8f, 0xae, 0x91, 0xb6, 0x81, 0xbd, + 0x17, 0x9a, 0xff, 0xa8, 0xac, 0x72, 0x94, 0x42, 0xd2, 0x65, 0x7a, 0x99, 0x39, 0xf4, 0x4c, 0x35, 0x76, 0x5f, 0x78, + 0xfd, 0xa7, 0x30, 0x2f, 0xbe, 0xa2, 0xcd, 0x57, 0x44, 0x7a, 0x3e, 0x9e, 0xc1, 0x30, 0x22, 0xb1, 0xd9, 0x1d, 0x39, + 0xc1, 0x50, 0x5f, 0x9c, 0xdf, 0x12, 0xec, 0x57, 0x5d, 0x23, 0xb2, 0x3f, 0xad, 0x3e, 0x92, 0x6a, 0x3e, 0x7a, 0xe8, + 0xcb, 0x3c, 0xb8, 0x26, 0x63, 0x12, 0xfb, 0xfc, 0x18, 0x29, 0x95, 0xb2, 0x7c, 0xd1, 0xce, 0x80, 0x7a, 0xe6, 0x78, + 0x5a, 0xc1, 0xda, 0x35, 0xe8, 0x16, 0xfc, 0x69, 0x0e, 0x8b, 0xb2, 0xae, 0xd3, 0xdd, 0x48, 0x2e, 0xd7, 0xf8, 0xe6, + 0xb9, 0x8e, 0xb9, 0xfb, 0x03, 0x52, 0xae, 0x93, 0xb3, 0x80, 0x03, 0x89, 0x43, 0x2b, 0x1d, 0xe8, 0x57, 0xda, 0xa7, + 0x5c, 0xa3, 0xe7, 0x80, 0x80, 0xa0, 0x24, 0x32, 0x03, 0xbd, 0x68, 0x97, 0x16, 0xc2, 0xd7, 0x18, 0x57, 0x1e, 0x61, + 0x07, 0x20, 0xe5, 0xf7, 0x69, 0x5a, 0xea, 0xa1, 0x69, 0x49, 0x58, 0xd5, 0x6f, 0x7b, 0xe8, 0x82, 0x14, 0xa1, 0xa9, + 0xdd, 0xcb, 0xa3, 0xcc, 0x9a, 0xc6, 0xba, 0x9c, 0x1e, 0x8e, 0x02, 0x58, 0xa3, 0xbd, 0xc4, 0x56, 0xbb, 0xbe, 0x93, + 0xd5, 0x28, 0x29, 0x60, 0x28, 0x34, 0xba, 0x5f, 0xee, 0x59, 0x2e, 0xa6, 0x61, 0xf0, 0xa6, 0x2e, 0xe5, 0xd6, 0xaf, + 0x91, 0xaa, 0x6f, 0x85, 0xfe, 0xfe, 0x77, 0x81, 0xf6, 0x4b, 0x18, 0xc4, 0x1e, 0x67, 0xc7, 0x5e, 0x75, 0xd3, 0x25, + 0x8b, 0x17, 0x47, 0x40, 0xe4, 0xbd, 0x8c, 0x90, 0xe3, 0xbb, 0xd9, 0x50, 0x89, 0x1a, 0xf7, 0xa9, 0x7a, 0x36, 0x2f, + 0x76, 0x50, 0x86, 0x60, 0xbc, 0x6d, 0xa2, 0x61, 0x64, 0x91, 0xc1, 0xc9, 0x16, 0xad, 0xd5, 0x45, 0xa6, 0xab, 0x9a, + 0x59, 0xe9, 0x14, 0x5b, 0x72, 0x2e, 0x5a, 0x5e, 0x1c, 0x5b, 0x02, 0x17, 0xad, 0x2d, 0xc2, 0xb1, 0x6a, 0xdd, 0xb9, + 0x72, 0x67, 0x38, 0x89, 0xab, 0x05, 0x9b, 0xb2, 0x90, 0xe6, 0xc4, 0x9a, 0xf1, 0x15, 0x5a, 0x3b, 0x33, 0x9b, 0xb8, + 0x36, 0x2a, 0x8a, 0xaa, 0x53, 0xdb, 0xdc, 0x68, 0x5a, 0x06, 0x7a, 0xaa, 0x19, 0xcc, 0xc9, 0x88, 0xc1, 0x7f, 0x9a, + 0xef, 0x5a, 0x4e, 0x69, 0xd4, 0x5c, 0x4e, 0x3a, 0x1c, 0xee, 0x6c, 0xf0, 0x94, 0xdd, 0x27, 0xe0, 0xee, 0xc7, 0xc5, + 0x71, 0x26, 0x8a, 0x98, 0x33, 0x13, 0x34, 0xcf, 0x1b, 0x84, 0x3e, 0x33, 0xb0, 0xc5, 0x82, 0xae, 0x7b, 0xf3, 0xaa, + 0x6a, 0x21, 0x33, 0x31, 0x07, 0xb6, 0x46, 0x24, 0x1d, 0x9c, 0x6a, 0x03, 0x3b, 0x48, 0xd0, 0x48, 0xb0, 0x26, 0xee, + 0xf5, 0x59, 0x62, 0x09, 0xea, 0x00, 0x4d, 0x98, 0xa5, 0xb2, 0xc9, 0x31, 0x8a, 0x68, 0xdc, 0x84, 0x5d, 0x20, 0x1e, + 0x83, 0x2f, 0x05, 0xb6, 0x56, 0xbf, 0x38, 0xf0, 0x85, 0xda, 0xed, 0xe4, 0x8b, 0x73, 0xc2, 0x89, 0xd5, 0x77, 0x0b, + 0x4f, 0x4f, 0x36, 0xe7, 0x3c, 0x6f, 0x7f, 0xf4, 0xf9, 0x36, 0x96, 0x95, 0xc9, 0x16, 0x9f, 0x21, 0x2a, 0x08, 0x7f, + 0x3d, 0x00, 0xf8, 0xf5, 0xc5, 0xd3, 0xe7, 0x23, 0x42, 0x01, 0xb3, 0x90, 0x74, 0xce, 0x39, 0x8c, 0x43, 0x2e, 0x95, + 0x42, 0x21, 0xf0, 0xfd, 0x21, 0x24, 0xee, 0xbc, 0x00, 0x6d, 0x4b, 0x02, 0x85, 0xd1, 0x52, 0x78, 0xf4, 0xee, 0xa1, + 0x89, 0x87, 0xdd, 0xe7, 0x4a, 0x21, 0x4e, 0x2c, 0x71, 0x06, 0x62, 0x5a, 0x43, 0x86, 0xe5, 0xc4, 0xd6, 0xb1, 0x6d, + 0x0a, 0xb0, 0x78, 0x43, 0xb6, 0xc9, 0xe9, 0x6d, 0x22, 0xff, 0x9d, 0xdd, 0x64, 0x61, 0xeb, 0x52, 0x5f, 0xcf, 0x3a, + 0x49, 0x38, 0xda, 0xa1, 0x6a, 0xcc, 0x1f, 0x80, 0x7b, 0x75, 0xfa, 0xa7, 0x58, 0xe8, 0x24, 0x8b, 0x2a, 0xcd, 0x02, + 0xb5, 0x02, 0x1a, 0xfd, 0x26, 0x08, 0x1e, 0xf4, 0xb1, 0xbe, 0x6d, 0x52, 0x96, 0x99, 0x32, 0x09, 0x6c, 0x19, 0xc2, + 0x65, 0x0e, 0xb5, 0x4b, 0x9f, 0x35, 0xe3, 0xee, 0xfb, 0x3a, 0x7b, 0xdd, 0xf2, 0x6b, 0xa9, 0x8b, 0xd2, 0xb5, 0xe8, + 0x18, 0x84, 0x65, 0x6c, 0xab, 0xdb, 0xf9, 0xeb, 0x5d, 0xb4, 0x5e, 0xef, 0xd1, 0x4a, 0xce, 0x0d, 0xaa, 0x7a, 0x23, + 0x99, 0x7c, 0x8d, 0xa8, 0xa0, 0xfb, 0xba, 0x60, 0x52, 0xf3, 0xc4, 0x7b, 0x8b, 0x44, 0x13, 0x46, 0xe4, 0x9d, 0x23, + 0x1a, 0x75, 0x30, 0x86, 0x06, 0x39, 0x59, 0xe9, 0xd2, 0x6a, 0x72, 0xf7, 0x15, 0x1f, 0x52, 0x54, 0x34, 0xc7, 0x62, + 0x93, 0xda, 0xb1, 0x42, 0x10, 0x7b, 0xa1, 0xfc, 0x88, 0x34, 0x63, 0xe5, 0xd6, 0x80, 0x64, 0xfb, 0x48, 0x1d, 0x2c, + 0xdb, 0x10, 0x6a, 0x2e, 0x78, 0x24, 0xee, 0x60, 0x95, 0xf9, 0x0b, 0xb5, 0xd9, 0x95, 0xf9, 0x0e, 0xa8, 0xd9, 0x6c, + 0xb3, 0x75, 0x59, 0xf8, 0x4b, 0x6f, 0x10, 0xb5, 0x65, 0x40, 0xef, 0x45, 0x8f, 0x0d, 0x1b, 0xef, 0xf7, 0x64, 0x9b, + 0xe0, 0x1f, 0xd2, 0xb7, 0xcc, 0x7d, 0xab, 0xea, 0x2f, 0x2c, 0x71, 0x36, 0xaa, 0x6a, 0x1e, 0x70, 0xf5, 0x89, 0x41, + 0x54, 0xc8, 0x26, 0x74, 0xbd, 0x1f, 0x27, 0x77, 0x25, 0xeb, 0x8f, 0xa9, 0xb5, 0xb4, 0x46, 0xe4, 0x61, 0x44, 0x76, + 0x15, 0xf4, 0x55, 0x90, 0x08, 0x73, 0x77, 0x2f, 0x4e, 0x7f, 0x62, 0x09, 0x8a, 0x86, 0x2c, 0x57, 0xd7, 0xad, 0x95, + 0xf9, 0xcc, 0xbe, 0xf7, 0x33, 0xc3, 0x43, 0x2d, 0x4a, 0xd1, 0x85, 0xc4, 0x14, 0xcd, 0x56, 0x53, 0x28, 0xd4, 0x86, + 0xa5, 0xb6, 0x9d, 0x65, 0xef, 0xa4, 0xdb, 0xda, 0x7b, 0xf5, 0x17, 0x62, 0x37, 0x6f, 0x74, 0x15, 0x50, 0x46, 0xd7, + 0x00, 0x4a, 0xa3, 0x7f, 0xf7, 0x77, 0xf2, 0xe9, 0xa6, 0xbf, 0xdf, 0x85, 0x76, 0x9b, 0x09, 0x79, 0x44, 0xb1, 0xac, + 0xb2, 0x7e, 0x5d, 0xd1, 0xa9, 0x59, 0xe7, 0x58, 0xfe, 0xf1, 0x81, 0xd2, 0x5e, 0xb8, 0xd5, 0x66, 0x5a, 0x8f, 0x52, + 0xa2, 0xaa, 0xcb, 0x3b, 0x53, 0xe8, 0xfd, 0x29, 0x48, 0x99, 0x23, 0xfd, 0x8a, 0xfa, 0x75, 0x3c, 0x60, 0xec, 0x05, + 0x5d, 0xf8, 0x95, 0xb7, 0x4d, 0x82, 0xfd, 0xa4, 0x0e, 0x98, 0x42, 0x67, 0xac, 0x14, 0x30, 0x23, 0xe9, 0x7c, 0xb6, + 0x39, 0x80, 0xe5, 0x1a, 0xd8, 0x87, 0x21, 0xe0, 0x62, 0x67, 0x53, 0x19, 0xa3, 0x97, 0xb9, 0xe4, 0x38, 0xbd, 0xef, + 0x5f, 0xe4, 0x37, 0x7d, 0x31, 0x9e, 0x28, 0x6c, 0x35, 0x42, 0xad, 0x5d, 0xef, 0x88, 0xce, 0x18, 0x5e, 0xd5, 0xdb, + 0xc7, 0x90, 0x38, 0x34, 0x19, 0xef, 0x47, 0xf1, 0x88, 0x0a, 0x49, 0xfd, 0xca, 0xe9, 0x41, 0xf4, 0xa3, 0xc0, 0x70, + 0xfc, 0x2d, 0xd0, 0x23, 0x72, 0x81, 0x30, 0x05, 0xf3, 0x66, 0x07, 0x93, 0x54, 0x45, 0x56, 0x81, 0xd9, 0x4f, 0xe4, + 0x1c, 0xa5, 0xb6, 0xfd, 0x93, 0xa6, 0xf7, 0x09, 0x25, 0x6f, 0x93, 0x26, 0xeb, 0x45, 0x50, 0x69, 0x33, 0x16, 0x64, + 0x2f, 0xf3, 0x98, 0x05, 0x5c, 0x14, 0x21, 0xc1, 0x57, 0xb3, 0x33, 0x44, 0xd5, 0xcc, 0xdd, 0xcd, 0xfc, 0x95, 0x8d, + 0x08, 0xd3, 0x5f, 0x57, 0x28, 0xb4, 0x8a, 0x98, 0xe5, 0x1b, 0xf6, 0xc1, 0xfa, 0xcf, 0x42, 0x61, 0xd9, 0x60, 0x94, + 0xf4, 0x70, 0x69, 0x7b, 0x6c, 0xd9, 0x6e, 0xe1, 0x2b, 0x4b, 0x92, 0xf4, 0x39, 0x9e, 0x5a, 0xf1, 0x53, 0xb4, 0xe0, + 0x6d, 0xfc, 0xa9, 0x8a, 0xfe, 0x36, 0x74, 0x10, 0x1c, 0x10, 0x0c, 0x95, 0x9a, 0x6e, 0xa9, 0x08, 0x2a, 0x02, 0x43, + 0x74, 0x3a, 0x02, 0x6a, 0x9d, 0x3d, 0x10, 0x83, 0x08, 0xf7, 0x71, 0x7e, 0xc2, 0xdf, 0xf8, 0xf7, 0x2a, 0xcd, 0xb9, + 0x96, 0xb2, 0x0a, 0xba, 0x84, 0x54, 0xb8, 0xec, 0xc0, 0xd7, 0xb2, 0xf7, 0xf5, 0x59, 0xf3, 0xa3, 0x0f, 0xed, 0x53, + 0x19, 0xb0, 0x3c, 0x2c, 0xa4, 0x5b, 0xf6, 0x9b, 0x14, 0x4e, 0x58, 0xdb, 0x86, 0xb9, 0xfb, 0x34, 0x33, 0xc3, 0x05, + 0x30, 0xe7, 0x39, 0x20, 0x0e, 0xbf, 0x4d, 0x4e, 0x99, 0xdc, 0x2d, 0x6f, 0xf4, 0xcb, 0xd9, 0x70, 0x07, 0x50, 0xd8, + 0x1f, 0x02, 0xbd, 0x54, 0x75, 0x39, 0x1e, 0xc9, 0x9a, 0xec, 0xbb, 0x0e, 0x5a, 0xb6, 0x33, 0x15, 0x54, 0xee, 0xda, + 0x3f, 0x49, 0x18, 0x85, 0x20, 0x4e, 0x7b, 0x29, 0x41, 0xea, 0x8c, 0x4b, 0x1f, 0xac, 0x8a, 0x04, 0xeb, 0xb4, 0x96, + 0xbf, 0xe1, 0x69, 0x4b, 0xd5, 0x2c, 0x64, 0x65, 0x70, 0x5b, 0x0a, 0xbb, 0x21, 0x19, 0x27, 0xf5, 0x19, 0x77, 0x8b, + 0xf3, 0xc6, 0xe2, 0x88, 0xc9, 0xc7, 0x10, 0x6b, 0x46, 0xcb, 0x82, 0x1a, 0x9b, 0xeb, 0xab, 0xe3, 0x58, 0x26, 0xdb, + 0xd0, 0x95, 0x98, 0x18, 0x9e, 0xd3, 0x98, 0x0f, 0x3b, 0xf4, 0x38, 0x2a, 0x98, 0x6b, 0xe0, 0xf5, 0xd4, 0x17, 0xeb, + 0xb3, 0x5f, 0xff, 0x1d, 0x3c, 0x6d, 0x89, 0xf1, 0xb4, 0xcf, 0x68, 0x76, 0x16, 0x13, 0xe0, 0xbc, 0xb0, 0x2e, 0x0e, + 0x01, 0x05, 0x18, 0xad, 0x5f, 0xa3, 0x69, 0x43, 0x9e, 0xcd, 0x50, 0x4a, 0xf8, 0x52, 0xe5, 0x92, 0x5d, 0xa7, 0xce, + 0xcf, 0x83, 0xb3, 0x83, 0x22, 0xbd, 0x4e, 0x58, 0x80, 0xe1, 0x79, 0x11, 0x23, 0x69, 0x52, 0xa8, 0x36, 0xb4, 0xa9, + 0x6e, 0x4b, 0xff, 0xe2, 0xf8, 0xd2, 0xf6, 0x6e, 0xa4, 0x43, 0xb1, 0xf1, 0xc0, 0xac, 0x5b, 0x78, 0x09, 0x31, 0xec, + 0xfa, 0x1e, 0x76, 0x18, 0xf9, 0x8b, 0x77, 0x4c, 0xc7, 0x37, 0xbd, 0x70, 0xc2, 0x9a, 0xff, 0xa4, 0xa7, 0xe4, 0xa8, + 0xbd, 0x74, 0xd4, 0x4e, 0x3d, 0x5c, 0x1c, 0x5f, 0xbe, 0xae, 0xc3, 0xf6, 0x9f, 0x54, 0x87, 0x6d, 0x34, 0xfa, 0xc3, + 0x6f, 0xa5, 0x37, 0xbf, 0x07, 0x00, 0x99, 0xe2, 0xcf, 0x48, 0xda, 0xf8, 0xef, 0x12, 0x85, 0x97, 0x69, 0x8b, 0x9c, + 0xae, 0x67, 0x43, 0xb3, 0xbd, 0x0d, 0x49, 0x40, 0x77, 0x3c, 0xbd, 0x0e, 0x63, 0xa1, 0xa8, 0x77, 0x39, 0x77, 0x98, + 0xd2, 0x97, 0x9a, 0x33, 0xa3, 0x02, 0xc7, 0xfb, 0x49, 0xec, 0x09, 0x95, 0x1c, 0xa7, 0xd5, 0xac, 0x72, 0x41, 0x14, + 0x0d, 0x43, 0x20, 0x71, 0x71, 0x83, 0xff, 0x7a, 0x00, 0xc1, 0xcf, 0xbf, 0x4c, 0x01, 0x46, 0xdc, 0x92, 0x09, 0x12, + 0x8d, 0x08, 0x80, 0xfe, 0x06, 0xfc, 0x32, 0x90, 0xc4, 0x95, 0x2e, 0x9a, 0xa4, 0x16, 0x14, 0x6a, 0x6e, 0xcf, 0xe8, + 0xb2, 0x8f, 0x57, 0xe0, 0x2c, 0xb4, 0x7f, 0x08, 0xbd, 0xec, 0xc7, 0x3c, 0x46, 0x72, 0xd5, 0x7a, 0x2d, 0xf8, 0x71, + 0x31, 0x5b, 0xf0, 0xfd, 0xfb, 0xbc, 0x60, 0x14, 0x56, 0x95, 0xc5, 0x48, 0xd1, 0x57, 0xfe, 0xd6, 0xe7, 0x58, 0x9b, + 0xd9, 0x98, 0xc9, 0xc2, 0x55, 0xeb, 0x72, 0x65, 0xf2, 0x5a, 0xfa, 0x69, 0x9d, 0x94, 0x8d, 0x7a, 0x63, 0x07, 0xaa, + 0x10, 0xce, 0xd9, 0x12, 0x88, 0x30, 0xff, 0x0f, 0x45, 0xa9, 0x46, 0x8e, 0xf1, 0x92, 0x9f, 0xb9, 0xae, 0x1d, 0xf0, + 0x97, 0xb6, 0x3f, 0x53, 0xb9, 0x4f, 0x89, 0x2e, 0xf8, 0x55, 0xf8, 0x39, 0xff, 0x3c, 0x5a, 0x67, 0x86, 0x8f, 0x4f, + 0x6f, 0x9e, 0x4e, 0x12, 0x93, 0xc1, 0x88, 0xeb, 0x96, 0x8e, 0xc2, 0x1e, 0x5e, 0xb3, 0x01, 0x0e, 0x81, 0x98, 0x03, + 0x1d, 0xe8, 0x4e, 0xfc, 0xfa, 0x3e, 0xfc, 0xd2, 0x87, 0x9a, 0xf4, 0x1f, 0x54, 0xd1, 0xd3, 0x49, 0xdf, 0x2f, 0x44, + 0xfe, 0x2e, 0xf9, 0x1a, 0xdc, 0x49, 0x52, 0xde, 0x19, 0xe3, 0x9e, 0xda, 0x99, 0x0d, 0x53, 0x07, 0xeb, 0xcd, 0x28, + 0xa9, 0xb0, 0xfe, 0xa2, 0x0f, 0xe5, 0xdf, 0x08, 0xae, 0xb4, 0x99, 0x5e, 0x01, 0x34, 0x9f, 0x3c, 0xa2, 0xfc, 0xad, + 0x77, 0x91, 0xac, 0x02, 0xf3, 0x24, 0x92, 0xbc, 0xfb, 0x42, 0xb1, 0x56, 0x2b, 0x34, 0x8d, 0x0d, 0xdc, 0xe7, 0x15, + 0x9e, 0xa2, 0x60, 0xef, 0x89, 0xea, 0x4d, 0xa2, 0xa7, 0x58, 0xc3, 0xe4, 0x57, 0xc0, 0xc6, 0xa6, 0x80, 0x42, 0x17, + 0x75, 0xde, 0x55, 0xf8, 0x11, 0x3d, 0x71, 0x19, 0x22, 0x70, 0x3c, 0x0d, 0x77, 0x2e, 0x3e, 0x91, 0x9e, 0x05, 0xcd, + 0x1f, 0xe1, 0xa9, 0xfc, 0xdb, 0x94, 0xc3, 0x7a, 0x19, 0x21, 0xbd, 0x70, 0x83, 0x83, 0x30, 0x94, 0xd3, 0x8e, 0xd3, + 0x55, 0x90, 0x70, 0x00, 0xe7, 0x02, 0xc8, 0x2a, 0xa1, 0x2a, 0xaf, 0xa1, 0xc0, 0x39, 0xa3, 0xf2, 0x4a, 0x7e, 0x2d, + 0x5b, 0x59, 0x2b, 0x88, 0xe9, 0x66, 0x0e, 0x1b, 0xcc, 0x27, 0x35, 0x71, 0x06, 0xd7, 0xc2, 0x7b, 0x51, 0xbd, 0xf3, + 0x06, 0x07, 0x6e, 0x4f, 0xbe, 0x0a, 0x09, 0xc1, 0x1b, 0xdd, 0x63, 0x0b, 0xc3, 0x8c, 0x5d, 0xdb, 0xc3, 0x70, 0x29, + 0x1a, 0x8e, 0x59, 0x54, 0x77, 0x6f, 0x2d, 0xa5, 0x56, 0x3b, 0xa5, 0xf6, 0xa1, 0x2f, 0x10, 0xb7, 0x3f, 0x46, 0x8f, + 0x80, 0x7e, 0x98, 0x9a, 0x4f, 0x88, 0x04, 0x71, 0xfd, 0xd1, 0xcb, 0xf7, 0x92, 0x84, 0xfe, 0x64, 0x26, 0xa9, 0x28, + 0xf1, 0x8e, 0x88, 0x74, 0x2b, 0xe8, 0x08, 0xa5, 0xb9, 0x77, 0x3a, 0xdf, 0x86, 0xae, 0x65, 0x74, 0xe7, 0xa5, 0xe9, + 0xa6, 0x1b, 0x13, 0x9d, 0x70, 0x04, 0x1c, 0x27, 0xd2, 0xba, 0x9d, 0xc2, 0x26, 0xb3, 0x64, 0x7d, 0xf8, 0xe8, 0xbe, + 0x03, 0x52, 0xb7, 0xff, 0xa8, 0xaf, 0xc4, 0x29, 0xe7, 0x31, 0x16, 0x2b, 0x73, 0x9e, 0x26, 0xe9, 0x86, 0xc9, 0x80, + 0xd5, 0x57, 0xab, 0x54, 0x0e, 0x13, 0x16, 0x07, 0x7b, 0x08, 0xe5, 0xeb, 0x54, 0x07, 0x53, 0x07, 0xd7, 0xdb, 0xa2, + 0x85, 0x6f, 0x66, 0x53, 0x06, 0x8b, 0x63, 0x1b, 0x5a, 0x54, 0xca, 0x6f, 0x67, 0x31, 0x65, 0x96, 0xdb, 0x18, 0x95, + 0x20, 0xfc, 0x52, 0x98, 0x6c, 0xba, 0x6b, 0x15, 0x14, 0x85, 0x1c, 0x94, 0x26, 0x7c, 0x4c, 0x62, 0x83, 0x48, 0x26, + 0x16, 0x93, 0x03, 0x78, 0x27, 0x26, 0x59, 0xed, 0x38, 0x5a, 0x01, 0xe0, 0x29, 0x53, 0x72, 0x51, 0xe5, 0x2b, 0x6f, + 0x24, 0xb0, 0xde, 0x7c, 0xe8, 0x05, 0x28, 0x23, 0x7a, 0x3d, 0x2d, 0xe1, 0xf3, 0x96, 0xf1, 0x5d, 0x68, 0x46, 0xd3, + 0xc0, 0x33, 0xbf, 0xf6, 0x33, 0x0a, 0x94, 0x3f, 0x75, 0x66, 0x32, 0x23, 0xd3, 0x0d, 0xb1, 0x8e, 0x6e, 0x4b, 0x3f, + 0x2e, 0x4d, 0xe4, 0x3e, 0xc9, 0xda, 0x98, 0x3a, 0x94, 0x05, 0xe6, 0xc4, 0x56, 0x16, 0x6e, 0x53, 0x61, 0x03, 0x5d, + 0x67, 0x24, 0x96, 0x6a, 0x62, 0x84, 0x2e, 0xba, 0x52, 0x28, 0x08, 0x60, 0xbc, 0x12, 0xc3, 0xdd, 0xbe, 0x77, 0x82, + 0xc1, 0x98, 0xb0, 0xd2, 0xec, 0x77, 0xa2, 0x6c, 0x4d, 0xc1, 0x42, 0x37, 0x2e, 0x6f, 0x63, 0x2a, 0x26, 0x44, 0xb9, + 0xe4, 0xb0, 0x0d, 0x91, 0x5a, 0xde, 0x02, 0x7f, 0x8d, 0x98, 0xc1, 0x98, 0xaa, 0x47, 0x33, 0xda, 0x11, 0x78, 0xf6, + 0x94, 0x3a, 0x39, 0xf2, 0x45, 0xf2, 0xc1, 0x88, 0xc9, 0x43, 0xc4, 0x59, 0xa1, 0x5d, 0x9a, 0xda, 0x1b, 0x6d, 0xd1, + 0x30, 0x10, 0x0d, 0x87, 0x68, 0xc4, 0xbf, 0x21, 0x20, 0x32, 0x38, 0x3b, 0x7c, 0x32, 0xa9, 0xe4, 0x49, 0x00, 0x26, + 0x30, 0xef, 0x43, 0x26, 0x53, 0x1a, 0x4c, 0x44, 0xcc, 0xcc, 0x88, 0x68, 0xbb, 0x68, 0x40, 0x66, 0x70, 0x02, 0xc4, + 0x11, 0xf0, 0x1b, 0x7c, 0xc2, 0x54, 0xa7, 0xba, 0x10, 0x24, 0x09, 0x40, 0xde, 0x23, 0xf1, 0x0d, 0x77, 0xd8, 0x65, + 0xc1, 0x0f, 0x91, 0x61, 0xd2, 0x70, 0x29, 0x1b, 0x11, 0x8e, 0x99, 0x58, 0x1f, 0x11, 0xd2, 0x1b, 0x5a, 0x89, 0x53, + 0x55, 0x6b, 0x38, 0x9d, 0x47, 0xc3, 0xb3, 0x5a, 0x6c, 0x99, 0xf4, 0xdc, 0x2c, 0x0e, 0x71, 0xe5, 0xed, 0x12, 0xc8, + 0x6e, 0x38, 0xcb, 0x9f, 0xd3, 0xf6, 0xd8, 0x6e, 0x95, 0x83, 0x23, 0xf6, 0x70, 0x68, 0x02, 0xfa, 0x4a, 0xe9, 0xd5, + 0xa7, 0x64, 0xf0, 0xad, 0x69, 0x87, 0x3b, 0x88, 0x40, 0x41, 0x83, 0xf4, 0x90, 0x93, 0x48, 0x5b, 0x29, 0x64, 0x5f, + 0xa8, 0xb6, 0x3a, 0x21, 0xec, 0xca, 0x1a, 0x62, 0xb9, 0x9c, 0xd1, 0xb7, 0x35, 0xc2, 0x21, 0x62, 0x92, 0x9f, 0xb3, + 0x85, 0x35, 0x20, 0x46, 0x51, 0xb8, 0x99, 0x3b, 0xa9, 0xbf, 0x61, 0x44, 0x5c, 0x53, 0xb6, 0xee, 0x64, 0xbc, 0x4e, + 0xf0, 0x88, 0x17, 0x3d, 0x68, 0x08, 0xd6, 0xed, 0x40, 0x54, 0xc0, 0x2e, 0x97, 0xed, 0x1c, 0xe6, 0x45, 0xf2, 0x04, + 0x0e, 0xa8, 0x3a, 0x08, 0x18, 0x81, 0x6c, 0x5a, 0xb8, 0x7c, 0x5e, 0x47, 0x6b, 0xf9, 0x41, 0x0e, 0xc0, 0xb1, 0x1f, + 0x8a, 0xfa, 0x1c, 0x44, 0x3c, 0x39, 0xf4, 0x7b, 0x27, 0x10, 0x5c, 0x21, 0x39, 0x55, 0x95, 0xfe, 0x70, 0xf7, 0x23, + 0x1c, 0x5a, 0xa0, 0x7a, 0xea, 0x4d, 0xee, 0xa7, 0x29, 0x27, 0xff, 0xd3, 0x54, 0x3b, 0xbb, 0x77, 0x8f, 0x91, 0x5e, + 0x90, 0x9a, 0xed, 0x78, 0xe7, 0xb0, 0xec, 0x53, 0xd1, 0x29, 0x39, 0x24, 0x57, 0x61, 0xb3, 0x3d, 0x58, 0x61, 0x91, + 0x1c, 0x37, 0xb6, 0xb9, 0x2c, 0x63, 0x43, 0x72, 0xf1, 0x40, 0xa1, 0x3f, 0x46, 0x2f, 0x00, 0xb9, 0x62, 0xa3, 0x13, + 0xde, 0xfb, 0x0a, 0x2e, 0xde, 0xd2, 0x3e, 0xe0, 0xa6, 0xff, 0x98, 0x44, 0x78, 0x37, 0x2a, 0xcf, 0x72, 0xc3, 0xa6, + 0x7d, 0x8a, 0x88, 0x65, 0x62, 0x59, 0x5b, 0x10, 0x42, 0x32, 0x41, 0xd7, 0xb8, 0x30, 0x26, 0x7e, 0x14, 0x90, 0x3d, + 0x66, 0x25, 0xf9, 0x6f, 0x0a, 0x4f, 0x8c, 0x40, 0xf8, 0xf0, 0x69, 0xd2, 0xdb, 0x9d, 0x98, 0x86, 0x52, 0x60, 0xa0, + 0x71, 0xd3, 0xf4, 0x3a, 0x16, 0x63, 0xda, 0x95, 0x31, 0x19, 0x3c, 0xb2, 0x06, 0xfa, 0x76, 0xb3, 0xde, 0x33, 0xea, + 0x30, 0xa3, 0x72, 0x3e, 0x65, 0x62, 0x0c, 0x83, 0xb5, 0x59, 0x60, 0xab, 0x0a, 0xbf, 0xa8, 0xb1, 0x13, 0xc7, 0x89, + 0xda, 0xd6, 0xc0, 0x90, 0x27, 0x72, 0x1d, 0x99, 0x98, 0x4d, 0x9b, 0x5d, 0x5a, 0x53, 0xac, 0x78, 0x13, 0xe0, 0x1a, + 0x8f, 0x0f, 0xef, 0x1c, 0x25, 0x5d, 0xc1, 0xd5, 0xbd, 0xfc, 0xe9, 0x78, 0x9b, 0x6e, 0x87, 0x46, 0xaa, 0x0c, 0xb3, + 0xeb, 0xfb, 0xe4, 0xff, 0x08, 0xd7, 0xa0, 0x40, 0x83, 0xb6, 0x13, 0x54, 0x90, 0xb7, 0x55, 0xb8, 0x9d, 0xef, 0x80, + 0x4e, 0xc2, 0x26, 0x91, 0xc9, 0x69, 0x88, 0x83, 0x6c, 0xa5, 0xee, 0x56, 0x6f, 0x5b, 0x74, 0x83, 0xe6, 0xb3, 0x43, + 0xb0, 0x3e, 0x0b, 0x0a, 0xa7, 0x05, 0x2f, 0x28, 0x14, 0xbe, 0xd0, 0x1a, 0x23, 0xcd, 0x3b, 0x85, 0x56, 0xa3, 0xec, + 0xb0, 0x97, 0x16, 0xc0, 0xdb, 0x25, 0xbc, 0x66, 0x08, 0x07, 0xfa, 0x19, 0xb1, 0x85, 0x52, 0x42, 0x3d, 0xd9, 0x62, + 0xcc, 0x69, 0x71, 0xa3, 0x0a, 0xfd, 0x8d, 0x67, 0x07, 0xbc, 0x65, 0xe6, 0x94, 0x92, 0x4c, 0xec, 0x9f, 0x0c, 0x17, + 0x53, 0x07, 0x86, 0xd3, 0x72, 0xb3, 0xc4, 0xc5, 0xdc, 0x21, 0x27, 0x45, 0x4b, 0x22, 0xb4, 0xb9, 0x42, 0x7a, 0x13, + 0x7c, 0xf2, 0x55, 0x76, 0xdf, 0x3a, 0x01, 0xc7, 0x8b, 0xe9, 0x33, 0x76, 0x87, 0xf7, 0x99, 0x91, 0x65, 0x99, 0x79, + 0x5f, 0x40, 0x8d, 0x42, 0x2b, 0xd4, 0x19, 0x92, 0x23, 0x30, 0x59, 0xd3, 0x3e, 0xf5, 0xad, 0x89, 0xcd, 0xc4, 0x88, + 0x4c, 0xa1, 0x46, 0xcb, 0x84, 0xa9, 0x4e, 0xa8, 0xce, 0x31, 0xfa, 0xcd, 0x3e, 0x89, 0xfe, 0xf7, 0x00, 0x91, 0x01, + 0xd8, 0xdb, 0xc9, 0x43, 0x8e, 0x34, 0x4d, 0x47, 0x88, 0x86, 0xe5, 0xad, 0x28, 0x95, 0x47, 0xbf, 0x14, 0x02, 0xda, + 0xc9, 0x11, 0xdb, 0x46, 0xe9, 0xaa, 0x38, 0x7b, 0x65, 0x6d, 0xcc, 0x82, 0xfc, 0xde, 0x7e, 0xe7, 0x08, 0x25, 0x14, + 0xae, 0x12, 0x06, 0xfd, 0x01, 0xf2, 0xa0, 0x37, 0xfc, 0x02, 0x26, 0x1f, 0x8c, 0x6d, 0x31, 0x5b, 0x8a, 0xe9, 0x87, + 0xee, 0x49, 0x26, 0x69, 0x8c, 0x0f, 0x15, 0x01, 0x83, 0x41, 0x2d, 0xe7, 0x7d, 0xa0, 0x1b, 0xc3, 0xa4, 0x57, 0xac, + 0x24, 0x97, 0xbc, 0x5f, 0x55, 0x4e, 0xba, 0xc4, 0x89, 0x0c, 0x9b, 0x5a, 0x0c, 0xbd, 0x5b, 0xf1, 0x49, 0xa8, 0x4a, + 0xdb, 0x65, 0xe2, 0xb7, 0x8c, 0x54, 0xe0, 0xfe, 0x4a, 0x99, 0x7f, 0x8e, 0x13, 0xaf, 0x14, 0x4b, 0x1b, 0x0a, 0x91, + 0x34, 0xe8, 0x3d, 0x4c, 0x13, 0x19, 0x6c, 0x29, 0xac, 0x83, 0x60, 0x3f, 0x70, 0x3a, 0xeb, 0xe2, 0xe0, 0x5d, 0xc9, + 0x64, 0x7e, 0x64, 0x86, 0x46, 0xfc, 0xcf, 0x5a, 0xe8, 0x12, 0xdb, 0x68, 0x2f, 0x08, 0x6a, 0x56, 0x24, 0x90, 0x16, + 0xa0, 0xdc, 0xdc, 0x52, 0x60, 0xd2, 0x4e, 0x98, 0x71, 0x02, 0x24, 0xa8, 0xb0, 0x69, 0x39, 0x05, 0x9c, 0xbf, 0xe6, + 0xde, 0x2e, 0x99, 0x9e, 0xb7, 0x51, 0x10, 0xfa, 0xcb, 0xd0, 0xbf, 0xab, 0xfa, 0x2f, 0x63, 0xff, 0x9e, 0xbc, 0x7f, + 0x4f, 0xd6, 0xbf, 0x6b, 0xec, 0xdf, 0x2d, 0xf5, 0xef, 0xd2, 0xf4, 0xef, 0x5a, 0xf5, 0xef, 0x52, 0xf7, 0xfd, 0x97, + 0xbd, 0xd8, 0xf3, 0xfb, 0x30, 0xee, 0x73, 0x27, 0xbd, 0xdc, 0xb4, 0xbe, 0xe8, 0x3f, 0x1f, 0x30, 0xef, 0xa9, 0xfc, + 0xda, 0xa7, 0x62, 0x99, 0xac, 0x6b, 0x9a, 0x03, 0xca, 0x7b, 0x82, 0x60, 0xb2, 0x8d, 0xcb, 0x75, 0xaa, 0x02, 0xb6, + 0x90, 0xb7, 0xe9, 0xa3, 0xed, 0x19, 0xb5, 0xa9, 0x99, 0x48, 0xc5, 0xce, 0x7e, 0xad, 0x8a, 0x78, 0x66, 0xa6, 0xbd, + 0x04, 0x90, 0x31, 0x5e, 0x51, 0xa6, 0x10, 0x79, 0xf6, 0x88, 0x7e, 0xa2, 0x8a, 0xa8, 0x88, 0x82, 0xa1, 0xcd, 0x0d, + 0x6f, 0xab, 0x1a, 0xa3, 0x45, 0x62, 0xb1, 0xa3, 0x52, 0xd6, 0xf4, 0xa1, 0xde, 0xdb, 0xaf, 0xcd, 0x6d, 0x77, 0x82, + 0xb0, 0xd3, 0xc5, 0xc0, 0x2f, 0x91, 0x65, 0xc0, 0x40, 0x94, 0xde, 0x43, 0xb0, 0x2f, 0x6d, 0x65, 0x1e, 0x05, 0x93, + 0x90, 0x2b, 0xe0, 0xb7, 0x42, 0xa5, 0x4e, 0x20, 0x7e, 0x27, 0xde, 0xce, 0xa3, 0xde, 0x0b, 0x30, 0x58, 0xdf, 0xb6, + 0x78, 0x1e, 0xfd, 0x7b, 0x9d, 0xd1, 0x92, 0xe6, 0x12, 0x20, 0x69, 0x06, 0xae, 0xd4, 0x14, 0x94, 0x1a, 0x73, 0x2a, + 0xcd, 0xca, 0x4a, 0x54, 0xbd, 0x62, 0x2f, 0xee, 0x89, 0x16, 0xa3, 0x3f, 0x0a, 0x5d, 0x4b, 0x16, 0xc7, 0xec, 0xcc, + 0x3a, 0x8c, 0xd5, 0x04, 0x74, 0xf7, 0x16, 0x06, 0x0a, 0x41, 0x51, 0x80, 0x0e, 0x70, 0x81, 0x28, 0xe5, 0x91, 0x26, + 0xc0, 0xdc, 0xa3, 0x02, 0x78, 0x2e, 0x4d, 0x1e, 0x63, 0x70, 0x4b, 0xa6, 0xea, 0x32, 0x2a, 0x93, 0xc6, 0x3b, 0x1c, + 0x3f, 0x1d, 0x05, 0x6f, 0xf0, 0x83, 0x3a, 0xff, 0xfd, 0x0e, 0x2f, 0x9d, 0xff, 0xe4, 0xec, 0x97, 0xf2, 0x1b, 0xda, + 0xf9, 0x94, 0x2f, 0xcd, 0xe2, 0x41, 0x80, 0xbe, 0xd7, 0x44, 0x49, 0x1f, 0x89, 0x13, 0x87, 0x1d, 0x63, 0x59, 0x3a, + 0xea, 0x89, 0xb7, 0x4c, 0x29, 0x73, 0xac, 0x0c, 0x5c, 0x1c, 0x1f, 0xdb, 0xb6, 0x9f, 0x8e, 0xd1, 0x74, 0xd0, 0x5a, + 0x2e, 0x85, 0x87, 0x2a, 0x0a, 0x6a, 0x6c, 0xfa, 0x7e, 0xe0, 0x16, 0x19, 0xc6, 0x90, 0xe5, 0xf3, 0x31, 0x42, 0xdb, + 0x89, 0x99, 0xe4, 0x0d, 0x3e, 0xf8, 0x76, 0x97, 0x17, 0x0c, 0xde, 0xff, 0x70, 0x98, 0xac, 0xf8, 0x46, 0x4e, 0xb6, + 0x20, 0x35, 0xda, 0xf7, 0xbd, 0x0a, 0xf1, 0x3f, 0xdc, 0xda, 0x47, 0xb0, 0xc5, 0x2e, 0x69, 0x3a, 0xdf, 0x00, 0x40, + 0x09, 0xa4, 0xee, 0xca, 0x83, 0xab, 0xf8, 0x5a, 0x44, 0x7a, 0x32, 0x2f, 0x48, 0x09, 0x01, 0x41, 0x75, 0x2a, 0xdd, + 0x76, 0xc9, 0xb8, 0xcc, 0xac, 0x49, 0x8e, 0xb5, 0x30, 0xc7, 0xb4, 0x1c, 0x2c, 0x84, 0xc4, 0x06, 0x83, 0x14, 0x7b, + 0xb2, 0x17, 0x5d, 0xe0, 0xb2, 0xe4, 0x17, 0x70, 0xe6, 0x6b, 0x85, 0xc0, 0x40, 0xfc, 0xb8, 0x18, 0x48, 0xc8, 0xca, + 0xcb, 0x98, 0xaa, 0x77, 0xd7, 0x5e, 0xc5, 0x2e, 0x6f, 0xfd, 0x92, 0x1b, 0xbb, 0xdd, 0x96, 0x95, 0xe6, 0x46, 0x8d, + 0xc6, 0xec, 0x24, 0xa4, 0x05, 0x50, 0x8c, 0xbf, 0xb2, 0xdf, 0x95, 0x72, 0xe8, 0xbd, 0x23, 0x50, 0x91, 0x7d, 0x64, + 0xa3, 0x70, 0xdb, 0x23, 0x30, 0x7b, 0x84, 0xeb, 0x6c, 0x25, 0xbc, 0x51, 0x1d, 0x4c, 0x7c, 0x17, 0xa6, 0x8e, 0x30, + 0x4a, 0xd3, 0x93, 0x3e, 0x54, 0xaa, 0x41, 0xc8, 0xc3, 0xb3, 0xa9, 0x91, 0x55, 0x88, 0x44, 0x44, 0x45, 0x6b, 0x44, + 0xf1, 0x37, 0xf6, 0x82, 0x8f, 0x44, 0xb2, 0xe7, 0x69, 0xe1, 0x25, 0xe4, 0xf0, 0x21, 0xcf, 0x72, 0xcd, 0x9a, 0x76, + 0x9b, 0x44, 0x34, 0x4a, 0x4b, 0x65, 0xbc, 0xd1, 0x81, 0x01, 0xf3, 0x5a, 0xba, 0x6e, 0xcc, 0x76, 0x5d, 0x2e, 0x0a, + 0xcc, 0xf4, 0x73, 0x63, 0xf5, 0xd2, 0xa1, 0x08, 0x97, 0x44, 0x3f, 0xe3, 0xa6, 0x9c, 0xf9, 0x6d, 0xf2, 0x81, 0xd8, + 0xe8, 0xa4, 0x42, 0x96, 0x89, 0xea, 0xe6, 0xfe, 0x21, 0x1a, 0x62, 0x19, 0xd8, 0xf4, 0x10, 0xfd, 0xda, 0xf5, 0xe1, + 0xb2, 0x83, 0x04, 0xed, 0x87, 0xae, 0xe9, 0x71, 0xe1, 0xfd, 0xf6, 0xb5, 0x20, 0x46, 0x3c, 0x26, 0x73, 0x96, 0x3e, + 0x76, 0xab, 0x08, 0x8c, 0xbe, 0xfb, 0x58, 0x0f, 0xf3, 0x37, 0x58, 0x69, 0x95, 0x3e, 0xec, 0xb4, 0x54, 0x2f, 0x24, + 0xc6, 0x79, 0x9c, 0xb8, 0x16, 0xca, 0x81, 0xf3, 0x59, 0x62, 0x09, 0x6e, 0x23, 0xdb, 0xe6, 0xa1, 0x12, 0x96, 0xfa, + 0xd0, 0x20, 0xd4, 0xea, 0x11, 0x3c, 0x21, 0xa1, 0x55, 0xa8, 0x4f, 0x8f, 0x73, 0x35, 0xcf, 0x6f, 0x39, 0x04, 0x0e, + 0xe2, 0x07, 0x1d, 0x22, 0xf9, 0xa0, 0x4e, 0x53, 0x4f, 0xa2, 0x62, 0x78, 0x91, 0xff, 0xd8, 0x2e, 0x66, 0x40, 0x23, + 0x53, 0xba, 0x8a, 0x74, 0xcf, 0x09, 0x81, 0x93, 0x49, 0xa1, 0x74, 0x98, 0x51, 0x63, 0x16, 0x33, 0xa0, 0xb2, 0x10, + 0x33, 0xc2, 0x2d, 0x00, 0x39, 0x75, 0x2e, 0x33, 0xcf, 0x84, 0x8d, 0x39, 0xbc, 0x3d, 0x73, 0x5a, 0x4b, 0xc6, 0xbf, + 0x7d, 0x7b, 0x70, 0x7d, 0x79, 0xfd, 0xcf, 0xed, 0x7c, 0x3f, 0x67, 0x1c, 0x82, 0xab, 0x7d, 0xbd, 0x88, 0x14, 0x53, + 0xe5, 0xfc, 0x53, 0x7c, 0xd7, 0xb1, 0xc7, 0xa3, 0x8d, 0x2c, 0xb6, 0xfd, 0x98, 0x40, 0x0f, 0x0a, 0x86, 0x01, 0x95, + 0xfc, 0x19, 0x04, 0xc3, 0x1b, 0xdb, 0x0e, 0xfd, 0xe0, 0x43, 0xb7, 0x13, 0x8e, 0x77, 0xad, 0x61, 0x2d, 0x5a, 0x9f, + 0x07, 0x87, 0x4e, 0x18, 0xf5, 0x29, 0x23, 0x87, 0x43, 0x2f, 0xd7, 0x73, 0x40, 0x83, 0x1e, 0x23, 0x85, 0xbc, 0x14, + 0xd9, 0x1e, 0x89, 0x2e, 0x3f, 0x30, 0x9f, 0x55, 0xba, 0xff, 0x95, 0x44, 0xd7, 0x5d, 0x85, 0xc5, 0xde, 0x4d, 0xf4, + 0xea, 0xa2, 0x92, 0x60, 0x54, 0xc3, 0x3f, 0xc1, 0xb2, 0xd5, 0x50, 0x0f, 0xbe, 0x2c, 0xdd, 0x1e, 0x65, 0x0c, 0x2d, + 0x5d, 0xc1, 0x87, 0x5e, 0x64, 0x77, 0xe2, 0x49, 0xf3, 0x15, 0x29, 0xdb, 0xbe, 0x28, 0xa1, 0x3e, 0xfa, 0x97, 0x54, + 0x61, 0xf4, 0xaf, 0x21, 0xfa, 0x7b, 0x31, 0x8e, 0x78, 0xce, 0x36, 0x72, 0x84, 0xb9, 0xe4, 0x46, 0x13, 0x41, 0x76, + 0x85, 0x52, 0x83, 0x2c, 0xb1, 0x79, 0x29, 0xe4, 0x6f, 0x4f, 0xd3, 0x36, 0x09, 0xa6, 0x1a, 0x2d, 0xd4, 0x15, 0xf7, + 0xac, 0x12, 0xa9, 0xc4, 0x41, 0x12, 0xcd, 0x75, 0x90, 0x60, 0xdb, 0x8e, 0xb2, 0x56, 0xfb, 0xe6, 0x64, 0xdd, 0xbb, + 0x49, 0x00, 0xb3, 0xc4, 0x5b, 0xee, 0xd3, 0xbf, 0x04, 0x4c, 0xcb, 0xe4, 0x5b, 0xf7, 0x07, 0xe2, 0x4c, 0x66, 0x28, + 0xd6, 0x1a, 0x91, 0x37, 0xec, 0x7a, 0xb3, 0xbf, 0xc1, 0x74, 0xcc, 0xd2, 0x93, 0x4b, 0x94, 0x16, 0x12, 0x65, 0xf4, + 0xb8, 0xe9, 0x01, 0xed, 0x40, 0x08, 0x65, 0x4b, 0xad, 0xe9, 0xab, 0xb2, 0x65, 0x2c, 0xae, 0xa8, 0xbf, 0xd8, 0xf6, + 0x98, 0x47, 0x0f, 0x5b, 0xa6, 0xe5, 0x98, 0xb9, 0xde, 0xda, 0xf3, 0xcd, 0xd9, 0xd7, 0x1f, 0x99, 0x7d, 0xdb, 0x95, + 0xf6, 0x47, 0xd9, 0xcf, 0x01, 0x57, 0x4f, 0x35, 0x78, 0x7f, 0x23, 0xa7, 0xb6, 0x31, 0x4d, 0xfb, 0xa5, 0x88, 0xd2, + 0x2e, 0xee, 0xba, 0xe0, 0x1f, 0x8f, 0x43, 0x2c, 0xa6, 0x8a, 0xcf, 0xda, 0x8e, 0x33, 0x1c, 0x12, 0xb6, 0x6c, 0x5b, + 0x11, 0x39, 0x16, 0x55, 0xa6, 0xda, 0xdf, 0xce, 0xa3, 0x97, 0xf8, 0x19, 0x53, 0xeb, 0x5a, 0x96, 0xb2, 0x8c, 0x92, + 0x7d, 0x09, 0x05, 0xdc, 0x42, 0x95, 0x8b, 0x1f, 0xcd, 0xa0, 0x08, 0xda, 0x14, 0xba, 0xa4, 0x5d, 0x0e, 0x61, 0x9c, + 0x68, 0xb5, 0x44, 0xcc, 0x6e, 0x09, 0xc4, 0xfb, 0x98, 0xd3, 0x24, 0x54, 0xfc, 0x4d, 0x66, 0xa6, 0x2c, 0x07, 0x45, + 0xf8, 0xe7, 0x5f, 0x2d, 0x82, 0xba, 0x01, 0xbb, 0xfc, 0x75, 0xc1, 0xae, 0xd7, 0x36, 0x3c, 0xb5, 0x1f, 0x71, 0xe8, + 0x02, 0xf3, 0x6e, 0x60, 0x8c, 0x05, 0x6e, 0xea, 0xaf, 0x79, 0xba, 0x7f, 0xfc, 0xf6, 0x68, 0x1a, 0x24, 0x6c, 0x98, + 0xfb, 0x7e, 0x1c, 0xc7, 0xc2, 0x3d, 0x4b, 0x8a, 0x9f, 0x09, 0x26, 0x73, 0x09, 0x6d, 0x00, 0x18, 0x9a, 0xe1, 0xd6, + 0x45, 0xfd, 0x49, 0x93, 0xf3, 0x34, 0x93, 0xfb, 0xfb, 0x28, 0x75, 0xb4, 0xeb, 0xf2, 0xa3, 0x78, 0xcb, 0xf5, 0xfd, + 0x85, 0x35, 0xfe, 0x11, 0xd9, 0x3c, 0x00, 0xf5, 0x4d, 0xe8, 0x31, 0xc7, 0xda, 0x1f, 0x5f, 0x77, 0xb6, 0xb6, 0x7b, + 0xd3, 0x82, 0xe2, 0x96, 0x8b, 0xfd, 0xe0, 0xe2, 0x6d, 0x6e, 0x7d, 0xdc, 0x3c, 0x42, 0x6b, 0x59, 0x8e, 0xc1, 0xd2, + 0xeb, 0x06, 0xd6, 0xe5, 0xac, 0xf1, 0x90, 0x00, 0x54, 0x1f, 0x3b, 0x5d, 0x9a, 0x45, 0x88, 0x10, 0xbd, 0x85, 0x93, + 0xc3, 0x2e, 0xee, 0xf8, 0xda, 0x64, 0x69, 0x4a, 0x89, 0xf0, 0x60, 0x09, 0x50, 0x9c, 0xe1, 0x43, 0x11, 0xab, 0x74, + 0xfb, 0x5e, 0x46, 0x14, 0xe6, 0x46, 0x88, 0x81, 0x50, 0xe6, 0x48, 0xb9, 0x9c, 0xfa, 0x55, 0x21, 0xd3, 0x14, 0xa4, + 0x33, 0xab, 0x49, 0xe9, 0x91, 0x28, 0x51, 0x28, 0x78, 0xab, 0x8f, 0xc7, 0xbe, 0x4e, 0x0f, 0x29, 0x81, 0x53, 0x32, + 0x9b, 0x9c, 0x27, 0x3c, 0x82, 0xb4, 0x29, 0x3a, 0xcd, 0x14, 0x67, 0xd7, 0x4d, 0x6c, 0x8b, 0xe3, 0xd6, 0x21, 0xc7, + 0x69, 0x8b, 0x24, 0xe8, 0xb2, 0xab, 0x1d, 0x97, 0x65, 0xad, 0xc8, 0x81, 0x77, 0x9a, 0xe7, 0xf1, 0x00, 0x3e, 0xda, + 0x6e, 0xfd, 0x3e, 0xb4, 0x36, 0x21, 0x86, 0x87, 0x95, 0x94, 0xba, 0x59, 0x7c, 0x85, 0xe8, 0x60, 0xf0, 0xb6, 0xd9, + 0x87, 0x8b, 0xfd, 0xfb, 0xa3, 0xd3, 0x1b, 0x71, 0xd6, 0xe7, 0xaf, 0x89, 0xc1, 0x87, 0xf3, 0xe7, 0xdf, 0xec, 0xd5, + 0xd7, 0xed, 0xb4, 0x6e, 0x32, 0xc5, 0xe4, 0xee, 0x56, 0x25, 0xe5, 0xe8, 0x08, 0x08, 0xba, 0x12, 0x46, 0x45, 0x73, + 0x11, 0x80, 0x88, 0x0e, 0x28, 0x2f, 0x2c, 0xea, 0xe8, 0x85, 0x07, 0x1f, 0xc9, 0xd2, 0x4b, 0x9a, 0xb0, 0x51, 0xec, + 0xd8, 0xff, 0x23, 0x7d, 0xfb, 0x51, 0x56, 0x42, 0x95, 0x0b, 0xe0, 0xff, 0x0d, 0x74, 0x03, 0xf8, 0xb0, 0x15, 0x68, + 0x21, 0x85, 0x34, 0x04, 0x03, 0xe8, 0xac, 0x09, 0xfa, 0x9a, 0x32, 0x64, 0xa0, 0x77, 0x26, 0x43, 0x6a, 0x95, 0xb9, + 0x94, 0xa5, 0xb0, 0xde, 0x90, 0xa5, 0x89, 0xb7, 0x3f, 0x3f, 0x7d, 0x81, 0x1f, 0xb1, 0x48, 0xb3, 0x47, 0x32, 0x8b, + 0x4a, 0xb9, 0x68, 0x88, 0x3c, 0x83, 0x08, 0x54, 0x93, 0x70, 0x54, 0xca, 0x35, 0x68, 0x15, 0xa3, 0xf6, 0xbb, 0xb0, + 0x16, 0xac, 0x77, 0xc3, 0xa4, 0xa8, 0x2f, 0x46, 0xb5, 0xf6, 0x68, 0x54, 0xc8, 0x7a, 0x5f, 0x23, 0x43, 0xbb, 0x23, + 0x56, 0x3f, 0xbd, 0xac, 0xd2, 0xa5, 0xd9, 0xa7, 0x1a, 0xac, 0x44, 0x2b, 0x03, 0xd9, 0x42, 0xaa, 0x3d, 0xba, 0x6b, + 0xad, 0x7f, 0xe5, 0xeb, 0x37, 0x5e, 0x83, 0xb7, 0xe0, 0x09, 0xf8, 0xab, 0xab, 0x76, 0x3f, 0xaa, 0xef, 0xd4, 0xac, + 0x90, 0xd1, 0x8c, 0x55, 0x4c, 0xb0, 0xe6, 0x6d, 0x2b, 0xa5, 0x45, 0xbe, 0xbf, 0x31, 0x1e, 0x7f, 0xc4, 0x8f, 0x69, + 0x72, 0x53, 0xc9, 0x30, 0xbf, 0x40, 0x25, 0xee, 0x01, 0x4f, 0x73, 0xcc, 0x23, 0x1f, 0x4d, 0x84, 0x82, 0x7d, 0x9b, + 0x2f, 0x49, 0x59, 0xdf, 0x93, 0xec, 0xf5, 0x2d, 0xe1, 0x19, 0x15, 0x59, 0x12, 0x3b, 0x36, 0x51, 0xb0, 0x46, 0x71, + 0x48, 0x85, 0x66, 0x50, 0x0e, 0x81, 0xb9, 0x81, 0x76, 0x3f, 0xd5, 0xde, 0x63, 0xb5, 0x86, 0x3d, 0x09, 0xea, 0x51, + 0x47, 0xd4, 0xf2, 0x5b, 0xac, 0x84, 0xc9, 0xd0, 0xd9, 0xd9, 0x8f, 0x11, 0x83, 0x14, 0xae, 0x0b, 0x5d, 0x5d, 0xbd, + 0xc3, 0x7e, 0x5e, 0x4c, 0xdc, 0xf4, 0x6e, 0xa5, 0x43, 0x0c, 0x71, 0x77, 0x0b, 0x95, 0xbe, 0x6f, 0x28, 0xe1, 0x3a, + 0x7c, 0x12, 0x5f, 0x47, 0xdc, 0x94, 0x07, 0xfd, 0x65, 0xf9, 0x21, 0x3c, 0x82, 0x53, 0x78, 0x73, 0x9e, 0xbf, 0xe9, + 0x5c, 0x3a, 0x70, 0x05, 0x00, 0x47, 0xe2, 0x9d, 0x20, 0x29, 0x8e, 0x36, 0xdb, 0x93, 0x28, 0x56, 0x28, 0x9c, 0x4d, + 0x91, 0xd4, 0xee, 0xde, 0x50, 0xf8, 0x58, 0xa1, 0x31, 0x5b, 0x48, 0x06, 0x80, 0xf1, 0x5a, 0x96, 0xd5, 0xea, 0xf9, + 0x2c, 0x40, 0x72, 0xa7, 0x8d, 0xe6, 0x61, 0xb7, 0x05, 0x51, 0xdd, 0x63, 0xe6, 0xd1, 0x16, 0xe9, 0xde, 0xba, 0x29, + 0xb4, 0xf1, 0xb2, 0xa4, 0x75, 0x76, 0x1e, 0xf4, 0xfa, 0x5c, 0x44, 0xa8, 0x83, 0xa0, 0x0b, 0xa6, 0xfb, 0x92, 0xe4, + 0x44, 0xcc, 0xac, 0x2d, 0xd3, 0x18, 0x1d, 0x8d, 0xd4, 0xf1, 0x1c, 0x47, 0x8d, 0x6d, 0x49, 0xdb, 0xb4, 0xd7, 0x03, + 0xa1, 0xbb, 0x73, 0x9c, 0x16, 0x31, 0x70, 0xee, 0x61, 0x44, 0x81, 0x6c, 0x3d, 0x3d, 0x45, 0xb8, 0x2e, 0x83, 0xcd, + 0x5a, 0x65, 0x1f, 0xbd, 0xbf, 0xd2, 0xa1, 0x0d, 0xfb, 0x02, 0x1d, 0x4e, 0x62, 0x15, 0x2a, 0x2e, 0x82, 0xec, 0xaa, + 0xf6, 0x5f, 0x24, 0x7e, 0xd7, 0xb5, 0x01, 0x02, 0x28, 0xe3, 0x04, 0x43, 0x6f, 0xf1, 0x4e, 0xd4, 0x8d, 0xd7, 0xba, + 0x70, 0x2d, 0xdf, 0xb5, 0x25, 0xf5, 0xda, 0x54, 0x8c, 0x1a, 0xc3, 0x66, 0xa1, 0x60, 0x88, 0xf6, 0xe1, 0x87, 0x52, + 0xc1, 0xd9, 0x75, 0x9d, 0x81, 0x2f, 0xdc, 0x85, 0x59, 0x16, 0xd2, 0x15, 0x38, 0xcc, 0xab, 0x67, 0x17, 0x5b, 0xa5, + 0x39, 0xda, 0x14, 0xe8, 0xe3, 0x6f, 0xdb, 0x7a, 0x52, 0x49, 0x05, 0x89, 0xcf, 0x6f, 0x9c, 0x12, 0xf4, 0x0c, 0x2d, + 0x39, 0xbc, 0x23, 0x38, 0xc1, 0x24, 0xd4, 0x6d, 0x6e, 0x0e, 0x97, 0xa1, 0xfd, 0x86, 0xb5, 0x9e, 0xb6, 0xdf, 0x81, + 0xb6, 0xea, 0x3d, 0xcc, 0x55, 0xcc, 0x4c, 0xaf, 0xd6, 0xf3, 0x38, 0x72, 0x87, 0x79, 0xbf, 0xcb, 0x10, 0x3d, 0x6a, + 0x6a, 0xf0, 0x96, 0x04, 0x57, 0xe8, 0xfc, 0xc2, 0xaa, 0x84, 0x8e, 0x88, 0x49, 0x06, 0x05, 0xd9, 0x24, 0x10, 0x8c, + 0xe8, 0x8f, 0xd0, 0x8b, 0xfb, 0x13, 0x29, 0x69, 0xc4, 0x2a, 0x32, 0x82, 0x39, 0xfa, 0x46, 0x19, 0x4b, 0x25, 0xe2, + 0x7c, 0xe3, 0x18, 0xef, 0x13, 0xd4, 0xeb, 0x9a, 0x79, 0xd4, 0xc5, 0x2e, 0xcb, 0x50, 0x69, 0x4c, 0x1f, 0x4b, 0xb9, + 0xb0, 0x91, 0x3d, 0x07, 0x6e, 0xb8, 0xd3, 0x9f, 0x8a, 0x09, 0xdb, 0x78, 0x7e, 0x4a, 0x97, 0x0e, 0x2b, 0x1b, 0x14, + 0xf9, 0xc5, 0xb6, 0x05, 0x88, 0xfa, 0xd6, 0xed, 0xe9, 0x94, 0x7c, 0x60, 0x7b, 0xd2, 0xec, 0x62, 0x1e, 0x04, 0x9e, + 0xfd, 0x2c, 0xb9, 0x58, 0xa4, 0x5d, 0x27, 0x59, 0xd9, 0x87, 0x27, 0x5b, 0x95, 0xdc, 0x38, 0xd5, 0xab, 0x0e, 0x00, + 0xb4, 0xbd, 0xd0, 0x8c, 0x78, 0x85, 0xec, 0x65, 0x68, 0x3b, 0xd8, 0xfc, 0xe5, 0x42, 0x6d, 0x60, 0xda, 0x54, 0x2e, + 0x0d, 0x47, 0x07, 0x06, 0xdf, 0x47, 0x63, 0x8a, 0x71, 0x7b, 0xcc, 0x4c, 0x25, 0x39, 0x12, 0x4c, 0x80, 0xc1, 0xc3, + 0x40, 0x33, 0x21, 0x74, 0x5f, 0x8b, 0xa7, 0xc9, 0x19, 0x58, 0x09, 0x3f, 0x14, 0xc3, 0x58, 0x54, 0xda, 0x42, 0x41, + 0xa9, 0xbb, 0x24, 0xc1, 0x18, 0x59, 0x05, 0x7d, 0x5e, 0xf5, 0xc9, 0xc3, 0x91, 0x7d, 0x88, 0xed, 0x9e, 0x7c, 0xf1, + 0xdc, 0xac, 0xab, 0xa1, 0xb4, 0xa0, 0x1d, 0x42, 0x13, 0x2e, 0xab, 0x4d, 0x7d, 0x93, 0x1c, 0xb0, 0x60, 0x69, 0x18, + 0xa4, 0xa9, 0x77, 0xf4, 0x69, 0xd2, 0x48, 0x1c, 0x8e, 0x43, 0xc7, 0x48, 0x7b, 0x59, 0x28, 0xec, 0x2c, 0x2e, 0x5b, + 0xec, 0x5f, 0xcf, 0x12, 0xbd, 0xe9, 0xb6, 0xfd, 0xfb, 0x14, 0xf6, 0x10, 0x0e, 0x58, 0x12, 0x6a, 0xe4, 0xb4, 0x06, + 0x37, 0x34, 0x58, 0x5e, 0xfb, 0x27, 0x2e, 0x92, 0xdb, 0x1a, 0x79, 0x79, 0x7b, 0x38, 0x83, 0x0d, 0x30, 0x44, 0x57, + 0x8a, 0x6d, 0xb2, 0x44, 0x7c, 0xf1, 0xd6, 0x35, 0x05, 0x05, 0x9d, 0xd4, 0xc6, 0xad, 0x8c, 0xda, 0xa1, 0xb6, 0x31, + 0x7b, 0x79, 0x58, 0xab, 0xb0, 0x13, 0x37, 0x1e, 0x6f, 0xb6, 0xe4, 0xc4, 0x66, 0x38, 0x20, 0xcd, 0x67, 0x1b, 0x4e, + 0x18, 0xed, 0x1d, 0xd9, 0x97, 0x72, 0xa4, 0xe5, 0x17, 0xed, 0xe6, 0x84, 0xa5, 0xb4, 0x48, 0x6b, 0xa7, 0x6b, 0x6f, + 0x61, 0xba, 0xdf, 0x12, 0xfe, 0x44, 0xbb, 0xb0, 0xaf, 0x93, 0x75, 0x29, 0x9d, 0x3c, 0x0d, 0xb7, 0x2a, 0xc9, 0xf1, + 0x0f, 0x9b, 0x15, 0xba, 0x24, 0x62, 0x6a, 0x1b, 0x2e, 0xc7, 0xb7, 0xc7, 0xfd, 0x91, 0x9f, 0x11, 0xb7, 0x30, 0x18, + 0x6a, 0x0d, 0x5f, 0x6c, 0xe1, 0xa8, 0xec, 0x33, 0x9e, 0x43, 0x53, 0x1a, 0x84, 0xed, 0xe6, 0x91, 0x59, 0xd3, 0x07, + 0xcf, 0x4c, 0x27, 0xac, 0x39, 0xbc, 0x7e, 0x16, 0xe0, 0x3d, 0x08, 0x06, 0xb0, 0xee, 0x49, 0x10, 0xe0, 0x14, 0x55, + 0x18, 0x8a, 0x7b, 0x60, 0xf5, 0x97, 0x6e, 0x4f, 0x10, 0xe8, 0xe8, 0x74, 0xfa, 0x28, 0xa0, 0x84, 0x31, 0x24, 0x8f, + 0xfc, 0x42, 0xd6, 0x42, 0x8b, 0x7b, 0xf7, 0xf0, 0xcb, 0xbe, 0x42, 0x6a, 0x24, 0x6c, 0xd9, 0x5f, 0x94, 0xd5, 0x7c, + 0x1b, 0xfd, 0x23, 0x87, 0x11, 0x46, 0x00, 0x7d, 0x3d, 0x6d, 0x13, 0x38, 0xf9, 0x3c, 0x1b, 0x09, 0x19, 0xb5, 0xe1, + 0xac, 0x23, 0xf6, 0xa1, 0x3e, 0xf6, 0xb1, 0x23, 0x5d, 0x36, 0x38, 0x21, 0x5b, 0xc2, 0xb2, 0x3f, 0x75, 0xed, 0x2e, + 0xa7, 0xec, 0xef, 0x61, 0x5b, 0x61, 0xb0, 0x21, 0x20, 0x4f, 0xae, 0xd2, 0x42, 0xb6, 0x14, 0x42, 0xc3, 0xdb, 0x6a, + 0xce, 0x61, 0xfd, 0x38, 0xe2, 0x53, 0xb9, 0xac, 0x9d, 0xd2, 0x24, 0x6a, 0x61, 0x6c, 0x7b, 0xa5, 0xc7, 0x71, 0xf4, + 0x48, 0x65, 0x47, 0x18, 0x55, 0x51, 0x7a, 0xbf, 0xc4, 0x13, 0x9c, 0x50, 0xc3, 0x5b, 0x22, 0x51, 0x48, 0x1e, 0x9f, + 0x93, 0xf7, 0x70, 0xf0, 0x53, 0x8d, 0x49, 0x9a, 0xfb, 0xa8, 0x2b, 0xae, 0xa9, 0x74, 0x47, 0xfe, 0x61, 0x60, 0x39, + 0xe9, 0x0f, 0x69, 0xad, 0x52, 0xa6, 0x51, 0xc9, 0x4f, 0x05, 0x87, 0x06, 0x37, 0x0b, 0x26, 0x1e, 0x18, 0xe5, 0x7e, + 0x2c, 0x63, 0xc7, 0x90, 0x3b, 0xb5, 0x8a, 0x9b, 0xf0, 0xeb, 0x2f, 0x00, 0x98, 0xb5, 0xf0, 0x41, 0xd9, 0x9d, 0xa1, + 0x0d, 0x94, 0x54, 0xda, 0x55, 0x2a, 0xb1, 0x29, 0xd7, 0x0b, 0xae, 0x8a, 0x2d, 0x36, 0xef, 0x4e, 0x1d, 0x0d, 0x11, + 0xea, 0x36, 0x33, 0x8f, 0xaa, 0xc8, 0x44, 0x7c, 0x45, 0x66, 0xae, 0xcf, 0x3a, 0x42, 0x61, 0x00, 0x4f, 0x6a, 0x53, + 0x64, 0x06, 0xab, 0xb4, 0x27, 0x29, 0xe5, 0x60, 0xf3, 0x0b, 0x66, 0xd3, 0xed, 0xa6, 0x26, 0x5b, 0xc6, 0x07, 0x67, + 0x66, 0x0c, 0x91, 0x29, 0xc2, 0x9e, 0x58, 0x9c, 0x18, 0x03, 0xeb, 0x19, 0x41, 0xd3, 0xe1, 0x66, 0x69, 0xd9, 0xa8, + 0xca, 0x1b, 0xa2, 0xe1, 0x4f, 0x58, 0x38, 0xdf, 0x91, 0x4a, 0x6f, 0x98, 0xa6, 0x7a, 0x4f, 0x60, 0x3a, 0x33, 0x19, + 0x99, 0xf6, 0x94, 0xd9, 0xc8, 0xf7, 0x30, 0xa4, 0x9b, 0x5e, 0xbc, 0x60, 0xc1, 0x32, 0x7d, 0xb1, 0x09, 0xda, 0xce, + 0xff, 0xa6, 0x82, 0xbc, 0xd1, 0xc2, 0xf0, 0x70, 0x5b, 0x46, 0x93, 0x5f, 0xde, 0x95, 0x51, 0xff, 0xd9, 0xdf, 0xe5, + 0x66, 0xaa, 0x51, 0x81, 0x82, 0xd7, 0x04, 0x55, 0x1b, 0xe5, 0xbe, 0x6e, 0xb7, 0xfe, 0xfb, 0x9c, 0x35, 0x7e, 0x40, + 0x09, 0x1e, 0x0e, 0x19, 0xb0, 0x27, 0xd8, 0x7e, 0xf2, 0x08, 0xf2, 0x69, 0xe7, 0x90, 0x45, 0xe3, 0xd0, 0x2a, 0xda, + 0x90, 0xdb, 0xb8, 0x93, 0x29, 0x9c, 0x07, 0x91, 0xed, 0xbc, 0xd8, 0x30, 0x00, 0x91, 0x0f, 0xba, 0xdd, 0xd8, 0x7d, + 0x5f, 0x16, 0x51, 0xd0, 0xe7, 0xad, 0xc8, 0x28, 0x82, 0x6c, 0x6c, 0x0a, 0x07, 0x53, 0x95, 0xef, 0xe6, 0x2c, 0xf1, + 0xe4, 0x90, 0x5d, 0x74, 0x10, 0x0f, 0x79, 0xba, 0x9c, 0x6e, 0x52, 0xb2, 0x32, 0x73, 0x7a, 0xdf, 0xb5, 0x7d, 0xb0, + 0x77, 0xde, 0xf3, 0x12, 0x30, 0x84, 0xb5, 0x61, 0xed, 0xb4, 0x90, 0x7d, 0x0f, 0x82, 0xaa, 0xbe, 0x6f, 0xa4, 0xe0, + 0x66, 0x60, 0x1a, 0x63, 0x1a, 0x10, 0x63, 0x96, 0x91, 0xfe, 0x11, 0xb2, 0xe5, 0xc9, 0x54, 0xf5, 0xf7, 0x1b, 0x32, + 0x8b, 0xc8, 0x6a, 0x79, 0x46, 0x77, 0xed, 0x0d, 0x9e, 0xf9, 0xf8, 0xdf, 0x8d, 0x4c, 0x93, 0x98, 0x5f, 0xf5, 0x28, + 0xd6, 0x48, 0xaa, 0xe7, 0x81, 0x4e, 0xee, 0x09, 0xad, 0x62, 0xe0, 0xb8, 0x56, 0x28, 0xd4, 0x58, 0xc0, 0x4a, 0x6c, + 0x8f, 0x00, 0xb7, 0xc2, 0x2f, 0x03, 0x3a, 0x81, 0x98, 0xd2, 0x88, 0xf5, 0x72, 0xd9, 0x05, 0x29, 0xb6, 0x9f, 0xa0, + 0x06, 0xc0, 0x27, 0x83, 0x6b, 0x1f, 0x82, 0xa4, 0x62, 0x4a, 0xf6, 0x73, 0x40, 0x76, 0x61, 0x88, 0xe0, 0xc5, 0x8c, + 0x51, 0x4d, 0x88, 0x3e, 0x20, 0xcf, 0xe1, 0xff, 0xab, 0x1c, 0x04, 0x95, 0x6a, 0x21, 0xbc, 0x29, 0x12, 0x17, 0x9f, + 0x6d, 0xc1, 0x0d, 0x3b, 0x2b, 0xd9, 0xb8, 0x6f, 0xb7, 0xe9, 0xbf, 0xfe, 0x72, 0xdb, 0xf9, 0x9f, 0x44, 0xa0, 0xf5, + 0x58, 0x6b, 0x33, 0x05, 0x12, 0x38, 0x12, 0xb2, 0x37, 0x0a, 0x1e, 0xa9, 0x72, 0x8a, 0xe1, 0xdd, 0x89, 0x20, 0xfd, + 0xfc, 0x06, 0x12, 0x8a, 0x78, 0x95, 0xf6, 0x00, 0x1a, 0x0e, 0x5b, 0xac, 0x66, 0xf4, 0x79, 0xcb, 0x31, 0x00, 0xa1, + 0x12, 0xb7, 0x7c, 0xcb, 0xd0, 0xc1, 0x2a, 0xbe, 0xbd, 0x12, 0xb5, 0x8e, 0x5c, 0x4f, 0x8d, 0x49, 0x60, 0x4e, 0x8e, + 0x9a, 0xff, 0xe4, 0x76, 0x79, 0x8a, 0x2e, 0xa8, 0x84, 0xc6, 0xb2, 0xd0, 0x76, 0x72, 0x74, 0x7b, 0x34, 0xa2, 0xaf, + 0x54, 0xc6, 0x32, 0xac, 0xb9, 0xec, 0x07, 0xdf, 0x50, 0x31, 0x95, 0xb1, 0x15, 0x93, 0xb7, 0xae, 0x3d, 0xdf, 0xcb, + 0xf6, 0x44, 0x89, 0x5e, 0xeb, 0xf1, 0xb1, 0xb0, 0xdc, 0xef, 0x2c, 0xec, 0x2d, 0x05, 0x7f, 0xba, 0x72, 0x79, 0xc3, + 0x1b, 0x07, 0x36, 0x1d, 0x77, 0xd6, 0xc5, 0xb9, 0x4b, 0x15, 0x1e, 0xb0, 0xdd, 0xaa, 0x24, 0x6c, 0xce, 0xc5, 0x9d, + 0xe0, 0xa5, 0x11, 0xcb, 0x29, 0xd3, 0x3b, 0x93, 0xfb, 0xee, 0x00, 0x9b, 0xf2, 0x9f, 0xc3, 0x8a, 0x95, 0x89, 0x71, + 0x29, 0xc8, 0x34, 0x0b, 0x3c, 0x17, 0xac, 0x95, 0x9a, 0x19, 0x6d, 0xa8, 0x5f, 0xa0, 0x87, 0xed, 0xf8, 0xe0, 0x8e, + 0x42, 0x3a, 0xf0, 0x86, 0x5a, 0xe8, 0x94, 0xff, 0x89, 0x23, 0x8d, 0x6b, 0x6f, 0x3f, 0xfb, 0xaf, 0xa3, 0x4a, 0x45, + 0x0f, 0xd0, 0x4b, 0x4d, 0x7e, 0xee, 0x08, 0xb3, 0x7a, 0xcb, 0x17, 0x2a, 0xcb, 0xc3, 0x9d, 0xf4, 0x27, 0xe5, 0x7d, + 0x9b, 0x44, 0xdf, 0x39, 0x0e, 0xbf, 0xbe, 0x7b, 0x9e, 0x8c, 0x0b, 0xac, 0x9e, 0xdd, 0x9d, 0x38, 0x11, 0x52, 0x48, + 0x16, 0xdb, 0x41, 0xdf, 0x80, 0x5c, 0xf7, 0xfa, 0x45, 0x34, 0x3d, 0x48, 0x38, 0x20, 0xbd, 0xa1, 0x2f, 0xa4, 0x81, + 0x7d, 0xc1, 0x3d, 0xb4, 0xe0, 0xaa, 0x5c, 0x7e, 0x0f, 0x9e, 0x78, 0xce, 0x5d, 0x2b, 0x2f, 0x69, 0x8a, 0x30, 0x73, + 0x84, 0x2a, 0xaf, 0x04, 0xc5, 0x6d, 0x24, 0x0c, 0x7e, 0x29, 0x45, 0xff, 0x67, 0x99, 0x4f, 0xde, 0xfb, 0xb4, 0xae, + 0x74, 0x73, 0x8b, 0xcf, 0xd4, 0xd3, 0x0c, 0x5c, 0xdc, 0x4e, 0xcb, 0x47, 0x6a, 0xf3, 0x5c, 0xdd, 0x12, 0x4d, 0x5e, + 0xf9, 0x12, 0xb3, 0x56, 0x69, 0x1a, 0x11, 0xf9, 0x90, 0xd1, 0xea, 0xbd, 0xd8, 0x51, 0x32, 0xa6, 0xe9, 0xd1, 0x3e, + 0xd0, 0x15, 0x42, 0xfd, 0xba, 0xa6, 0xe8, 0x9b, 0x01, 0x08, 0x03, 0x44, 0xee, 0x40, 0xbd, 0x2d, 0x3c, 0x35, 0x8e, + 0xa6, 0x2d, 0x07, 0x94, 0x41, 0x03, 0x17, 0x01, 0x4d, 0xa4, 0xe0, 0x3d, 0x40, 0x9c, 0x46, 0xe8, 0xe1, 0x41, 0xe1, + 0x00, 0x65, 0xf7, 0x65, 0xaf, 0x26, 0x1f, 0x7b, 0xf2, 0x52, 0xef, 0xeb, 0x6c, 0x86, 0x1e, 0x27, 0x94, 0x32, 0xbb, + 0xa2, 0x34, 0xb6, 0x61, 0x18, 0xbe, 0x63, 0x22, 0x77, 0x11, 0x30, 0xd2, 0x7c, 0x30, 0x5b, 0xab, 0x74, 0xe7, 0x42, + 0x14, 0x10, 0x22, 0xd1, 0x05, 0xf5, 0x7e, 0xc5, 0xc4, 0xaf, 0x19, 0x4f, 0x7e, 0x87, 0xfb, 0x30, 0xc8, 0x50, 0x92, + 0x13, 0xc4, 0xb3, 0x97, 0xc8, 0xcd, 0xd5, 0xf4, 0x9c, 0xbb, 0x8e, 0xd8, 0xdb, 0x61, 0xd4, 0x62, 0x17, 0xf6, 0x44, + 0xda, 0xf9, 0xd4, 0xe2, 0xdc, 0x6d, 0xfa, 0x72, 0x35, 0xf9, 0x0a, 0x9b, 0xe1, 0x87, 0x37, 0xf2, 0xec, 0xf9, 0x2a, + 0x06, 0x90, 0x92, 0x16, 0xbe, 0xdb, 0xf0, 0x61, 0x21, 0x99, 0x4b, 0x04, 0x2f, 0x65, 0x59, 0x44, 0x4a, 0xc1, 0x43, + 0xb6, 0xfa, 0x8b, 0xb7, 0x0d, 0xdc, 0xcc, 0xb4, 0x31, 0xcc, 0x83, 0x1b, 0x79, 0xbc, 0xe1, 0xa0, 0xa4, 0xd9, 0x93, + 0x1a, 0x1d, 0x7c, 0x81, 0x95, 0xc6, 0xf7, 0x98, 0x81, 0xc6, 0xdf, 0xd6, 0xef, 0xef, 0xb0, 0xf9, 0xb3, 0xbb, 0xb6, + 0xb6, 0xc3, 0x83, 0xbf, 0x40, 0x74, 0x68, 0x79, 0x84, 0x5e, 0x56, 0xc9, 0x6c, 0x7c, 0x87, 0x7f, 0x64, 0x55, 0x4e, + 0xcb, 0x0f, 0x47, 0x22, 0x02, 0x37, 0xb3, 0x68, 0xc5, 0x52, 0x06, 0xf7, 0xc3, 0x99, 0x90, 0xcc, 0x84, 0xc9, 0x95, + 0xd4, 0x9b, 0xe1, 0x02, 0xf3, 0xf0, 0xa8, 0x40, 0x66, 0xa9, 0xba, 0xa5, 0x8e, 0xdd, 0xca, 0x6f, 0x8e, 0xb9, 0x09, + 0x91, 0xf9, 0xe7, 0x6a, 0x40, 0x81, 0x8a, 0x5e, 0xe9, 0x9f, 0xd0, 0xbc, 0x09, 0x01, 0x3a, 0x13, 0x8f, 0x4d, 0x9d, + 0x91, 0xa5, 0x35, 0x63, 0x11, 0x36, 0xce, 0x1d, 0x15, 0x0b, 0x60, 0x4e, 0x9f, 0xf6, 0xb3, 0x9f, 0x5a, 0x44, 0x92, + 0x64, 0x3a, 0x3f, 0xde, 0xbf, 0x9d, 0x0d, 0x3b, 0x0f, 0x7c, 0xa1, 0xd9, 0x5e, 0x96, 0xd3, 0xe3, 0xc4, 0xcc, 0x77, + 0xc9, 0x99, 0x11, 0x15, 0xd6, 0x43, 0x74, 0xef, 0x49, 0xdc, 0x02, 0xee, 0x5f, 0xee, 0xeb, 0x92, 0x44, 0xb0, 0x68, + 0x4b, 0xc3, 0xa0, 0xa6, 0xb4, 0xcc, 0xba, 0x64, 0x2d, 0x9d, 0x42, 0x32, 0x71, 0x04, 0x61, 0x34, 0x1e, 0x53, 0x57, + 0xe6, 0xa8, 0xd9, 0x6c, 0xbe, 0x8d, 0xcd, 0xb1, 0x64, 0xb7, 0x29, 0x00, 0xa0, 0xa3, 0x3e, 0x40, 0x14, 0xf7, 0x07, + 0x9e, 0x5b, 0xdb, 0x9f, 0x7b, 0xef, 0x53, 0xa0, 0xb1, 0x1e, 0x94, 0xfc, 0xb8, 0xdc, 0xee, 0x2c, 0x85, 0xba, 0x07, + 0x9c, 0x30, 0x0e, 0xdd, 0x26, 0x2a, 0x84, 0x90, 0xfc, 0x4b, 0x4a, 0xc4, 0x82, 0xae, 0x62, 0xb3, 0xee, 0x38, 0xe3, + 0x8f, 0xc0, 0xbc, 0xc9, 0x76, 0x90, 0x94, 0x8f, 0x48, 0x5c, 0x01, 0x8a, 0x21, 0x0b, 0xa0, 0x2c, 0xf6, 0x85, 0xf2, + 0x39, 0x35, 0x31, 0xf2, 0x12, 0x8f, 0xb1, 0xf5, 0xff, 0x8f, 0xa9, 0x70, 0xf5, 0x88, 0xdc, 0x6d, 0xa1, 0xab, 0x9f, + 0xc9, 0x8d, 0x59, 0x2f, 0xed, 0x2b, 0xfa, 0x6a, 0x7a, 0xc2, 0xe4, 0x53, 0xe7, 0x87, 0x79, 0xef, 0xdf, 0x6b, 0xb4, + 0x38, 0x1d, 0x69, 0xfe, 0xc5, 0x9a, 0xe7, 0x91, 0x87, 0xe9, 0xf5, 0xa6, 0x7a, 0x92, 0x77, 0xdb, 0xe0, 0x77, 0x6f, + 0x46, 0x50, 0x12, 0x6f, 0xf4, 0x3a, 0xd5, 0x70, 0xf6, 0xba, 0xaa, 0x67, 0xeb, 0xaa, 0x9d, 0x5d, 0x54, 0xd3, 0xd9, + 0x65, 0xb5, 0xfe, 0x79, 0xbf, 0x97, 0x91, 0x6b, 0x06, 0x9e, 0x60, 0x9c, 0x9c, 0x5d, 0x66, 0xb2, 0x81, 0x86, 0xdc, + 0xd9, 0x15, 0x00, 0xb7, 0x7e, 0x3d, 0xd4, 0x4d, 0x92, 0x18, 0x05, 0xeb, 0xc0, 0xdb, 0xbd, 0x8e, 0x8b, 0x89, 0x54, + 0xcf, 0x23, 0xc8, 0xeb, 0x71, 0xdd, 0xd3, 0xe3, 0xd1, 0x35, 0xd5, 0x16, 0x3d, 0x4a, 0x50, 0x72, 0x40, 0xc8, 0xb5, + 0x6f, 0x66, 0x14, 0x99, 0x7b, 0x5b, 0x03, 0x8c, 0x6d, 0xd3, 0xad, 0x5f, 0x13, 0x59, 0x27, 0x99, 0x10, 0xef, 0x98, + 0xb5, 0x88, 0xb5, 0x41, 0x97, 0x77, 0xdc, 0x22, 0x49, 0xe8, 0xcd, 0x1f, 0x2c, 0x94, 0xa6, 0xe3, 0x5b, 0x4b, 0xf9, + 0x19, 0x03, 0xb1, 0xe2, 0xd9, 0x6f, 0x48, 0xfd, 0xd0, 0xc4, 0x5f, 0xb9, 0x3d, 0x6b, 0xe2, 0x05, 0xa0, 0x7f, 0x50, + 0x77, 0x24, 0x65, 0x89, 0xf1, 0xb9, 0x7e, 0x8a, 0x08, 0xaf, 0xd6, 0x11, 0x0b, 0x8b, 0x5e, 0xe5, 0xd0, 0xb7, 0x35, + 0x49, 0xac, 0x73, 0xfd, 0x33, 0x93, 0x67, 0x21, 0x68, 0xb7, 0x4f, 0x0a, 0xd7, 0x9f, 0x1d, 0x52, 0xd1, 0x41, 0x6f, + 0xc5, 0x1a, 0x76, 0xba, 0x4a, 0x08, 0xd9, 0x72, 0x06, 0x49, 0xa3, 0xd9, 0x80, 0x9b, 0x24, 0x8e, 0xf2, 0xff, 0x14, + 0x24, 0xcc, 0xfb, 0x87, 0x36, 0x43, 0x2d, 0x6e, 0x39, 0x7a, 0xee, 0x74, 0x87, 0x47, 0x85, 0x77, 0xeb, 0x68, 0xe7, + 0x5d, 0xf7, 0xb3, 0x80, 0x98, 0x88, 0x23, 0x62, 0x7f, 0x4b, 0x6f, 0x53, 0x8d, 0x9d, 0x68, 0xee, 0x06, 0x17, 0x08, + 0x67, 0x98, 0x2b, 0xa1, 0xf1, 0xfa, 0xac, 0x1f, 0x6d, 0x2a, 0x19, 0xe5, 0xf8, 0x1e, 0xbe, 0x7a, 0xe6, 0x23, 0x4f, + 0xd0, 0x0b, 0x3c, 0x92, 0xc4, 0xfd, 0xc3, 0x89, 0xd6, 0x90, 0xdb, 0x16, 0xaf, 0x63, 0x7d, 0x55, 0xe3, 0x52, 0xa5, + 0xa7, 0x0b, 0x56, 0x08, 0x92, 0x38, 0x4d, 0x0f, 0xe0, 0x49, 0xdc, 0x10, 0x29, 0x16, 0x40, 0xc0, 0xe6, 0x45, 0xe0, + 0x19, 0x0d, 0xf4, 0x47, 0xf0, 0x76, 0x56, 0xe4, 0x45, 0xf4, 0xa9, 0xd6, 0x1d, 0x87, 0xaa, 0xad, 0xaf, 0xe4, 0x87, + 0xd5, 0xcb, 0x86, 0x08, 0x68, 0xde, 0x47, 0x8c, 0x26, 0x87, 0xbe, 0xe1, 0x33, 0xf5, 0x93, 0x1b, 0xf5, 0xf0, 0xba, + 0x1d, 0x85, 0x46, 0x88, 0x7b, 0x65, 0x48, 0x6c, 0xf6, 0x2d, 0x67, 0xe4, 0x84, 0x5b, 0x3d, 0xe2, 0x38, 0xad, 0x23, + 0x6b, 0x45, 0xca, 0xf1, 0xac, 0x3c, 0xdf, 0x33, 0xf1, 0x64, 0x72, 0xbb, 0xc8, 0xdf, 0x16, 0x7e, 0x96, 0x76, 0x58, + 0x8f, 0xfa, 0x56, 0x85, 0xf1, 0xc8, 0xdd, 0x1c, 0x41, 0x34, 0x1e, 0x25, 0xc0, 0x95, 0xf6, 0x11, 0x88, 0x76, 0x76, + 0xe6, 0xf4, 0x94, 0xe6, 0xad, 0x70, 0xe3, 0xaf, 0x66, 0xc4, 0x34, 0xf0, 0x1b, 0xf0, 0x40, 0xf1, 0x16, 0x71, 0x16, + 0xde, 0x60, 0x2c, 0xb1, 0xa8, 0x61, 0x60, 0x08, 0x1b, 0xc8, 0xd4, 0xe0, 0xf2, 0x81, 0x95, 0xd4, 0x73, 0x92, 0x00, + 0xca, 0x1a, 0xea, 0x59, 0x58, 0xe1, 0xcb, 0xcd, 0xf9, 0xde, 0x22, 0xab, 0x84, 0x3f, 0xb8, 0x7d, 0x66, 0xc2, 0xd6, + 0x9e, 0x5b, 0xe5, 0x6f, 0x47, 0xe6, 0x65, 0x79, 0x95, 0x02, 0xda, 0x32, 0xb4, 0x0c, 0x01, 0xde, 0xb2, 0x35, 0x8b, + 0x51, 0x1d, 0x2a, 0xf7, 0x4f, 0xa3, 0xe3, 0x41, 0xef, 0x12, 0x2d, 0x76, 0x1f, 0x5d, 0xff, 0xf3, 0x87, 0xaf, 0x7e, + 0xb1, 0x72, 0xcb, 0x2f, 0xa7, 0x6b, 0x6b, 0xa7, 0x8a, 0x5f, 0x5e, 0x2d, 0x87, 0x53, 0xfa, 0x0b, 0x99, 0xae, 0xd6, + 0x9e, 0xd5, 0x62, 0x6b, 0x21, 0x67, 0x6e, 0x97, 0x4b, 0xea, 0xa0, 0x75, 0x25, 0xf3, 0x73, 0xde, 0x41, 0x50, 0x0e, + 0xe7, 0xf1, 0x75, 0x40, 0x83, 0x33, 0xb0, 0x79, 0x77, 0xa2, 0xe8, 0x42, 0xa6, 0xe5, 0xfe, 0xc5, 0xee, 0x01, 0x53, + 0xd0, 0x59, 0xcc, 0x8c, 0x51, 0x5f, 0xc8, 0xbb, 0x66, 0xac, 0xee, 0xbc, 0xec, 0x7b, 0xf2, 0x03, 0x5c, 0xd9, 0xdf, + 0xcd, 0x61, 0x89, 0x47, 0xc7, 0x3d, 0x44, 0xce, 0x12, 0xd9, 0xae, 0xeb, 0x66, 0x43, 0x0c, 0x38, 0xf8, 0x7e, 0x98, + 0xc9, 0x41, 0xe8, 0x57, 0x06, 0x2b, 0xc1, 0xa4, 0x2e, 0xf2, 0x5e, 0x20, 0xfa, 0x3a, 0x63, 0x28, 0xc0, 0x92, 0x17, + 0xbe, 0x43, 0x52, 0xbb, 0x61, 0xf9, 0x8a, 0xf0, 0x6a, 0x60, 0x19, 0xbb, 0xfe, 0x03, 0x31, 0xa6, 0x81, 0xe9, 0xca, + 0x72, 0x28, 0x8e, 0xb7, 0x9f, 0xc8, 0xde, 0x1c, 0xb8, 0xb1, 0xa6, 0x40, 0xb0, 0x40, 0xf1, 0x28, 0x5e, 0x63, 0xc5, + 0x42, 0xe4, 0x06, 0x32, 0x08, 0x19, 0xd6, 0xfb, 0x9a, 0x40, 0x35, 0x6d, 0xd6, 0x38, 0x0a, 0x4d, 0x77, 0xfd, 0x36, + 0x21, 0xa6, 0x15, 0x92, 0x84, 0x30, 0xf0, 0x2b, 0xfb, 0x80, 0xd5, 0xcc, 0xc6, 0xd6, 0x4e, 0x35, 0x70, 0x21, 0x92, + 0x7c, 0x1a, 0xdf, 0x84, 0x8a, 0x69, 0x92, 0x68, 0x55, 0x7b, 0x19, 0xc1, 0x75, 0xfe, 0x84, 0x0d, 0x6f, 0xca, 0x04, + 0xc4, 0x3e, 0x98, 0x3e, 0xd7, 0x68, 0xdf, 0xbf, 0xf0, 0xd5, 0x29, 0x99, 0xd1, 0x21, 0x80, 0x84, 0x67, 0x46, 0x08, + 0x23, 0x44, 0x05, 0x03, 0xdb, 0xc2, 0xed, 0x37, 0x29, 0x30, 0x5e, 0x4d, 0x36, 0x46, 0x52, 0xe7, 0x02, 0x63, 0x13, + 0x6e, 0x9c, 0x17, 0xb5, 0x49, 0xae, 0x60, 0xd8, 0xb6, 0x73, 0xec, 0x51, 0xef, 0xa5, 0x6f, 0xd8, 0x3e, 0xa5, 0x26, + 0xa8, 0x96, 0x58, 0x63, 0x4f, 0x98, 0xfa, 0x28, 0xb8, 0xfc, 0xbb, 0x9c, 0x89, 0x5d, 0xb8, 0x6f, 0x7c, 0xf5, 0x32, + 0xcb, 0xb7, 0x8b, 0x19, 0x15, 0xc4, 0xd5, 0xc0, 0x09, 0x92, 0x06, 0xaa, 0xb1, 0xb5, 0x2d, 0xf3, 0x6e, 0xde, 0xe8, + 0x68, 0xcf, 0x80, 0x56, 0x03, 0xb1, 0xb8, 0x39, 0x2e, 0x7c, 0x3a, 0x8a, 0x95, 0x38, 0xdc, 0xd0, 0x4c, 0x33, 0x48, + 0xd1, 0x8f, 0xc9, 0x01, 0x31, 0x13, 0xd0, 0xc3, 0xa3, 0xe3, 0x5f, 0x65, 0x84, 0xb8, 0x47, 0x9c, 0xfb, 0xd9, 0x93, + 0x81, 0x8c, 0xee, 0x96, 0x6f, 0x3b, 0x33, 0x22, 0x64, 0x15, 0x13, 0x4a, 0x8a, 0xbd, 0x0e, 0x26, 0x13, 0x2d, 0x3c, + 0x97, 0x9a, 0x0c, 0x2f, 0x2a, 0x0b, 0x6a, 0x6c, 0x22, 0xab, 0x78, 0x31, 0x71, 0xd1, 0x16, 0x53, 0x76, 0xd0, 0x26, + 0x53, 0x39, 0x11, 0xd9, 0x67, 0x56, 0x10, 0x03, 0x3a, 0xa2, 0x66, 0xc3, 0x2b, 0x97, 0xd7, 0x6c, 0x91, 0xaa, 0xd9, + 0x74, 0x4d, 0x4d, 0x1d, 0x90, 0x81, 0x63, 0xab, 0x21, 0x5a, 0xf7, 0xbe, 0x93, 0x8a, 0x74, 0xf0, 0x9e, 0xa5, 0x73, + 0x48, 0x23, 0x76, 0xde, 0x73, 0x2c, 0x1c, 0xc7, 0xe0, 0x1c, 0x46, 0x3e, 0x2f, 0xbd, 0x7c, 0x97, 0x92, 0xbc, 0xfc, + 0xc6, 0xcb, 0xa1, 0xd6, 0x26, 0x07, 0xaf, 0x15, 0xdc, 0x0b, 0x5c, 0x54, 0xe0, 0xde, 0xcd, 0x52, 0xc4, 0xf2, 0x38, + 0x5e, 0xde, 0xe4, 0x74, 0x6a, 0x77, 0xac, 0x00, 0x9f, 0xca, 0x53, 0x13, 0x4d, 0x73, 0xd6, 0xcd, 0xb3, 0xa7, 0x35, + 0x46, 0xf1, 0x4c, 0x79, 0x02, 0x3f, 0x7b, 0xd0, 0xcb, 0xfe, 0x23, 0xf4, 0x81, 0x38, 0x65, 0x62, 0x4b, 0xa1, 0xde, + 0xc9, 0xa8, 0xa8, 0xe9, 0x70, 0xd2, 0x66, 0x4c, 0x73, 0x9b, 0x40, 0x21, 0xf7, 0x9c, 0x74, 0xff, 0x2e, 0x5c, 0xbe, + 0x07, 0x2e, 0xf0, 0x03, 0xd0, 0x94, 0x00, 0x38, 0x1f, 0x01, 0x3c, 0x85, 0x88, 0x17, 0x20, 0xcf, 0x73, 0x4f, 0x44, + 0x70, 0x1f, 0x06, 0x72, 0x93, 0x9b, 0x39, 0x3f, 0x19, 0xd6, 0x36, 0x31, 0x16, 0x67, 0x31, 0xc9, 0x67, 0xc1, 0xef, + 0x7f, 0x17, 0xb7, 0x3f, 0x8c, 0x8f, 0x49, 0xab, 0xea, 0xdf, 0x42, 0x6b, 0xba, 0x01, 0xd1, 0x2a, 0x70, 0x56, 0x59, + 0x9b, 0x57, 0x12, 0xde, 0xd4, 0xfb, 0x49, 0x36, 0x08, 0x90, 0x6a, 0x9d, 0xb6, 0xe1, 0x3f, 0x6b, 0x1a, 0x21, 0x02, + 0x0b, 0xf3, 0xed, 0xf7, 0xee, 0x87, 0x43, 0x81, 0xbc, 0xb2, 0x0e, 0x0d, 0x1b, 0xf0, 0xdf, 0x85, 0x58, 0x9d, 0xd5, + 0x4e, 0x39, 0x2a, 0x45, 0x80, 0x77, 0xcc, 0xb5, 0x1b, 0x57, 0xd2, 0xb0, 0xb7, 0x49, 0xc5, 0x9c, 0x76, 0x69, 0xd8, + 0xce, 0xc8, 0x4f, 0x49, 0x3a, 0x78, 0x48, 0x9d, 0x8e, 0xdd, 0x07, 0xe7, 0x18, 0xb0, 0xbc, 0x31, 0x46, 0x7d, 0xe3, + 0x8c, 0xa8, 0x5c, 0xe1, 0x2e, 0x45, 0x58, 0xe3, 0xb5, 0x6e, 0xf1, 0x26, 0xe0, 0x55, 0x61, 0xbb, 0x6a, 0x6a, 0xb8, + 0xbb, 0x5a, 0xa3, 0xbd, 0x0e, 0x6a, 0xb2, 0xbf, 0xdb, 0x3d, 0x8a, 0x1f, 0x49, 0x38, 0xd9, 0xde, 0x3e, 0x8a, 0xff, + 0x52, 0x7a, 0xd0, 0x9d, 0xbe, 0x3b, 0xf7, 0x96, 0x12, 0x10, 0xe6, 0x32, 0xbc, 0xb4, 0x2f, 0x6e, 0x35, 0x5c, 0x46, + 0xf6, 0x8d, 0x06, 0x72, 0x9f, 0xd4, 0xd0, 0x97, 0xed, 0x8b, 0xb6, 0x2c, 0xf1, 0x2a, 0xde, 0x26, 0x44, 0x09, 0x59, + 0x08, 0x5e, 0x27, 0x6f, 0x2b, 0xcf, 0x10, 0x27, 0xa0, 0x0f, 0xf1, 0xd6, 0x6a, 0xf8, 0xbd, 0x5e, 0xbd, 0x3d, 0xb4, + 0xe3, 0xfa, 0x83, 0xbb, 0xfe, 0x39, 0x65, 0x8a, 0xee, 0xe8, 0xff, 0xa1, 0xa0, 0x4c, 0x9b, 0xaa, 0xe0, 0x09, 0xb5, + 0x90, 0xbb, 0x60, 0xd4, 0xe9, 0x38, 0x57, 0x3d, 0x50, 0x34, 0x52, 0xb4, 0xcf, 0xcc, 0xfc, 0x3c, 0xf8, 0x60, 0x99, + 0xb6, 0x9a, 0x90, 0x42, 0xa6, 0x5f, 0x44, 0x75, 0x30, 0x21, 0xdd, 0x00, 0x2f, 0xfd, 0xf8, 0xa5, 0xed, 0x06, 0x10, + 0x10, 0xf4, 0x32, 0xcd, 0xb6, 0x7c, 0x52, 0x05, 0xbe, 0x04, 0x4b, 0x09, 0x94, 0x38, 0xe9, 0xa1, 0xa0, 0xe3, 0x1c, + 0x06, 0x75, 0xaf, 0xf6, 0x75, 0xed, 0x61, 0x54, 0xee, 0xb1, 0x16, 0xfc, 0xe3, 0x3c, 0xdd, 0x87, 0xa6, 0xb2, 0x28, + 0x30, 0x06, 0xf7, 0x65, 0x20, 0x97, 0xa3, 0x93, 0x53, 0xa8, 0x9c, 0x76, 0xea, 0xd2, 0x8b, 0xfb, 0x02, 0xb5, 0x6b, + 0x0b, 0xb4, 0x57, 0x35, 0x34, 0x16, 0x22, 0x8e, 0xd6, 0x91, 0x93, 0xe7, 0xd2, 0x35, 0x86, 0x7b, 0x7a, 0xcf, 0xec, + 0x8e, 0x35, 0xa4, 0xcc, 0xca, 0x15, 0x9b, 0xd9, 0x51, 0x82, 0x88, 0x83, 0xc1, 0xaf, 0xe9, 0xf7, 0xd2, 0xdb, 0xf5, + 0x1b, 0x50, 0xaa, 0xc8, 0x0b, 0x97, 0x27, 0x8e, 0x5e, 0x7f, 0xa7, 0x67, 0xb4, 0x33, 0xec, 0xe1, 0x12, 0x17, 0x03, + 0xdb, 0x82, 0x6e, 0x67, 0xb1, 0x8e, 0xc9, 0x31, 0x50, 0x64, 0x87, 0x14, 0xda, 0x0a, 0x0f, 0x9c, 0xd3, 0xf4, 0x91, + 0xaa, 0x78, 0x59, 0x78, 0xf3, 0x42, 0x34, 0xb8, 0x44, 0xe5, 0xa8, 0xb4, 0xa9, 0xf8, 0xd4, 0x99, 0xd4, 0xff, 0x28, + 0x6e, 0x5b, 0x91, 0x6f, 0x7a, 0x73, 0x49, 0x41, 0x08, 0x80, 0xcb, 0x04, 0x76, 0xfe, 0x28, 0xb8, 0xe5, 0xb9, 0x34, + 0x88, 0xaf, 0x26, 0x86, 0xbf, 0xfe, 0x93, 0xbf, 0xdf, 0xf6, 0x0b, 0xc1, 0xd0, 0x6a, 0xf6, 0x26, 0xbf, 0x75, 0x57, + 0xa6, 0x87, 0xe9, 0xf6, 0xd0, 0x43, 0x5a, 0x73, 0xbe, 0x80, 0x02, 0x20, 0xc1, 0xb9, 0x36, 0xc2, 0x96, 0x31, 0x9f, + 0x11, 0x33, 0xfb, 0x52, 0x17, 0x59, 0x5e, 0x60, 0xe3, 0x1b, 0x9b, 0xd9, 0x26, 0x18, 0x86, 0xff, 0x7f, 0xdf, 0xe2, + 0xda, 0x62, 0xf5, 0x7c, 0x4c, 0x49, 0x60, 0x64, 0x41, 0x11, 0x12, 0x87, 0x4d, 0x14, 0x2b, 0xf2, 0xb9, 0x43, 0xe1, + 0xb2, 0x62, 0x6d, 0x3c, 0x72, 0x42, 0x4b, 0xa0, 0x63, 0x27, 0x1c, 0x6c, 0x0a, 0xd8, 0x65, 0xdc, 0xa7, 0x89, 0x06, + 0x2a, 0xf0, 0xf2, 0x6a, 0x26, 0xdf, 0x52, 0x8f, 0xfd, 0x5c, 0x17, 0xf8, 0x7b, 0x16, 0xdb, 0xc0, 0xdf, 0xc7, 0x47, + 0x86, 0x76, 0xf1, 0xf1, 0x54, 0x47, 0xbb, 0x04, 0xb8, 0x4c, 0xa1, 0x6d, 0xd4, 0x8d, 0x34, 0xbc, 0x26, 0x83, 0x05, + 0x50, 0x7d, 0xf5, 0xcf, 0x04, 0x5b, 0x41, 0x30, 0xf7, 0x07, 0xb8, 0x0f, 0x13, 0xe1, 0x50, 0x8e, 0xde, 0x4d, 0xa7, + 0xa7, 0xad, 0x6d, 0xbf, 0x77, 0xe7, 0xd3, 0x5e, 0x75, 0xc4, 0xd1, 0x9c, 0xcb, 0x49, 0xe7, 0x9b, 0xc5, 0xbb, 0xaa, + 0xb9, 0x11, 0xe0, 0x8e, 0xaa, 0xf2, 0x1c, 0x11, 0xd0, 0xf7, 0x7d, 0xc0, 0x89, 0xf7, 0xd9, 0x70, 0x88, 0x01, 0x4e, + 0xd5, 0x8c, 0x6d, 0xe8, 0xf3, 0xfb, 0xa1, 0x07, 0xbe, 0x6a, 0xc2, 0x07, 0x6a, 0xba, 0xce, 0x3d, 0xc4, 0xd4, 0x4d, + 0xad, 0x53, 0x3e, 0x70, 0x2f, 0x91, 0x65, 0x87, 0x9f, 0x13, 0x05, 0x46, 0x7d, 0x1d, 0xc5, 0x4d, 0x51, 0x6d, 0xfd, + 0x89, 0x68, 0x67, 0x25, 0x78, 0xd4, 0x47, 0x85, 0x84, 0x03, 0x96, 0xb1, 0x38, 0x25, 0xb6, 0xf6, 0xcc, 0xe2, 0x59, + 0x33, 0xc7, 0xb2, 0x2b, 0x0d, 0x5e, 0x77, 0xe5, 0x1e, 0xc2, 0x74, 0x32, 0x54, 0x0d, 0x5a, 0x63, 0x21, 0x60, 0xba, + 0x9d, 0x76, 0x25, 0xb1, 0x23, 0xa9, 0x87, 0x29, 0xe3, 0xfc, 0x7e, 0xfb, 0x1e, 0x69, 0x09, 0x5e, 0xdd, 0x7e, 0x5c, + 0x11, 0xca, 0x36, 0xa3, 0x4c, 0x0b, 0xe6, 0x9a, 0x6a, 0xd1, 0x67, 0x93, 0xab, 0xa9, 0x02, 0xee, 0x4a, 0x62, 0x9e, + 0xd9, 0xbc, 0x43, 0x40, 0x5e, 0xb3, 0x76, 0xc3, 0xbc, 0x2e, 0xf2, 0x9b, 0x7b, 0xcd, 0x7d, 0x65, 0x3c, 0x9c, 0xdd, + 0xff, 0x25, 0xef, 0x11, 0xc5, 0x26, 0x33, 0x71, 0x47, 0x67, 0x84, 0xb7, 0xc0, 0x51, 0x4f, 0x2f, 0xd4, 0xe7, 0x6e, + 0x00, 0x2c, 0xca, 0x42, 0x4b, 0xc8, 0x0b, 0xd7, 0xca, 0x5e, 0x90, 0xac, 0xe8, 0xf4, 0x5c, 0x84, 0x36, 0xde, 0xf4, + 0xd6, 0xc2, 0x63, 0xd3, 0xb1, 0x47, 0x52, 0xec, 0x1b, 0xe8, 0xba, 0xc7, 0x38, 0x56, 0x22, 0x55, 0x89, 0x5a, 0xb7, + 0xa9, 0x36, 0xf2, 0x10, 0x82, 0xcd, 0xe9, 0xad, 0xa6, 0x54, 0xfe, 0xab, 0x15, 0x25, 0x51, 0x46, 0x4d, 0xd1, 0xf0, + 0xe5, 0x7b, 0xdf, 0x4e, 0xf5, 0xed, 0xf2, 0x98, 0x1e, 0x56, 0x08, 0x4f, 0xdc, 0xae, 0x57, 0xa7, 0x39, 0xa7, 0xa7, + 0xc7, 0xc6, 0xbd, 0x52, 0x22, 0x35, 0x93, 0xd5, 0x8b, 0x5d, 0x45, 0x34, 0x1c, 0x35, 0x7f, 0x14, 0xc9, 0x6d, 0xdb, + 0xd4, 0xaa, 0x25, 0x17, 0x69, 0x16, 0x2e, 0xf0, 0xcb, 0x13, 0xa9, 0x37, 0xc6, 0x99, 0x84, 0xb9, 0x7d, 0x77, 0x9d, + 0xfb, 0xad, 0xbb, 0x62, 0x04, 0x86, 0x35, 0x3c, 0x2c, 0xde, 0x88, 0x3c, 0xdd, 0xaf, 0x83, 0x0e, 0xf7, 0x57, 0x8e, + 0xe9, 0xcc, 0x87, 0x0c, 0x66, 0x14, 0xf5, 0x1f, 0xd7, 0xc2, 0xf5, 0x93, 0x86, 0x5f, 0x32, 0x39, 0xed, 0xb5, 0x14, + 0x9f, 0x9e, 0x7e, 0x46, 0xd6, 0x24, 0x9a, 0x90, 0x72, 0x6a, 0x5e, 0x36, 0x8f, 0xe6, 0xd4, 0x3e, 0x37, 0x93, 0x96, + 0xce, 0x24, 0x5b, 0x8b, 0x8b, 0x54, 0x95, 0x5c, 0x74, 0xae, 0x81, 0x44, 0x53, 0xab, 0x71, 0x73, 0x31, 0x17, 0xda, + 0xa7, 0xcd, 0x8f, 0x60, 0xf3, 0x2e, 0xe3, 0xe0, 0x91, 0x4d, 0x54, 0x4d, 0x21, 0xe6, 0x91, 0xc0, 0x6d, 0x4e, 0xc9, + 0x77, 0xb9, 0x66, 0xe0, 0x01, 0x26, 0xdc, 0xd6, 0x00, 0x94, 0x1a, 0x94, 0x8f, 0xae, 0x00, 0x97, 0x7a, 0x70, 0xa4, + 0xca, 0x2e, 0x2b, 0xef, 0xe9, 0x0e, 0xbe, 0xe4, 0x27, 0xc5, 0x18, 0x0b, 0xcf, 0xd6, 0x6d, 0xe8, 0x4f, 0x42, 0x83, + 0xad, 0x6a, 0xe5, 0x23, 0x1c, 0xf8, 0x68, 0x9f, 0xd0, 0x72, 0x62, 0x7e, 0x92, 0xdb, 0xf5, 0xa5, 0x22, 0x8b, 0x30, + 0xb6, 0x43, 0x23, 0x2d, 0x5c, 0x02, 0xe3, 0x1e, 0x74, 0xea, 0x18, 0xdb, 0xb6, 0xf7, 0xd8, 0xb7, 0x55, 0xc2, 0xbf, + 0xdc, 0x8f, 0xad, 0x95, 0xa9, 0x7f, 0xf5, 0x31, 0x0d, 0x5d, 0x24, 0xfc, 0xf8, 0x2a, 0xb8, 0xfc, 0x37, 0x4b, 0xf9, + 0x90, 0xc3, 0x7e, 0x3b, 0xd7, 0xc5, 0xc0, 0xc3, 0xbd, 0x1b, 0x96, 0x41, 0x3b, 0xfc, 0x31, 0xcf, 0x6f, 0x3a, 0xed, + 0xf7, 0xe8, 0xf5, 0x95, 0x85, 0x2f, 0x56, 0x77, 0x51, 0xfa, 0x4b, 0x51, 0x23, 0x3c, 0x01, 0xaf, 0xc9, 0x81, 0x99, + 0x8e, 0x8a, 0xbd, 0x47, 0xd3, 0xe5, 0x57, 0xeb, 0x27, 0xa9, 0x3f, 0x9d, 0xec, 0x5e, 0x02, 0xe7, 0xeb, 0xc2, 0x6a, + 0x35, 0x79, 0x3c, 0xb4, 0x3c, 0x61, 0x41, 0xdf, 0x68, 0x0a, 0x7d, 0x25, 0x4f, 0xeb, 0x34, 0x68, 0x03, 0xb3, 0x1c, + 0xb4, 0x27, 0x55, 0x2c, 0xdc, 0x1c, 0xc2, 0xeb, 0xb8, 0xe1, 0xcd, 0x03, 0x97, 0x82, 0x79, 0x78, 0x18, 0x47, 0x0a, + 0xd3, 0xff, 0xf5, 0x1e, 0x18, 0x0a, 0x00, 0x86, 0x39, 0xc2, 0x5d, 0x3e, 0x25, 0xa7, 0x6a, 0x6c, 0xd9, 0xa3, 0x57, + 0xc0, 0xf4, 0xe9, 0xa3, 0x7d, 0xe4, 0xf7, 0xdc, 0x53, 0xc5, 0xd2, 0x14, 0x93, 0x22, 0xfb, 0xf4, 0x16, 0xe4, 0x0f, + 0x99, 0x94, 0xa0, 0x01, 0x1d, 0xc0, 0x1b, 0x5c, 0x1b, 0xb3, 0x00, 0x35, 0xa0, 0x13, 0xdc, 0xe4, 0xaa, 0xe6, 0x90, + 0x49, 0x8d, 0xdd, 0x0c, 0xf5, 0x09, 0xc8, 0xa7, 0xbe, 0x14, 0x0b, 0x33, 0xdf, 0xe4, 0x18, 0x54, 0x82, 0x65, 0xd6, + 0xf4, 0x86, 0x0c, 0xcd, 0x8c, 0xfa, 0x9a, 0x42, 0x83, 0x14, 0x40, 0xf5, 0x03, 0xc6, 0x52, 0xea, 0x99, 0xb9, 0x36, + 0x86, 0x17, 0x90, 0xab, 0x1a, 0x04, 0xa2, 0x43, 0xf4, 0x73, 0xa2, 0xbc, 0x5a, 0xf0, 0x05, 0x01, 0x66, 0x4a, 0xf9, + 0xaf, 0xf6, 0x22, 0xf8, 0xd9, 0x03, 0xe8, 0xd9, 0x33, 0x59, 0xef, 0xfb, 0xd1, 0x7c, 0x60, 0xaf, 0xf7, 0x89, 0xba, + 0xa1, 0xf3, 0xa9, 0x97, 0x76, 0xed, 0xe2, 0xb0, 0x26, 0x55, 0x9e, 0x6e, 0xd4, 0x17, 0x39, 0xd9, 0xe1, 0x96, 0x53, + 0xeb, 0xd1, 0x62, 0x82, 0x42, 0x61, 0xb3, 0x3a, 0x32, 0x15, 0x8b, 0xa0, 0x10, 0x99, 0x1e, 0x84, 0x88, 0x62, 0x5d, + 0xec, 0x35, 0xa3, 0x66, 0x88, 0x54, 0xc6, 0x46, 0x92, 0x30, 0x96, 0xf8, 0x10, 0xd3, 0x0b, 0x50, 0x80, 0xaf, 0x2d, + 0x35, 0x2f, 0xba, 0xc4, 0x39, 0x27, 0x68, 0x11, 0x62, 0x19, 0x52, 0xd2, 0xef, 0xbd, 0xb6, 0xc3, 0xeb, 0x0f, 0x58, + 0xbb, 0x81, 0x34, 0xdf, 0x30, 0x25, 0xe9, 0xa6, 0x9c, 0x7d, 0xb1, 0xc5, 0xdd, 0x30, 0x85, 0xc9, 0x04, 0xaa, 0x14, + 0x5e, 0x38, 0x29, 0x3e, 0x37, 0xc9, 0xe0, 0x40, 0x21, 0xfa, 0xc9, 0x13, 0x6f, 0x35, 0xb2, 0x61, 0xd6, 0x50, 0xbe, + 0xe4, 0xad, 0x04, 0x5e, 0x0d, 0xb8, 0xc6, 0x3e, 0x42, 0xf2, 0x78, 0x3c, 0xee, 0x21, 0xe8, 0xdb, 0xf1, 0x5e, 0xf6, + 0x60, 0x24, 0x36, 0x88, 0x1f, 0xa3, 0xa6, 0x2c, 0xb1, 0xe5, 0x25, 0x9b, 0x43, 0x90, 0x58, 0xc6, 0x84, 0x69, 0x6b, + 0x69, 0x67, 0x99, 0x39, 0x03, 0xc5, 0x2d, 0xee, 0x98, 0x1a, 0x84, 0xeb, 0x2e, 0x14, 0xb3, 0x2d, 0x23, 0x85, 0x9d, + 0x3e, 0x15, 0x2b, 0xbe, 0x2c, 0x10, 0x09, 0x8d, 0x62, 0x51, 0x56, 0x38, 0xaa, 0xf5, 0x56, 0xc0, 0xd8, 0x40, 0x2d, + 0xd4, 0x30, 0x52, 0xae, 0xd0, 0xec, 0xd5, 0xe4, 0x16, 0x6f, 0xd7, 0xec, 0xd1, 0x54, 0xc6, 0x48, 0xa3, 0xed, 0xc0, + 0xd1, 0xf4, 0x96, 0xa3, 0x00, 0xc7, 0x18, 0xa4, 0x9f, 0x2e, 0xbf, 0xb1, 0x9d, 0x33, 0x13, 0x84, 0x62, 0xb2, 0x45, + 0xb0, 0x4f, 0xd7, 0x03, 0x80, 0x99, 0x32, 0x99, 0x60, 0x1e, 0xc2, 0xbb, 0xfc, 0xd8, 0xcf, 0x08, 0x57, 0x23, 0xe0, + 0xe3, 0xc8, 0x70, 0x3a, 0xdf, 0x2b, 0x6a, 0x52, 0x5b, 0x60, 0x5a, 0x50, 0xf4, 0x07, 0x25, 0x8b, 0x26, 0x3b, 0xc5, + 0xb7, 0xa8, 0x1c, 0xd9, 0xc3, 0x21, 0xff, 0x83, 0xb3, 0xfd, 0xd6, 0xd8, 0xf2, 0x46, 0x1e, 0xe0, 0x71, 0xd5, 0x76, + 0x2f, 0x1b, 0x96, 0x93, 0x09, 0x1b, 0xdb, 0xf5, 0x67, 0x34, 0x7f, 0x84, 0x46, 0x4e, 0xf9, 0x66, 0xf3, 0x53, 0xc0, + 0x08, 0x0b, 0x96, 0x34, 0xa9, 0x37, 0xa7, 0x31, 0xf8, 0xe7, 0x0e, 0xb2, 0x3a, 0x7a, 0xc3, 0xaa, 0xeb, 0x4d, 0x78, + 0x42, 0x96, 0xe2, 0x5f, 0x1b, 0x6c, 0x57, 0xe7, 0x43, 0x1c, 0x9a, 0x76, 0xd7, 0xec, 0xb8, 0x25, 0x25, 0xc4, 0xef, + 0x45, 0x2e, 0xd5, 0xe4, 0x2d, 0x1e, 0x66, 0x79, 0xcb, 0x2d, 0x7d, 0x02, 0xd7, 0xed, 0xb7, 0x62, 0x79, 0xb9, 0xba, + 0x3d, 0x27, 0x38, 0x93, 0xc5, 0x85, 0xf8, 0x76, 0xc1, 0x35, 0xc3, 0xaa, 0xf6, 0x65, 0xee, 0x16, 0x30, 0x03, 0x83, + 0x70, 0xb8, 0xe3, 0x0d, 0x26, 0x42, 0x86, 0xdb, 0xc1, 0x05, 0x5e, 0xea, 0x5f, 0xa5, 0xa6, 0xef, 0xba, 0x9a, 0xe1, + 0x7d, 0xe2, 0x94, 0x57, 0x82, 0xc8, 0xd1, 0x05, 0x4e, 0xc8, 0x2e, 0x23, 0xbf, 0x42, 0x97, 0x9d, 0x0d, 0x20, 0x2e, + 0xbf, 0x2a, 0xee, 0x97, 0x9f, 0xb9, 0x59, 0x20, 0x97, 0xab, 0x95, 0xcd, 0x9c, 0x97, 0xe8, 0xb7, 0x83, 0x71, 0x4a, + 0xce, 0x87, 0xed, 0x77, 0xf3, 0xcc, 0x61, 0xff, 0x1d, 0x21, 0xac, 0x02, 0x7b, 0xef, 0xee, 0xeb, 0xc8, 0xac, 0x2b, + 0x5f, 0xf0, 0x9e, 0xc3, 0xf6, 0x3b, 0xc9, 0x8e, 0x29, 0xa7, 0x06, 0x28, 0xb4, 0x0a, 0x54, 0x6a, 0x07, 0x0d, 0x6b, + 0x5a, 0x43, 0x45, 0x9f, 0xd9, 0x59, 0xcc, 0x7f, 0xa6, 0x0b, 0x73, 0x9c, 0x64, 0xff, 0x20, 0xfe, 0x33, 0x0e, 0x01, + 0xd1, 0x73, 0x0e, 0x1b, 0x6e, 0xa6, 0x9c, 0xea, 0x95, 0x63, 0x5c, 0xd7, 0x10, 0x17, 0x58, 0xe1, 0x39, 0x86, 0x95, + 0xda, 0xfc, 0xe7, 0x7a, 0x56, 0x37, 0x9c, 0x6c, 0x23, 0x71, 0xfc, 0x31, 0xcb, 0xac, 0x61, 0x23, 0x24, 0xd6, 0xfa, + 0x0c, 0xfb, 0xf2, 0x37, 0x1c, 0x4f, 0xb2, 0xdb, 0x5e, 0xd9, 0x9e, 0x40, 0x08, 0xee, 0xac, 0x42, 0x3d, 0x82, 0x0d, + 0xf9, 0xdf, 0x2c, 0x4a, 0x4d, 0x38, 0xbe, 0xff, 0x74, 0xc3, 0x59, 0x43, 0xe7, 0x0a, 0xaa, 0x0e, 0x57, 0x40, 0xe7, + 0xd0, 0x5d, 0xaa, 0x2e, 0x76, 0x8a, 0xe9, 0xff, 0x2a, 0x0d, 0xd3, 0x33, 0xa7, 0x39, 0x9d, 0xbf, 0x79, 0xd5, 0x42, + 0x67, 0xa7, 0x43, 0x00, 0xfc, 0x30, 0xfd, 0xaa, 0xb8, 0x12, 0xb9, 0xaf, 0xb8, 0xef, 0x9d, 0xc5, 0xc8, 0x79, 0xa3, + 0xe0, 0x91, 0xca, 0x98, 0xc9, 0xaa, 0x11, 0x0d, 0x2c, 0xa0, 0x5c, 0xca, 0xc5, 0xb6, 0x2f, 0xfd, 0xfe, 0x7f, 0x23, + 0x71, 0xd1, 0x39, 0x7d, 0x47, 0x68, 0xf4, 0x87, 0x4b, 0xbd, 0xef, 0x17, 0xef, 0x7d, 0xcf, 0x08, 0x49, 0xad, 0xb6, + 0xbb, 0xd2, 0xcc, 0x5a, 0x4c, 0x10, 0xd7, 0xf4, 0x18, 0x90, 0xa3, 0x64, 0x3e, 0x6b, 0x00, 0x6d, 0x15, 0xb0, 0x43, + 0x0a, 0x43, 0xb2, 0x17, 0xc4, 0x96, 0x25, 0x05, 0x78, 0x24, 0x31, 0xd1, 0xb6, 0x59, 0x67, 0x3e, 0x31, 0x88, 0xb2, + 0x9a, 0x43, 0xbb, 0x43, 0xd9, 0x70, 0xa4, 0xf6, 0x4a, 0x46, 0x08, 0x1a, 0x9f, 0x17, 0x70, 0xb1, 0x9c, 0x62, 0x2c, + 0xa8, 0xa6, 0x56, 0x84, 0xe0, 0xfc, 0xd0, 0x90, 0x1a, 0x72, 0xec, 0x31, 0x7b, 0x41, 0xc3, 0x91, 0xa4, 0x7c, 0xb8, + 0xad, 0xb9, 0xd0, 0x62, 0x59, 0x65, 0xbb, 0x26, 0x36, 0xe7, 0x77, 0xdb, 0x81, 0x7b, 0xfc, 0x3b, 0x9c, 0xbf, 0xa8, + 0x75, 0x4f, 0xe4, 0x5e, 0x53, 0x55, 0x03, 0xdb, 0x36, 0xdb, 0x0c, 0xd9, 0xbd, 0xb4, 0xfb, 0x93, 0xde, 0xb7, 0xbc, + 0x59, 0x30, 0x86, 0xc5, 0x16, 0xa3, 0xca, 0x15, 0x3d, 0x2a, 0x7d, 0xae, 0xb2, 0x1b, 0xf6, 0x22, 0x23, 0xc2, 0x88, + 0x22, 0xa4, 0x73, 0x1b, 0xc2, 0xfc, 0xb2, 0x37, 0x6a, 0x16, 0x80, 0xe8, 0xf6, 0xb9, 0x15, 0xd4, 0x62, 0xfd, 0x6d, + 0x2f, 0x1b, 0xc5, 0x1b, 0xcc, 0x71, 0xe4, 0x18, 0xd3, 0x66, 0x63, 0x43, 0x89, 0x93, 0x39, 0x97, 0x90, 0x23, 0xd2, + 0x1b, 0x2a, 0x2a, 0xd9, 0x87, 0x37, 0xae, 0x3a, 0x17, 0x4a, 0x53, 0x9b, 0x24, 0x16, 0xb8, 0xdc, 0xd8, 0xac, 0x79, + 0x59, 0x0e, 0xe9, 0xf8, 0x31, 0x95, 0x30, 0x8d, 0x58, 0x73, 0xa9, 0xb7, 0xea, 0x0d, 0xda, 0x4f, 0x39, 0x95, 0xbc, + 0x8d, 0x0f, 0xee, 0x5e, 0x8b, 0xb0, 0x3d, 0xcc, 0xc8, 0x1c, 0xcc, 0xbc, 0x28, 0xe1, 0xab, 0xc1, 0xb0, 0x99, 0x94, + 0xd3, 0xf0, 0xa0, 0x1a, 0xc6, 0x4f, 0xda, 0xf3, 0x88, 0x8a, 0x1d, 0xfa, 0xf4, 0x94, 0xdf, 0xb8, 0x1c, 0x75, 0x34, + 0x42, 0x9a, 0x37, 0x32, 0x86, 0x7e, 0x10, 0x7c, 0xbc, 0xc8, 0x01, 0x7a, 0x60, 0x4f, 0x44, 0x89, 0x4a, 0xf8, 0x71, + 0xd3, 0x6e, 0xd5, 0x1f, 0x62, 0xf3, 0x58, 0x4e, 0xbc, 0x20, 0xd4, 0x7a, 0xd2, 0xff, 0xb7, 0x8c, 0x37, 0x82, 0xea, + 0x25, 0x7a, 0x53, 0x6d, 0xe8, 0x52, 0xcc, 0xa7, 0x47, 0x27, 0x16, 0x36, 0x06, 0xc3, 0x3c, 0x43, 0xf0, 0x97, 0x02, + 0x0f, 0x4e, 0x5a, 0x89, 0xe7, 0x9e, 0x32, 0xef, 0x25, 0xf6, 0xfb, 0x85, 0x3b, 0x71, 0x26, 0x75, 0xf0, 0x72, 0x9c, + 0x5b, 0xa3, 0x27, 0x98, 0x77, 0x1d, 0x3c, 0xff, 0x56, 0xfb, 0x12, 0x73, 0x3f, 0xef, 0x94, 0xed, 0xc3, 0x79, 0xf1, + 0x30, 0xc5, 0x73, 0x6f, 0x39, 0xf4, 0x7a, 0x14, 0xd3, 0x89, 0x66, 0xab, 0x87, 0x54, 0x6a, 0xf5, 0xb3, 0x6f, 0x82, + 0x13, 0xff, 0xfc, 0x93, 0xc7, 0xfa, 0xac, 0x54, 0x9c, 0x01, 0x62, 0x63, 0xb3, 0x4e, 0x13, 0xc7, 0x42, 0x56, 0x35, + 0x21, 0x5a, 0xe2, 0x49, 0xbc, 0x4e, 0xe3, 0x3d, 0xee, 0xf4, 0xea, 0x87, 0xc5, 0x1b, 0xaf, 0xd5, 0xc2, 0x94, 0x73, + 0x0f, 0x96, 0xda, 0xc5, 0x66, 0x29, 0xbc, 0xef, 0xa4, 0xad, 0xec, 0x22, 0x9e, 0x79, 0x34, 0xd9, 0x0f, 0xb2, 0xf7, + 0x81, 0x11, 0x78, 0x26, 0xab, 0x56, 0x1a, 0xd8, 0x22, 0x2c, 0x2c, 0x9d, 0xa1, 0x77, 0x77, 0x77, 0xc8, 0x9f, 0x68, + 0xc8, 0xa7, 0xac, 0xa7, 0xf0, 0xbb, 0x9e, 0xc9, 0xc3, 0xf0, 0xf7, 0x35, 0xd1, 0x50, 0xe6, 0xa2, 0x29, 0xcc, 0x5d, + 0xcd, 0xa6, 0xc4, 0x8c, 0x41, 0xf9, 0xaf, 0x51, 0x96, 0xbb, 0x37, 0x72, 0x77, 0x0b, 0x42, 0x7f, 0x91, 0x4a, 0x0e, + 0xe9, 0xdd, 0xd1, 0x0b, 0x78, 0xb3, 0xde, 0x50, 0x5d, 0xb4, 0xb8, 0xe7, 0x1f, 0x7d, 0xde, 0xfc, 0x0f, 0x8d, 0xe9, + 0xff, 0xda, 0xf9, 0xee, 0x0e, 0x51, 0x48, 0x25, 0xbf, 0xcf, 0xc0, 0xcb, 0x06, 0x8b, 0xfa, 0xc4, 0xb6, 0xe3, 0x07, + 0xf3, 0x60, 0x46, 0x4b, 0x93, 0x0a, 0xcd, 0x7e, 0xa0, 0x9f, 0xd7, 0x9c, 0xc3, 0xd1, 0x11, 0x08, 0x7e, 0x46, 0x6f, + 0xbb, 0x20, 0xe9, 0x0f, 0xb4, 0x93, 0x40, 0x4e, 0x28, 0x42, 0xf6, 0xf6, 0x44, 0x65, 0x13, 0x3f, 0x0f, 0x57, 0x2d, + 0xd0, 0x13, 0x70, 0x3f, 0xe3, 0x4d, 0xd3, 0x8a, 0x94, 0x82, 0x4b, 0x03, 0xc4, 0x7c, 0x38, 0x0b, 0x40, 0x37, 0x79, + 0xce, 0x87, 0x91, 0x30, 0x01, 0xc8, 0x0e, 0xfd, 0x2f, 0xd0, 0x6a, 0x8a, 0x80, 0x35, 0x09, 0x01, 0xf7, 0x08, 0x28, + 0xd7, 0x46, 0x2d, 0xd1, 0x8e, 0x13, 0x54, 0xeb, 0xfb, 0xd7, 0x71, 0xd1, 0x66, 0x2a, 0x60, 0xe4, 0x85, 0xd2, 0x10, + 0x31, 0xc7, 0x5a, 0xcb, 0x0f, 0xb4, 0xd0, 0x6d, 0xa1, 0xff, 0x7d, 0x0a, 0x88, 0xbe, 0x39, 0x47, 0x49, 0x87, 0x0a, + 0xb8, 0x05, 0xde, 0x67, 0x1f, 0x02, 0x6c, 0x3b, 0xf1, 0x16, 0xc0, 0x89, 0xbc, 0x40, 0x43, 0xec, 0x09, 0x5f, 0x38, + 0xe3, 0x01, 0x81, 0xca, 0xae, 0x8a, 0xee, 0xdc, 0x16, 0xbb, 0x92, 0x46, 0x41, 0xe3, 0xba, 0x1f, 0xf1, 0x29, 0xf0, + 0xce, 0x8e, 0x42, 0x6c, 0x6c, 0xb8, 0xd6, 0xb5, 0x0c, 0x4c, 0x23, 0xd6, 0x80, 0x22, 0xfb, 0x10, 0x78, 0x8d, 0x83, + 0x97, 0x69, 0x29, 0xc2, 0x85, 0xde, 0xa5, 0xce, 0xea, 0x77, 0x0f, 0xb3, 0x7a, 0x9b, 0x6b, 0x0b, 0x16, 0xa3, 0x56, + 0x34, 0xa2, 0x14, 0xfe, 0x09, 0x59, 0x68, 0x39, 0xe0, 0x69, 0x11, 0x86, 0x93, 0x6d, 0xcf, 0x1e, 0x6a, 0xe6, 0x20, + 0x7e, 0xfd, 0x9d, 0x87, 0xb6, 0x91, 0xc2, 0x6c, 0xd3, 0x93, 0x6d, 0xb4, 0x22, 0xc8, 0xd6, 0xac, 0xbb, 0xe0, 0xd7, + 0x18, 0x4f, 0xde, 0xac, 0x8a, 0x52, 0x68, 0x8a, 0x8c, 0x02, 0x9e, 0x6f, 0x9a, 0x60, 0xdc, 0x80, 0x63, 0x6d, 0x5c, + 0xc0, 0x5d, 0xcc, 0x09, 0xd1, 0x9d, 0x89, 0x68, 0x10, 0xf9, 0x00, 0x36, 0x9f, 0xf3, 0x00, 0x8b, 0x4e, 0xd7, 0xae, + 0xad, 0x1f, 0xff, 0xcb, 0xff, 0xbe, 0x4b, 0x65, 0xd1, 0x86, 0x5b, 0xcc, 0x0c, 0x6d, 0x2e, 0x88, 0x9c, 0x0c, 0x2b, + 0x61, 0xe6, 0x97, 0x80, 0x5d, 0x9c, 0xbe, 0xd4, 0x99, 0x42, 0x1a, 0x3e, 0xcb, 0x1b, 0x35, 0x79, 0x59, 0xc8, 0x1f, + 0x95, 0xc4, 0x91, 0xad, 0x04, 0x6d, 0xee, 0x12, 0x67, 0xad, 0x28, 0xac, 0xf7, 0xd2, 0x86, 0x51, 0x8d, 0x77, 0x85, + 0xd3, 0x5e, 0xee, 0x83, 0x1c, 0xcf, 0x41, 0xd4, 0x1d, 0xb5, 0xc3, 0xe9, 0x31, 0x5d, 0x72, 0xb4, 0xa1, 0x95, 0xd2, + 0xac, 0x22, 0x81, 0x50, 0xca, 0x76, 0xfe, 0x61, 0x39, 0x54, 0x3e, 0xbf, 0x9a, 0x9f, 0x31, 0xd9, 0xe0, 0xc0, 0x99, + 0xfc, 0xe3, 0xaa, 0x8d, 0x8c, 0xeb, 0x9d, 0x24, 0x80, 0xf3, 0x4f, 0xff, 0x38, 0x60, 0xf0, 0x77, 0x4d, 0xce, 0x39, + 0xfe, 0x60, 0x5a, 0xf0, 0xbe, 0x83, 0x3f, 0xc1, 0x3b, 0x99, 0x98, 0x23, 0x54, 0xb9, 0x01, 0x4b, 0xb0, 0x29, 0xd7, + 0xb9, 0xde, 0xd5, 0xd2, 0xd8, 0xd6, 0x85, 0x4a, 0x01, 0x61, 0x2c, 0xfd, 0x40, 0x34, 0x40, 0xdd, 0x53, 0xeb, 0x46, + 0xd0, 0x79, 0xfb, 0x68, 0x23, 0x6f, 0x6f, 0x0c, 0xdd, 0xcf, 0x76, 0xd0, 0xe5, 0xea, 0x4d, 0x0d, 0x58, 0x09, 0xa3, + 0xe0, 0x59, 0xcb, 0x57, 0x04, 0xd0, 0x08, 0x7d, 0x80, 0x82, 0x6e, 0x1c, 0xe2, 0xb6, 0x3b, 0x48, 0xd7, 0x21, 0x7d, + 0xcf, 0x7b, 0x10, 0xae, 0xd5, 0xdc, 0x3c, 0xab, 0xfa, 0x6c, 0xc6, 0x5a, 0xdc, 0xcf, 0xb2, 0x3a, 0xd6, 0x90, 0x3c, + 0xfe, 0xee, 0xd1, 0x76, 0xd5, 0x38, 0xee, 0x67, 0x17, 0x68, 0xfb, 0x4f, 0x93, 0xa6, 0xdf, 0x69, 0x48, 0x18, 0x0d, + 0xf4, 0x7c, 0xe3, 0xd4, 0x52, 0x74, 0x06, 0x04, 0xa6, 0x9b, 0xc1, 0x0c, 0x83, 0xdb, 0x9d, 0xb8, 0x23, 0x68, 0x31, + 0xfb, 0x4b, 0x8c, 0x38, 0xa7, 0x3f, 0x77, 0x5f, 0x6e, 0x35, 0x93, 0x3c, 0xda, 0x9e, 0x52, 0x0a, 0xd0, 0xb2, 0xd7, + 0x66, 0xb8, 0x7a, 0xc5, 0xac, 0xcf, 0x0a, 0x41, 0x5e, 0x94, 0xd1, 0xa1, 0xfb, 0xc6, 0xc8, 0x1f, 0x45, 0xe6, 0x55, + 0x7f, 0xa8, 0x46, 0xc5, 0x79, 0xa3, 0xbe, 0x91, 0xe3, 0xa7, 0xe6, 0xb1, 0x52, 0x79, 0x00, 0x99, 0x6f, 0x88, 0x8d, + 0x5b, 0x86, 0x1d, 0xc9, 0xf5, 0xb3, 0x69, 0x63, 0x52, 0x8b, 0x37, 0xfe, 0x65, 0x86, 0x4a, 0xa2, 0x44, 0xc1, 0x92, + 0xaa, 0x52, 0x9f, 0xcb, 0x95, 0xd4, 0xca, 0xe6, 0x8e, 0x50, 0x68, 0x55, 0x76, 0xa8, 0xa4, 0xa7, 0x38, 0x52, 0x6c, + 0x8c, 0x10, 0x91, 0x96, 0xf4, 0x80, 0x25, 0x5f, 0xdc, 0x8b, 0x41, 0xb0, 0xc9, 0x34, 0xcc, 0x18, 0x04, 0xe4, 0x45, + 0x09, 0x4a, 0xb5, 0xda, 0x14, 0x3a, 0xc2, 0x83, 0xfd, 0xb5, 0x5a, 0x85, 0xe9, 0xb9, 0x57, 0x95, 0xed, 0x45, 0x9d, + 0xb4, 0xf3, 0x31, 0x10, 0x0a, 0x1d, 0x20, 0xb1, 0x51, 0x6f, 0x97, 0x79, 0xfc, 0x38, 0x86, 0x89, 0x3a, 0x40, 0xcf, + 0x9d, 0x8b, 0x57, 0xba, 0xbf, 0x7a, 0x89, 0x52, 0x66, 0xa4, 0x39, 0xbe, 0xa2, 0x34, 0x5a, 0x20, 0x6f, 0xb0, 0xd3, + 0xfc, 0x71, 0x7d, 0xf9, 0xe1, 0x80, 0x52, 0xe8, 0x23, 0xe6, 0xa4, 0x4d, 0x01, 0x75, 0x13, 0xfb, 0xbc, 0x0d, 0xa6, + 0xf3, 0x98, 0x0d, 0xab, 0xfb, 0xad, 0xed, 0x61, 0xd9, 0x33, 0xe1, 0xd5, 0xf0, 0x5b, 0xd9, 0x30, 0x68, 0xc7, 0xb0, + 0x50, 0x61, 0xd9, 0x30, 0xbc, 0xd6, 0x4d, 0xf7, 0x40, 0xa1, 0xe6, 0xc8, 0x79, 0x8e, 0x57, 0x97, 0xd5, 0xdb, 0xf3, + 0xf1, 0xa4, 0x34, 0xa1, 0xff, 0xf1, 0x66, 0x0d, 0x2a, 0x2a, 0x37, 0x0c, 0xff, 0x06, 0x17, 0xcc, 0xfb, 0x55, 0xba, + 0xbb, 0x95, 0x9a, 0xb6, 0xc9, 0xa6, 0x0a, 0xff, 0xfa, 0x37, 0x6a, 0x26, 0xd7, 0x4a, 0x5b, 0xde, 0x81, 0x9f, 0x52, + 0xed, 0x99, 0xcc, 0x04, 0x5b, 0xdf, 0xbe, 0x91, 0x59, 0x0f, 0xcb, 0x6c, 0xdf, 0x22, 0x12, 0x93, 0x95, 0xca, 0x78, + 0xb8, 0xb1, 0x37, 0x6b, 0x76, 0xb3, 0xe0, 0x6a, 0x82, 0xbf, 0x7e, 0x76, 0x5f, 0xcb, 0x4d, 0x42, 0xc4, 0x21, 0x4a, + 0x25, 0xd4, 0x32, 0x52, 0x9d, 0xba, 0x79, 0x22, 0x78, 0x70, 0xbe, 0x3c, 0x4d, 0xe4, 0xb1, 0x6c, 0xf9, 0x0a, 0x5f, + 0x87, 0x21, 0xa3, 0xf8, 0xf2, 0x15, 0xd3, 0xf4, 0x46, 0xfe, 0x6e, 0x78, 0xe6, 0xb5, 0x14, 0xe9, 0x84, 0xb1, 0x5c, + 0xa4, 0xca, 0x72, 0x34, 0x10, 0xe6, 0xd8, 0x4c, 0x29, 0xa4, 0x7d, 0xd5, 0x01, 0xb7, 0x0d, 0x1d, 0x51, 0x1e, 0x25, + 0xd6, 0xe1, 0x7f, 0xef, 0x07, 0xe2, 0x7e, 0x26, 0x4c, 0xe4, 0x71, 0xca, 0x9b, 0xa9, 0x1c, 0x03, 0x93, 0xe1, 0x5c, + 0x6d, 0x7d, 0x84, 0xed, 0x8b, 0x47, 0xbf, 0x31, 0xed, 0xa5, 0x43, 0x49, 0xa3, 0x69, 0xcd, 0x42, 0xc0, 0x95, 0x85, + 0x70, 0x1e, 0xaa, 0x90, 0x6c, 0xaf, 0x6c, 0x20, 0x70, 0xe5, 0x69, 0xb1, 0x1e, 0x29, 0x9f, 0xb4, 0xba, 0x78, 0x78, + 0xfb, 0x68, 0x4c, 0xda, 0xd6, 0xd1, 0xb7, 0x5e, 0xb5, 0x6c, 0xd1, 0x48, 0x66, 0x85, 0x68, 0xb5, 0xa2, 0x4f, 0x2d, + 0x37, 0x3c, 0x60, 0x86, 0x87, 0xdb, 0x67, 0x81, 0x80, 0x68, 0xda, 0x93, 0xf0, 0xc4, 0xf5, 0xfd, 0xa4, 0x9b, 0x43, + 0x1b, 0x5e, 0xc5, 0x2e, 0xb8, 0xc8, 0xdc, 0x70, 0x60, 0xdb, 0x29, 0x5d, 0xb3, 0xad, 0x85, 0x2f, 0x04, 0x92, 0xaf, + 0x30, 0x9a, 0xe2, 0x72, 0x4c, 0xe8, 0x4a, 0x87, 0x75, 0x59, 0x88, 0x00, 0x6d, 0xc9, 0x86, 0xb4, 0xc9, 0x4f, 0x16, + 0x69, 0xe8, 0x25, 0xc9, 0x75, 0xfb, 0x5e, 0x72, 0x60, 0xa4, 0xf8, 0xe6, 0x6a, 0x37, 0x92, 0x15, 0x4e, 0xb4, 0x5e, + 0x65, 0x4c, 0xd3, 0x4f, 0x82, 0x5f, 0x53, 0x6e, 0x0f, 0xf9, 0x30, 0xad, 0x96, 0x25, 0x3b, 0x36, 0x77, 0xd6, 0x1c, + 0x2e, 0xdc, 0x71, 0xb0, 0xe3, 0x90, 0x31, 0x3b, 0x73, 0x1a, 0xe6, 0x6e, 0x8a, 0x37, 0x61, 0xa4, 0x80, 0x2f, 0xf1, + 0xd1, 0xa4, 0x05, 0xf0, 0xc1, 0x8d, 0x27, 0x00, 0x9b, 0x3a, 0xdb, 0x49, 0x42, 0x92, 0xaa, 0x10, 0xcb, 0x04, 0x5e, + 0x48, 0xb9, 0x53, 0x33, 0xd6, 0x64, 0x59, 0x16, 0xd5, 0x37, 0x46, 0x70, 0xf1, 0x25, 0x2f, 0x08, 0x52, 0x27, 0xa6, + 0x00, 0x68, 0x8a, 0x7d, 0x73, 0x11, 0x74, 0x54, 0x96, 0xbd, 0x1f, 0xbf, 0x45, 0xc7, 0x5b, 0x7b, 0xfe, 0x95, 0x66, + 0x80, 0x29, 0x10, 0x4c, 0x37, 0xcc, 0x83, 0x0d, 0x3d, 0x8c, 0x58, 0x91, 0xde, 0xb2, 0x2c, 0x03, 0x17, 0xc2, 0x0b, + 0xdf, 0x5e, 0x2a, 0x92, 0x70, 0x07, 0x0b, 0x2f, 0xfe, 0x5a, 0xc4, 0xdf, 0x69, 0x2f, 0xa7, 0x97, 0x31, 0x93, 0x60, + 0x72, 0xa2, 0xc0, 0x2e, 0x44, 0x4a, 0x60, 0xad, 0xc2, 0x6b, 0xe6, 0xf4, 0x8d, 0x01}; // Backwards compatibility alias #define INDEX_GZ INDEX_BR diff --git a/esphome/components/weikai/weikai.cpp b/esphome/components/weikai/weikai.cpp index a19dce4db3..b95d474fd3 100644 --- a/esphome/components/weikai/weikai.cpp +++ b/esphome/components/weikai/weikai.cpp @@ -134,7 +134,7 @@ void WeikaiComponent::loop() { } bool status = children_[i]->uart_receive_test_(message); ESP_LOGI(TAG, "Test %s => send/received %u bytes %s - execution time %" PRIu32 " ms", message, RING_BUFFER_SIZE, - status ? "correctly" : "with error", elapsed_ms(time)); + status ? LOG_STR_LITERAL("correctly") : LOG_STR_LITERAL("with error"), elapsed_ms(time)); } } @@ -238,9 +238,9 @@ void WeikaiComponent::set_pin_direction_(uint8_t pin, gpio::Flags flags) { void WeikaiGPIOPin::setup() { ESP_LOGCONFIG(TAG, "Setting GPIO pin %d mode to %s", this->pin_, - flags_ == gpio::FLAG_INPUT ? "Input" - : this->flags_ == gpio::FLAG_OUTPUT ? "Output" - : "NOT SPECIFIED"); + this->flags_ == gpio::FLAG_INPUT ? LOG_STR_LITERAL("Input") + : this->flags_ == gpio::FLAG_OUTPUT ? LOG_STR_LITERAL("Output") + : LOG_STR_LITERAL("NOT SPECIFIED")); this->pin_mode(this->flags_); } @@ -348,14 +348,18 @@ size_t WeikaiChannel::rx_in_fifo_() { uint8_t const fsr = this->reg(WKREG_FSR); if (fsr & (FSR_RFOE | FSR_RFLB | FSR_RFFE | FSR_RFPE)) { char bin_buf[9]; - if (fsr & FSR_RFOE) + if (fsr & FSR_RFOE) { ESP_LOGE(TAG, "Receive data overflow FSR=%s", format_bin_to(bin_buf, fsr)); - if (fsr & FSR_RFLB) + } + if (fsr & FSR_RFLB) { ESP_LOGE(TAG, "Receive line break FSR=%s", format_bin_to(bin_buf, fsr)); - if (fsr & FSR_RFFE) + } + if (fsr & FSR_RFFE) { ESP_LOGE(TAG, "Receive frame error FSR=%s", format_bin_to(bin_buf, fsr)); - if (fsr & FSR_RFPE) + } + if (fsr & FSR_RFPE) { ESP_LOGE(TAG, "Receive parity error FSR=%s", format_bin_to(bin_buf, fsr)); + } } if ((available == 0) && (fsr & FSR_RFDAT)) { // here we should be very careful because we can have something like this: @@ -420,7 +424,7 @@ bool WeikaiChannel::read_array(uint8_t *buffer, size_t length) { this->receive_buffer_.pop(buffer[i]); } ESP_LOGVV(TAG, "read_array(ch=%d buffer[0]=%02X, length=%d): status %s", this->channel_, *buffer, length, - status ? "OK" : "ERROR"); + status ? LOG_STR_LITERAL("OK") : LOG_STR_LITERAL("ERROR")); return status; } @@ -495,8 +499,9 @@ void print_buffer(std::vector buffer) { hex_buffer[(3 * 32) + 1] = 0; for (size_t i = 0; i < buffer.size(); i++) { snprintf(&hex_buffer[3 * (i % 32)], sizeof(hex_buffer), "%02X ", buffer[i]); - if (i % 32 == 31) + if (i % 32 == 31) { ESP_LOGI(TAG, " %s", hex_buffer); + } } if (buffer.size() % 32) { // null terminate if incomplete line @@ -558,8 +563,8 @@ bool WeikaiChannel::uart_receive_test_(char *message) { } } - ESP_LOGV(TAG, "%s => received %d bytes status %s - exec time %d µs", message, received, status ? "OK" : "ERROR", - micros() - start_exec); + ESP_LOGV(TAG, "%s => received %d bytes status %s - exec time %d µs", message, received, + status ? LOG_STR_LITERAL("OK") : LOG_STR_LITERAL("ERROR"), micros() - start_exec); return status; } diff --git a/esphome/components/whirlpool/whirlpool.cpp b/esphome/components/whirlpool/whirlpool.cpp index ace96d78fc..f560917f41 100644 --- a/esphome/components/whirlpool/whirlpool.cpp +++ b/esphome/components/whirlpool/whirlpool.cpp @@ -103,7 +103,7 @@ void WhirlpoolClimate::transmit_state() { } // Swing - ESP_LOGV(TAG, "send swing %s", this->send_swing_cmd_ ? "true" : "false"); + ESP_LOGV(TAG, "send swing %s", this->send_swing_cmd_ ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false")); if (this->send_swing_cmd_) { if (this->swing_mode == climate::CLIMATE_SWING_VERTICAL || this->swing_mode == climate::CLIMATE_SWING_OFF) { remote_state[2] |= 128; diff --git a/esphome/components/whynter/whynter.cpp b/esphome/components/whynter/whynter.cpp index b8a8db4d7c..f5f304aa17 100644 --- a/esphome/components/whynter/whynter.cpp +++ b/esphome/components/whynter/whynter.cpp @@ -84,8 +84,8 @@ void Whynter::transmit_state() { if (fahrenheit_) { remote_state |= UNIT_MASK; - uint8_t temp = - (uint8_t) clamp(esphome::celsius_to_fahrenheit(this->target_temperature), TEMP_MIN_F, TEMP_MAX_F); + uint8_t temp = (uint8_t) roundf( + clamp(esphome::celsius_to_fahrenheit(this->target_temperature), TEMP_MIN_F, TEMP_MAX_F)); temp = esphome::reverse_bits(temp); remote_state |= temp; } else { diff --git a/esphome/components/wifi/__init__.py b/esphome/components/wifi/__init__.py index 4bb6629da1..b8c6d774ac 100644 --- a/esphome/components/wifi/__init__.py +++ b/esphome/components/wifi/__init__.py @@ -445,10 +445,15 @@ def _report_provisioning_credentials(config): about this, since a device that uses a provisioning window should get its credentials on first connection instead. """ - if config.get(CONF_NETWORKS): - from esphome.components import provisioning + from esphome.components import provisioning + if config.get(CONF_NETWORKS): provisioning.report_hardcoded_credentials("wifi") + elif CONF_AP in config: + # An access point with no station credentials: the AP shuts down when the + # provisioning window closes, so `provisioning:` warns that the device may + # become unreachable until power-cycled. + provisioning.report_ap_without_sta() return config diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp index 9ff580fbad..d5a73894ac 100644 --- a/esphome/components/wifi/wifi_component.cpp +++ b/esphome/components/wifi/wifi_component.cpp @@ -636,6 +636,21 @@ void WiFiComponent::setup() { this->configured_power_save_ = this->power_save_; #endif +#if defined(USE_PROVISIONING) && defined(USE_WIFI_AP) + // The access point is a provisioning surface: once the provisioning window has + // closed, shut it down (mirrors the teardown done on a successful connection). + // The captive portal registers its own closed-callback, and the fallback block + // in loop() is gated so neither is started again afterwards. + if (provisioning::global_provisioning_manager != nullptr) { + provisioning::global_provisioning_manager->add_on_closed_callback([this]() { + if (this->ap_setup_) { + ESP_LOGD(TAG, "Provisioning window closed; disabling AP"); + this->wifi_mode_({}, false); + } + }); + } +#endif + if (this->enable_on_boot_) { #ifdef USE_ESP32 this->wifi_lazy_init_(); @@ -857,7 +872,15 @@ void WiFiComponent::loop() { } #ifdef USE_WIFI_AP - if (this->has_ap() && !this->ap_setup_) { + bool provisioning_closed = false; +#ifdef USE_PROVISIONING + // Once the provisioning window has closed, don't bring up the fallback AP (or + // the captive portal on it) - the device must stay unprovisionable until it is + // power-cycled. + provisioning_closed = + provisioning::global_provisioning_manager != nullptr && provisioning::global_provisioning_manager->closed(); +#endif + if (this->has_ap() && !this->ap_setup_ && !provisioning_closed) { if (this->ap_timeout_ != 0 && (now - this->last_connected_ > this->ap_timeout_)) { ESP_LOGI(TAG, "Starting fallback AP"); this->setup_ap_config_(); @@ -911,7 +934,7 @@ void WiFiComponent::loop() { if (semaphore_count > 0 && !this->is_high_performance_mode_) { // Transition to high-performance mode (no power save) ESP_LOGV(TAG, "Switching to high-performance mode (%" PRIu32 " active %s)", (uint32_t) semaphore_count, - semaphore_count == 1 ? "request" : "requests"); + semaphore_count == 1 ? LOG_STR_LITERAL("request") : LOG_STR_LITERAL("requests")); this->power_save_ = WIFI_POWER_SAVE_NONE; if (this->wifi_apply_power_save_()) { this->is_high_performance_mode_ = true; @@ -1159,8 +1182,9 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) { " CA Cert: %s\n" " Client Cert: %s\n" " Client Key: %s", - ca_cert_present ? "present" : "not present", client_cert_present ? "present" : "not present", - client_key_present ? "present" : "not present"); + ca_cert_present ? LOG_STR_LITERAL("present") : LOG_STR_LITERAL("not present"), + client_cert_present ? LOG_STR_LITERAL("present") : LOG_STR_LITERAL("not present"), + client_key_present ? LOG_STR_LITERAL("present") : LOG_STR_LITERAL("not present")); } else { #endif ESP_LOGV(TAG, " Password: " LOG_SECRET("'%s'"), ap.password_.c_str()); @@ -1294,7 +1318,8 @@ void WiFiComponent::print_connect_params_() { ESP_LOGCONFIG(TAG, " BTM: %s\n" " RRM: %s", - this->btm_ ? "enabled" : "disabled", this->rrm_ ? "enabled" : "disabled"); + this->btm_ ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled"), + this->rrm_ ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled")); #endif } diff --git a/esphome/components/wireguard/wireguard.cpp b/esphome/components/wireguard/wireguard.cpp index 2f07344d3b..fc06569fba 100644 --- a/esphome/components/wireguard/wireguard.cpp +++ b/esphome/components/wireguard/wireguard.cpp @@ -146,18 +146,19 @@ void Wireguard::dump_config() { " Peer Pre-shared Key: " LOG_SECRET("%s"), this->address_, this->netmask_, private_key_masked, this->peer_endpoint_, this->peer_port_, this->peer_public_key_, - (this->preshared_key_ != nullptr ? preshared_key_masked : "NOT IN USE")); + (this->preshared_key_ != nullptr ? preshared_key_masked : LOG_STR_LITERAL("NOT IN USE"))); // clang-format on ESP_LOGCONFIG(TAG, " Peer Allowed IPs:"); for (const AllowedIP &allowed_ip : this->allowed_ips_) { ESP_LOGCONFIG(TAG, " - %s/%s", allowed_ip.ip, allowed_ip.netmask); } ESP_LOGCONFIG(TAG, " Peer Persistent Keepalive: %d%s", this->keepalive_, - (this->keepalive_ > 0 ? "s" : " (DISABLED)")); + (this->keepalive_ > 0 ? LOG_STR_LITERAL("s") : LOG_STR_LITERAL(" (DISABLED)"))); ESP_LOGCONFIG(TAG, " Reboot Timeout: %" PRIu32 "%s", (this->reboot_timeout_ / 1000), - (this->reboot_timeout_ != 0 ? "s" : " (DISABLED)")); + (this->reboot_timeout_ != 0 ? LOG_STR_LITERAL("s") : LOG_STR_LITERAL(" (DISABLED)"))); // be careful: if proceed_allowed_ is true, require connection is false - ESP_LOGCONFIG(TAG, " Require Connection to Proceed: %s", (this->proceed_allowed_ ? "NO" : "YES")); + ESP_LOGCONFIG(TAG, " Require Connection to Proceed: %s", + (this->proceed_allowed_ ? LOG_STR_LITERAL("NO") : LOG_STR_LITERAL("YES"))); LOG_UPDATE_INTERVAL(this); } diff --git a/esphome/components/wl_134/wl_134.cpp b/esphome/components/wl_134/wl_134.cpp index f3eb17965d..5e86d5a441 100644 --- a/esphome/components/wl_134/wl_134.cpp +++ b/esphome/components/wl_134/wl_134.cpp @@ -76,8 +76,8 @@ Wl134Component::Rfid134Error Wl134Component::read_packet_() { " isAnimal: %s\n" " Reserved0: %d\n" " Reserved1: %" PRId32, - reading.id, reading.country, reading.isData ? "true" : "false", reading.isAnimal ? "true" : "false", - reading.reserved0, reading.reserved1); + reading.id, reading.country, reading.isData ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false"), + reading.isAnimal ? LOG_STR_LITERAL("true") : LOG_STR_LITERAL("false"), reading.reserved0, reading.reserved1); char buf[20]; // "%03d" (3) + "%012" PRId64 (12) + null = 16 max buf_append_printf(buf, sizeof(buf), 0, "%03d%012" PRId64, reading.country, reading.id); diff --git a/esphome/components/zigbee/zigbee_esp32.py b/esphome/components/zigbee/zigbee_esp32.py index ade45e8cc3..57fa3b2a00 100644 --- a/esphome/components/zigbee/zigbee_esp32.py +++ b/esphome/components/zigbee/zigbee_esp32.py @@ -9,6 +9,7 @@ from esphome.components.esp32 import ( add_idf_component, add_idf_sdkconfig_option, add_partition, + include_builtin_idf_component, require_vfs_select, ) import esphome.config_validation as cv @@ -288,6 +289,10 @@ async def esp32_to_code(config: ConfigType) -> "MockObj": ref="2.0.4", ) + if CONF_WIFI in CORE.config: + # zigbee_esp32.cpp uses esp_coexist.h when WiFi is present + include_builtin_idf_component("esp_coex") + # add sdkconfigs later so they can overwrite esp32 defaults CORE.add_job(_zigbee_add_sdkconfigs, config) diff --git a/esphome/components/zwave_proxy/zwave_proxy.cpp b/esphome/components/zwave_proxy/zwave_proxy.cpp index 68750295e1..b0d18a3e6a 100644 --- a/esphome/components/zwave_proxy/zwave_proxy.cpp +++ b/esphome/components/zwave_proxy/zwave_proxy.cpp @@ -180,11 +180,11 @@ void ZWaveProxy::process_uart_slow_() { void ZWaveProxy::dump_config() { char hex_buf[format_hex_pretty_size(ZWAVE_HOME_ID_SIZE)]; - ESP_LOGCONFIG( - TAG, - "Z-Wave Proxy:\n" - " Home ID: %s", - this->home_id_ready_ ? format_hex_pretty_to(hex_buf, this->home_id_.data(), this->home_id_.size()) : "unknown"); + ESP_LOGCONFIG(TAG, + "Z-Wave Proxy:\n" + " Home ID: %s", + this->home_id_ready_ ? format_hex_pretty_to(hex_buf, this->home_id_.data(), this->home_id_.size()) + : LOG_STR_LITERAL("unknown")); } void ZWaveProxy::api_connection_authenticated(api::APIConnection *conn) { @@ -510,7 +510,8 @@ bool ZWaveProxy::response_handler_slow_() { return false; // No response handled } - ESP_LOGVV(TAG, "Sending %s (0x%02X)", this->last_response_ == ZWAVE_FRAME_TYPE_ACK ? "ACK" : "NAK/CAN", + ESP_LOGVV(TAG, "Sending %s (0x%02X)", + this->last_response_ == ZWAVE_FRAME_TYPE_ACK ? LOG_STR_LITERAL("ACK") : LOG_STR_LITERAL("NAK/CAN"), this->last_response_); this->write_byte(this->last_response_); this->parsing_state_ = ZWAVE_PARSING_STATE_WAIT_START; diff --git a/esphome/config_validation.py b/esphome/config_validation.py index 904cbd1919..aff39201e8 100644 --- a/esphome/config_validation.py +++ b/esphome/config_validation.py @@ -1462,7 +1462,7 @@ def hostname(value): Maximum length is 63 characters per RFC 1035. Note: If this limit is changed, update MAX_NAME_WITH_SUFFIX_SIZE in - esphome/core/helpers.cpp to accommodate the new maximum length. + esphome/core/helpers.h to accommodate the new maximum length. """ value = string(value) if re.match(r"^[a-z0-9-]{1,63}$", value, re.IGNORECASE) is not None: diff --git a/esphome/core/__init__.py b/esphome/core/__init__.py index 77efc91bef..6e3f91af22 100644 --- a/esphome/core/__init__.py +++ b/esphome/core/__init__.py @@ -783,7 +783,8 @@ class EsphomeCore: can compare a locally computed hash against the one a device advertises. Machine-local data is kept out of the input: build_path (which embeds ESPHOME_BUILD_PATH and OS path separators) is excluded, - and Path values are dumped relative to the config directory. + and Path values are dumped relative to the config directory, with + the data directory always at its default ``.esphome`` location. """ if self._config_hash is None: from esphome import yaml_util @@ -794,11 +795,15 @@ class EsphomeCore: esphome_conf = dict(esphome_conf) esphome_conf.pop(CONF_BUILD_PATH, None) config[CONF_ESPHOME] = esphome_conf + relative_to = data_dir = None + if self.config_path is not None: + relative_to, data_dir = self.config_dir, self.data_dir config_str = yaml_util.dump( config, show_secrets=True, sort_keys=True, - relative_to=self.config_dir if self.config_path is not None else None, + relative_to=relative_to, + data_dir=data_dir, ) self._config_hash = fnv1a_32bit_hash(config_str) return self._config_hash diff --git a/esphome/core/component.cpp b/esphome/core/component.cpp index e5fbb8ba07..41dd32ea66 100644 --- a/esphome/core/component.cpp +++ b/esphome/core/component.cpp @@ -336,10 +336,8 @@ void log_update_interval(const char *tag, PollingComponent *component) { uint32_t update_interval = component->get_update_interval(); if (update_interval == SCHEDULER_DONT_RUN) { ESP_LOGCONFIG(tag, " Update Interval: never"); - } else if (update_interval < 100) { - ESP_LOGCONFIG(tag, " Update Interval: %.3fs", update_interval / 1000.0f); } else { - ESP_LOGCONFIG(tag, " Update Interval: %.1fs", update_interval / 1000.0f); + ESP_LOGCONFIG(tag, " Update Interval: %" PRIu32 ".%03" PRIu32 "s", update_interval / 1000, update_interval % 1000); } } float Component::get_actual_setup_priority() const { diff --git a/esphome/core/config.py b/esphome/core/config.py index 472ca64c9a..67a7b5210e 100644 --- a/esphome/core/config.py +++ b/esphome/core/config.py @@ -55,6 +55,7 @@ from esphome.helpers import ( cpp_string_escape, fnv1a_32bit_hash, get_str_env, + get_usable_cpu_count, walk_files, ) from esphome.types import ConfigType @@ -205,16 +206,6 @@ def valid_project_name(value: str): return value -def get_usable_cpu_count() -> int: - """Return the number of CPUs that can be used for processes. - On Python 3.13+ this is the number of CPUs that can be used for processes. - On older Python versions this is the number of CPUs. - """ - return ( - os.process_cpu_count() if hasattr(os, "process_cpu_count") else os.cpu_count() - ) - - if "ESPHOME_DEFAULT_COMPILE_PROCESS_LIMIT" in os.environ: _compile_process_limit_default = min( int(os.environ["ESPHOME_DEFAULT_COMPILE_PROCESS_LIMIT"]), get_usable_cpu_count() diff --git a/esphome/core/defines.h b/esphome/core/defines.h index db278c1c46..7516cfac37 100644 --- a/esphome/core/defines.h +++ b/esphome/core/defines.h @@ -81,8 +81,6 @@ #define USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT 8000 // NOLINT #define USE_I2S_AUDIO_SPDIF_MODE #define USE_IMAGE -#define USE_IMPROV_SERIAL -#define USE_IMPROV_SERIAL_NEXT_URL #define USE_INFRARED #define USE_IR_RF #define USE_JSON @@ -136,6 +134,7 @@ #define MDNS_DYNAMIC_TXT_COUNT 2 #define MICRONOVA_LISTENER_COUNT 1 #define USE_MICRONOVA_WRITER +#define MK2PVROUTER_LISTENER_COUNT 1 #define SERIAL_PROXY_COUNT 2 #define SNTP_SERVER_COUNT 3 #define USE_MEDIA_PLAYER @@ -219,10 +218,15 @@ #define USE_API_PLAINTEXT #define USE_API_USER_DEFINED_ACTIONS #define USE_API_CUSTOM_SERVICES +#define USE_API_USER_DEFINED_ACTION_METADATA #define USE_API_USER_DEFINED_ACTION_RESPONSES #define USE_API_USER_DEFINED_ACTION_RESPONSES_JSON #define API_MAX_SEND_QUEUE 8 +#define API_USER_ACTION_STRINGS_SCRATCH_SIZE 64 #define MAX_API_CONNECTIONS 6 +// The Improv library is not in the Zephyr tidy environment +#define USE_IMPROV_SERIAL +#define USE_IMPROV_SERIAL_NEXT_URL #define USE_MD5 #define USE_NOISE #define USE_SHA256 @@ -233,10 +237,12 @@ #endif #define USE_RTTTL_FINISHED_PLAYBACK_CALLBACK #define USE_RUNTIME_IMAGE_BMP -#define USE_RUNTIME_IMAGE_PNG #define USE_RUNTIME_IMAGE_JPEG +#define USE_RUNTIME_IMAGE_PNG +#define USE_RUNTIME_IMAGE_QOI #define USE_RUNTIME_STATS #define USE_OTA +#define USE_OTA_ENCRYPTION #define USE_OTA_PASSWORD #define USE_OTA_VERSION 2 #define USE_TIME_TIMEZONE @@ -355,6 +361,7 @@ #define USE_SPEAKER #define USE_SPEAKER_MEDIA_PLAYER_ON_OFF #define USE_SPI +#define USE_SPI_PSRAM_DMA #define USE_VOICE_ASSISTANT #define USE_WEBSERVER #define USE_WEBSERVER_AUTH @@ -539,6 +546,8 @@ #ifdef USE_HOST #define USE_HTTP_REQUEST_RESPONSE +// Host only: the uart arm would shadow the native logger UART arms in other envs +#define USE_IMPROV_SERIAL_UART #define USE_SOCKET_IMPL_BSD_SOCKETS #define USE_ESPHOME_TASK_LOG_BUFFER #define ESPHOME_TASK_LOG_BUFFER_SIZE 64 diff --git a/esphome/core/helpers.cpp b/esphome/core/helpers.cpp index 71e3c87e1e..433d2547b0 100644 --- a/esphome/core/helpers.cpp +++ b/esphome/core/helpers.cpp @@ -268,9 +268,6 @@ char *str_sanitize_to(char *buffer, size_t buffer_size, const char *str) { // str_sanitize, str_snprintf, str_sprintf moved to alloc_helpers.cpp -// Maximum size for name with suffix: 120 (max friendly name) + 1 (separator) + 6 (MAC suffix) + 1 (null term) -static constexpr size_t MAX_NAME_WITH_SUFFIX_SIZE = 128; - size_t make_name_with_suffix_to(char *buffer, size_t buffer_size, const char *name, size_t name_len, char sep, const char *suffix_ptr, size_t suffix_len) { size_t total_len = name_len + 1 + suffix_len; @@ -291,17 +288,6 @@ size_t make_name_with_suffix_to(char *buffer, size_t buffer_size, const char *na return total_len; } -std::string make_name_with_suffix(const char *name, size_t name_len, char sep, const char *suffix_ptr, - size_t suffix_len) { - char buffer[MAX_NAME_WITH_SUFFIX_SIZE]; - size_t len = make_name_with_suffix_to(buffer, sizeof(buffer), name, name_len, sep, suffix_ptr, suffix_len); - return std::string(buffer, len); -} - -std::string make_name_with_suffix(const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len) { - return make_name_with_suffix(name.c_str(), name.size(), sep, suffix_ptr, suffix_len); -} - // Parsing & formatting size_t parse_hex(const char *str, size_t length, uint8_t *data, size_t count) { @@ -582,7 +568,7 @@ size_t value_accuracy_to_buf(std::span buf, float } // Fallback for NaN/Inf/high accuracy/out-of-range - int len = snprintf(buf.data(), buf.size(), "%.*f", accuracy_decimals, value); + int len = snprintf(buf.data(), buf.size(), "%.*f", accuracy_decimals, static_cast(value)); if (len < 0) return 0; return static_cast(len) >= buf.size() ? buf.size() - 1 : static_cast(len); @@ -600,16 +586,30 @@ size_t value_accuracy_with_uom_to_buf(std::span bu } int8_t step_to_accuracy_decimals(float step) { - // use printf %g to find number of digits based on temperature step - char buf[32]; - snprintf(buf, sizeof buf, "%.5g", step); - - std::string str{buf}; - size_t dot_pos = str.find('.'); - if (dot_pos == std::string::npos) + // Decimals needed to show the step at five significant digits, trailing zeros dropped. + if (!std::isfinite(step) || step == 0.0f) return 0; - - return str.length() - dot_pos - 1; + float mantissa = std::fabs(step); + int8_t decimals = 4; // decimals needed for five significant digits when mantissa is in [1, 10) + while (mantissa >= 10.0f) { + mantissa /= 10.0f; + decimals--; + } + while (mantissa < 1.0f) { + mantissa *= 10.0f; + decimals++; + } + if (decimals <= 0) + return 0; + float scaled = mantissa * 10000.0f; + auto digits = static_cast(scaled); + if (scaled - static_cast(digits) >= 0.5f) + digits++; + while (decimals > 0 && digits % 10 == 0) { + digits /= 10; + decimals--; + } + return decimals; } // Map a base64/base64url character to its 6-bit value (0-63) arithmetically. diff --git a/esphome/core/helpers.h b/esphome/core/helpers.h index 9fdc088ecb..a0afb03124 100644 --- a/esphome/core/helpers.h +++ b/esphome/core/helpers.h @@ -290,6 +290,7 @@ template class StaticVector { } size_t size() const { return count_; } + static constexpr size_t capacity() { return N; } bool empty() const { return count_ == 0; } // Direct access to underlying data @@ -1153,28 +1154,10 @@ inline size_t buf_append_str(char *buf, size_t size, size_t pos, const char *str } #endif -/// Concatenate a name with a separator and suffix using an efficient stack-based approach. -/// This avoids multiple heap allocations during string construction. -/// Maximum name length supported is 120 characters for friendly names. -/// @param name The base name string -/// @param sep The separator character (e.g., '-', ' ', or '.') -/// @param suffix_ptr Pointer to the suffix characters -/// @param suffix_len Length of the suffix -/// @return The concatenated string: name + sep + suffix -std::string make_name_with_suffix(const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len); +/// Maximum size for name with suffix: 120 (max friendly name) + 1 (separator) + 6 (MAC suffix) + 1 (null term) +static constexpr size_t MAX_NAME_WITH_SUFFIX_SIZE = 128; -/// Optimized string concatenation: name + separator + suffix (const char* overload) -/// Uses a fixed stack buffer to avoid heap allocations. -/// @param name The base name string -/// @param name_len Length of the name -/// @param sep Single character separator -/// @param suffix_ptr Pointer to the suffix characters -/// @param suffix_len Length of the suffix -/// @return The concatenated string: name + sep + suffix -std::string make_name_with_suffix(const char *name, size_t name_len, char sep, const char *suffix_ptr, - size_t suffix_len); - -/// Zero-allocation version: format name + separator + suffix directly into buffer. +/// Format name + separator + suffix directly into buffer without heap allocation. /// @param buffer Output buffer (must have space for result + null terminator) /// @param buffer_size Size of the output buffer /// @param name The base name string diff --git a/esphome/core/scheduler.cpp b/esphome/core/scheduler.cpp index e9c5bf2c04..afb323f78e 100644 --- a/esphome/core/scheduler.cpp +++ b/esphome/core/scheduler.cpp @@ -193,7 +193,7 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type } #ifdef ESPHOME_DEBUG_SCHEDULER - this->debug_log_timer_(item, name_type, static_name, hash_or_id, type, delay, now_64); + this->debug_log_timer_(item, name_type, static_name, hash_or_id, delay, now_64); #endif /* ESPHOME_DEBUG_SCHEDULER */ } @@ -438,9 +438,10 @@ uint32_t HOT Scheduler::call(uint32_t now) { SchedulerNameLog name_log; bool is_cancelled = is_item_removed_(item); ESP_LOGD(TAG, " %s '%s/%s' interval=%" PRIu32 " next_execution in %" PRIu64 "ms at %" PRIu64 "%s", - item->get_type_str(), LOG_STR_ARG(item->get_source()), + LOG_STR_ARG(item->get_type_str()), LOG_STR_ARG(item->get_source()), name_log.format(item->get_name_type(), item->get_name(), item->get_name_hash_or_id()), item->interval, - item->get_next_execution() - now_64, item->get_next_execution(), is_cancelled ? " [CANCELLED]" : ""); + item->get_next_execution() - now_64, item->get_next_execution(), + is_cancelled ? LOG_STR_LITERAL(" [CANCELLED]") : LOG_STR_LITERAL("")); old_items.push_back(item); } @@ -512,7 +513,7 @@ uint32_t HOT Scheduler::call(uint32_t now) { { SchedulerNameLog name_log; ESP_LOGV(TAG, "Running %s '%s/%s' with interval=%" PRIu32 " next_execution=%" PRIu64 " (now=%" PRIu64 ")", - item->get_type_str(), LOG_STR_ARG(item->get_source()), + LOG_STR_ARG(item->get_type_str()), LOG_STR_ARG(item->get_source()), name_log.format(item->get_name_type(), item->get_name(), item->get_name_hash_or_id()), item->interval, item->get_next_execution(), now_64); } @@ -794,7 +795,7 @@ void Scheduler::trim_freelist() { #ifdef ESPHOME_DEBUG_SCHEDULER void Scheduler::debug_log_timer_(const SchedulerItem *item, NameType name_type, const char *static_name, - uint32_t hash_or_id, SchedulerItem::Type type, uint32_t delay, uint64_t now) { + uint32_t hash_or_id, uint32_t delay, uint64_t now) { // Validate static strings in debug mode if (name_type == NameType::STATIC_STRING && static_name != nullptr) { validate_static_string(static_name); @@ -802,8 +803,8 @@ void Scheduler::debug_log_timer_(const SchedulerItem *item, NameType name_type, // Debug logging SchedulerNameLog name_log; - const char *type_str = (type == SchedulerItem::TIMEOUT) ? "timeout" : "interval"; - if (type == SchedulerItem::TIMEOUT) { + const char *type_str = LOG_STR_ARG(item->get_type_str()); + if (item->type == SchedulerItem::TIMEOUT) { ESP_LOGD(TAG, "set_%s(name='%s/%s', %s=%" PRIu32 ")", type_str, LOG_STR_ARG(item->get_source()), name_log.format(name_type, static_name, hash_or_id), type_str, delay); } else { diff --git a/esphome/core/scheduler.h b/esphome/core/scheduler.h index 8ef3499a11..56fc83f12f 100644 --- a/esphome/core/scheduler.h +++ b/esphome/core/scheduler.h @@ -254,7 +254,7 @@ class Scheduler { // This is correct because millis_major_ that creates these values is also 16 bits. next_execution_high_ = static_cast(value >> 32); } - constexpr const char *get_type_str() const { return (type == TIMEOUT) ? "timeout" : "interval"; } + const LogString *get_type_str() const { return (type == TIMEOUT) ? LOG_STR("timeout") : LOG_STR("interval"); } // The owning component, or nullptr for SELF_POINTER items (whose slot holds source_name instead). // All component access goes through this so SELF_POINTER items read as component-less. Component *get_component() const { return name_type_ == NameType::SELF_POINTER ? nullptr : component; } @@ -404,7 +404,7 @@ class Scheduler { #ifdef ESPHOME_DEBUG_SCHEDULER // Helper for debug logging in set_timer_common_ - extracted to reduce code size void debug_log_timer_(const SchedulerItem *item, NameType name_type, const char *static_name, uint32_t hash_or_id, - SchedulerItem::Type type, uint32_t delay, uint64_t now); + uint32_t delay, uint64_t now); #endif /* ESPHOME_DEBUG_SCHEDULER */ #ifndef ESPHOME_THREAD_SINGLE diff --git a/esphome/cpp_types.py b/esphome/cpp_types.py index aeaa4480a8..45d6559b3f 100644 --- a/esphome/cpp_types.py +++ b/esphome/cpp_types.py @@ -14,6 +14,7 @@ std_string_ref = std_ns.namespace("string &") std_vector = std_ns.class_("vector") std_span = std_ns.class_("span") int8 = global_ns.namespace("int8_t") +char = global_ns.namespace("char") uint8 = global_ns.namespace("uint8_t") uint16 = global_ns.namespace("uint16_t") uint32 = global_ns.namespace("uint32_t") diff --git a/esphome/espidf/framework.py b/esphome/espidf/framework.py index 239d874dbd..9373b5f569 100644 --- a/esphome/espidf/framework.py +++ b/esphome/espidf/framework.py @@ -2,7 +2,6 @@ from collections.abc import Callable from ctypes.util import find_library -from functools import partial import json import logging import os @@ -24,16 +23,17 @@ from esphome.framework_helpers import ( create_venv, download_and_extract, download_from_mirrors, - download_with_resume, failure_reason, get_python_env_executable_path, get_system_python_path, + resume_fetch_job, rmdir, run_batch_downloads, run_command, run_command_ok, str_to_lst_of_str, tool_version_runs, + warn_prefetch_failures, ) from esphome.helpers import write_file_if_changed @@ -686,18 +686,6 @@ def _patch_tools_json_demote_unused_tools(framework_path: Path) -> None: ) -def _download_tool( - dist_path: Path, entry: dict, tracker: Callable[[int], None] -) -> None: - download_with_resume( - entry["url"], - dist_path / entry["dest"], - sha256=entry["sha256"], - size=entry["size"], - progress=tracker, - ) - - def _prefetch_idf_tool_archives( framework_path: Path, targets_str: str, @@ -775,15 +763,17 @@ def _prefetch_idf_tool_archives( ( entry["name"], entry["size"], - partial(_download_tool, dist_path, entry), + resume_fetch_job( + entry["url"], + dist_path / entry["dest"], + sha256=entry["sha256"], + size=entry["size"], + ), ) for entry in entries ], ) - for name, e in failures: - # failure_reason: a message-less exception must not log blank - _LOGGER.warning("Could not prefetch %s: %s", name, failure_reason(e)) - _LOGGER.debug("Prefetch failure detail", exc_info=e) + warn_prefetch_failures(failures) if len(failures) == len(entries): # A systematic fault, not one flaky mirror: the resume # workaround (#17703) is off for this whole install @@ -1063,15 +1053,28 @@ def _check_esp_idf_python_env_install( constraint_file_path, ) - cmd_pip_install = [ - str(env_python_path), - "-m", - "pip", - "install", - "--upgrade", - "--constraint", - constraint_file_path, - ] + # uv (much faster than pip) when available, e.g. in the docker image + if uv_path := shutil.which("uv"): + cmd_pip_install = [ + uv_path, + "pip", + "install", + "--python", + str(env_python_path), + "--upgrade", + "--constraint", + str(constraint_file_path), + ] + else: + cmd_pip_install = [ + str(env_python_path), + "-m", + "pip", + "install", + "--upgrade", + "--constraint", + str(constraint_file_path), + ] _LOGGER.info("Installing ESP-IDF %s Python dependencies ...", version) cmd = cmd_pip_install + [ @@ -1145,6 +1148,8 @@ def check_esp_idf_install( env = {} env["IDF_TOOLS_PATH"] = str(get_idf_tools_path()) env["IDF_PATH"] = "" + # uv defaults to 3 HTTP retries; match the pioarduino penv's bump to 10 + env["UV_HTTP_RETRIES"] = os.environ.get("UV_HTTP_RETRIES", "10") # An explicit ESPHOME_IDF_DEFAULT_TARGETS wins over the caller's # per-variant request (builder-image pre-warm); otherwise the caller's diff --git a/esphome/espota2.py b/esphome/espota2.py index ca833f1816..ac4cbeeb7c 100644 --- a/esphome/espota2.py +++ b/esphome/espota2.py @@ -53,6 +53,7 @@ RESPONSE_ERROR_PARTITION_TABLE_UPDATE = 0x90 RESPONSE_ERROR_BOOTLOADER_VERIFY = 0x91 RESPONSE_ERROR_BOOTLOADER_UPDATE = 0x92 RESPONSE_ERROR_VERSION_DOWNGRADE = 0x93 +RESPONSE_ERROR_ENCRYPTION_REQUIRED = 0x94 RESPONSE_ERROR_UNKNOWN = 0xFF OTA_VERSION_1_0 = 1 @@ -63,8 +64,20 @@ MAGIC_BYTES = [0x6C, 0x26, 0xF7, 0x5C, 0x45] CLIENT_FEATURE_SUPPORTS_COMPRESSION = 0x01 CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02 CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04 +CLIENT_FEATURE_SUPPORTS_NOISE = 0x08 SERVER_FEATURE_SUPPORTS_COMPRESSION = 0x01 SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS = 0x02 +SERVER_FEATURE_SUPPORTS_NOISE = 0x04 + +NOISE_FRAME_INDICATOR = 0x01 +NOISE_HANDSHAKE_OK = 0x00 +# The device decrypts frames in its transfer buffer (OTA_BUFFER_SIZE, sized +# as this plus the 16-byte ChaCha20-Poly1305 MAC). 1024 divides the 8192-byte +# upload block exactly, so blocks tile into full frames with no runt. +NOISE_MAX_PLAINTEXT = 1024 +# Wire contract: the device sends exactly this reject reason for a bad MAC +NOISE_MAC_FAILURE_REASON = "Handshake MAC failure" +NOISE_PROLOGUE_INIT = b"NoiseOTAInit" # OTA types this client knows how to send. Future PRs that add bootloader/partition # updates extend this set. Anything outside the set is rejected up front so callers @@ -171,6 +184,12 @@ _ERROR_MESSAGES: dict[int, str] = { "enabled: the new firmware's version must be newer than the version the " "device is currently running." ), + RESPONSE_ERROR_ENCRYPTION_REQUIRED: ( + "The device requires an encrypted OTA connection but this upload has no " + "encryption key. Add 'encryption:' to the 'ota: platform: esphome' section " + "of the YAML this upload uses, or update your esphome installation if it " + "predates OTA encryption." + ), RESPONSE_ERROR_UNKNOWN: "Unknown error from ESP", } @@ -305,16 +324,149 @@ def send_check( raise OTANetworkError(f"sending {msg}: {err}") from err +class NoiseSocketWrapper: + """Runs the OTA session inside a Noise (ChaCha20-Poly1305) transport. + + Exposes the socket subset perform_ota uses. Frames are indicator 0x01, + 16-bit big-endian length, ciphertext; recv() drains one decrypted frame + at a time, sendall() keeps control units in one frame and splits data + at NOISE_MAX_PLAINTEXT. + """ + + def __init__(self, sock: socket.socket, psk: str, prologue: bytes) -> None: + # Deliberately lazy: the noise stack (noiseprotocol, cryptography) is + # only imported when an encrypted upload actually runs. + try: + from aioesphomeapi.noise import NoiseHandshake + except ImportError as err: + raise OTAError( + "OTA encryption requires a newer aioesphomeapi; update your " + "esphome installation (pip install -U esphome) and retry" + ) from err + # The aioesphomeapi import above already loaded cryptography; bind + # the exception once so recv() pays no per-frame import lookup + from cryptography.exceptions import InvalidTag + + self._invalid_tag = InvalidTag + self._sock = sock + try: + self._handshake = NoiseHandshake(psk, prologue) + except ValueError as err: + raise OTAError(f"Invalid OTA encryption key: {err}") from err + self._encrypt = None + self._decrypt = None + self._buffer = b"" + + # Only harmless socket controls pass through; byte-moving methods are + # deliberately absent so plaintext cannot leak past the transport. + def settimeout(self, timeout: float | None) -> None: + self._sock.settimeout(timeout) + + def setsockopt(self, level: int, optname: int, value: int) -> None: + self._sock.setsockopt(level, optname, value) + + def close(self) -> None: + self._sock.close() + + def do_handshake(self) -> None: + """Run the two-message NNpsk0 handshake and set up the transport ciphers.""" + try: + self._send_frame( + bytes([NOISE_HANDSHAKE_OK]) + self._handshake.write_message() + ) + payload = self._recv_frame() + except OSError as err: + raise OTANetworkError(f"noise handshake: {err}") from err + if not payload: + raise OTANetworkError("Device closed connection during the noise handshake") + if payload[0] != NOISE_HANDSHAKE_OK: + reason = payload[1:].decode("utf-8", "replace") + if reason == NOISE_MAC_FAILURE_REASON: + raise OTAError( + "Device rejected the handshake; is the OTA encryption key correct?" + ) + raise OTAError(f"Device rejected the noise handshake: {reason}") + try: + self._handshake.read_message(payload[1:]) + except (ValueError, self._invalid_tag) as err: + # InvalidTag is a wrong key; ValueError covers a device sending an + # invalid curve point, which cryptography rejects during the DH + raise OTAError( + "Noise handshake failed; is the OTA encryption key correct?" + ) from err + self._encrypt, self._decrypt = self._handshake.get_ciphers() + + def sendall(self, data: bytes) -> None: + frames: list[bytes] = [] + for offset in range(0, len(data), NOISE_MAX_PLAINTEXT): + ciphertext = self._encrypt.encrypt( + data[offset : offset + NOISE_MAX_PLAINTEXT] + ) + frames.append(self._frame_header(len(ciphertext))) + frames.append(ciphertext) + self._sock.sendall(b"".join(frames)) + + def recv(self, amount: int) -> bytes: + if not self._buffer: + ciphertext = self._recv_frame() + if not ciphertext: + return b"" # connection closed at a frame boundary + try: + self._buffer = self._decrypt.decrypt(ciphertext) + except self._invalid_tag as err: + # Retryable: a fresh connection renegotiates the session + raise OTANetworkError( + "Noise decryption failed (MAC mismatch); frame corrupted or tampered" + ) from err + if not self._buffer: + # Reject MAC-only frames so b"" always means the peer closed + raise OTANetworkError("Device sent an empty noise frame") + data = self._buffer[:amount] + self._buffer = self._buffer[amount:] + return data + + @staticmethod + def _frame_header(length: int) -> bytes: + return bytes([NOISE_FRAME_INDICATOR, (length >> 8) & 0xFF, length & 0xFF]) + + def _send_frame(self, payload: bytes) -> None: + self._sock.sendall(self._frame_header(len(payload)) + payload) + + def _recv_frame(self) -> bytes: + header = self._recv_exact(3, closed_ok=True) + if not header: + return b"" # connection closed at a frame boundary + # A malformed frame is a broken transport, not a device error; + # retryable so a fresh session is tried + if header[0] != NOISE_FRAME_INDICATOR: + raise OTANetworkError(f"Bad noise frame indicator 0x{header[0]:02X}") + length = (header[1] << 8) | header[2] + if length == 0: + raise OTANetworkError("Device sent an empty noise frame") + return self._recv_exact(length) + + def _recv_exact(self, amount: int, closed_ok: bool = False) -> bytes: + data = b"" + while len(data) < amount: + chunk = self._sock.recv(amount - len(data)) + if not chunk: + if closed_ok and not data: + return b"" + raise OSError("connection closed inside a noise frame") + data += chunk + return data + + def perform_ota( sock: socket.socket, password: str | None, file_handle: io.IOBase, filename: Path, ota_type: int = OTA_TYPE_UPDATE_APP, + noise_psk: str | None = None, ) -> None: - # Validate ota_type up front. It travels as a single byte on the wire, and - # passing an out-of-range value would only surface as a ValueError from - # bytes([ota_type]) deep inside send_check, bypassing OTAError handling. + # Validate up front; an out-of-range value would only surface as a + # ValueError deep inside send_check, bypassing OTAError handling if not isinstance(ota_type, int) or not 0 <= ota_type <= 0xFF: raise OTAError( f"Invalid ota_type {ota_type!r}; expected an integer in range 0-255" @@ -325,6 +477,11 @@ def perform_ota( f"Unsupported OTA type 0x{ota_type:02X}; this ESPHome supports: {supported}" ) + if noise_psk is not None and not noise_psk: + raise OTAError( + "An empty OTA encryption key was provided; refusing to upload in plaintext" + ) + file_contents = file_handle.read() file_size = len(file_contents) _LOGGER.info("Uploading %s (%s bytes)", filename, file_size) @@ -347,6 +504,8 @@ def perform_ota( | CLIENT_FEATURE_SUPPORTS_SHA256_AUTH | CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL ) + if noise_psk: + features_to_send |= CLIENT_FEATURE_SUPPORTS_NOISE send_check(sock, features_to_send, "features") features = receive_exactly( sock, @@ -369,6 +528,31 @@ def perform_ota( else: features = 0 + if noise_psk: + # Fail closed: never fall back to a plaintext upload when an + # encryption key is configured, an active attacker could otherwise + # strip the feature flag and capture the image (it contains the wifi + # credentials and the api encryption key). + if not (extended_proto and features & SERVER_FEATURE_SUPPORTS_NOISE): + raise OTAError( + "An OTA encryption key is configured but the device did not " + "offer encryption; refusing to send the image in plaintext. " + "If the running firmware predates OTA encryption, first update " + "it without the 'ota: encryption:' block (over a trusted " + "network or via USB), then restore the block and upload again." + ) + # The prologue binds every negotiation byte both sides saw, so any + # tampering with the plaintext preamble breaks the handshake. + prologue = ( + NOISE_PROLOGUE_INIT + + bytes(MAGIC_BYTES) + + bytes([RESPONSE_OK, version, features_to_send]) + + bytes([RESPONSE_FEATURE_FLAGS, features]) + ) + sock = NoiseSocketWrapper(sock, noise_psk, prologue) + sock.do_handshake() + _LOGGER.info("Encrypted connection established") + if ota_type != OTA_TYPE_UPDATE_APP: # Any non-app OTA type requires the extended protocol and the # partition-access server feature. Reject up front so the user gets @@ -572,6 +756,7 @@ def run_ota_impl_( password: str | None, filename: Path, ota_type: int = OTA_TYPE_UPDATE_APP, + noise_psk: str | None = None, ) -> tuple[int, str | None]: from esphome.core import CORE @@ -636,7 +821,7 @@ def run_ota_impl_( reached_device = True with contextlib.closing(sock), Path(filename).open("rb") as file_handle: try: - perform_ota(sock, password, file_handle, filename, ota_type) + perform_ota(sock, password, file_handle, filename, ota_type, noise_psk) except OTANetworkError as err: # Transient network failure; retry last_error = str(err) @@ -661,9 +846,12 @@ def run_ota( password: str | None, filename: Path, ota_type: int = OTA_TYPE_UPDATE_APP, + noise_psk: str | None = None, ) -> tuple[int, str | None]: try: - return run_ota_impl_(remote_host, remote_port, password, filename, ota_type) + return run_ota_impl_( + remote_host, remote_port, password, filename, ota_type, noise_psk + ) except OTAError as err: _LOGGER.error(err) return 1, None diff --git a/esphome/framework_helpers.py b/esphome/framework_helpers.py index aab7acc0e8..82bc0d3727 100644 --- a/esphome/framework_helpers.py +++ b/esphome/framework_helpers.py @@ -701,7 +701,7 @@ def _write_download_meta( _LOGGER.debug("Could not update download metadata %s: %s", meta, e) -def _content_length(resp: "requests.Response") -> int: +def content_length(resp: "requests.Response") -> int: """Return the response's Content-Length, or 0 when absent or malformed. 0 means "unknown", which downstream disables the progress bar and the @@ -744,7 +744,7 @@ def _stream_response_to_file( """ f.seek(offset) f.truncate(offset) - total_size = size or offset + _content_length(resp) + total_size = size or offset + content_length(resp) downloaded = offset own_bar: ProgressBar | None = None if progress is None: @@ -909,6 +909,19 @@ def _part_path(dest: Path) -> Path: return dest.with_name(dest.name + ".part") +def discard_partial_download(dest: Path) -> None: + """Remove ``dest`` and the resume sidecars of an abandoned download.""" + part = _part_path(dest) + for stale in (dest, part, part.with_name(part.name + ".meta")): + try: + stale.unlink() + except FileNotFoundError: + continue + except OSError as err: + # The caller's cache is never pruned; leave a trace + _LOGGER.debug("Could not remove %s: %s", stale, err) + + def _cancellable_sleep( delay: float, progress: Callable[[int], None] | None, done: int ) -> None: @@ -922,6 +935,31 @@ def _cancellable_sleep( time.sleep(min(0.5, remaining)) +def resume_fetch_job( + url: str, dest: PathType, **kwargs +) -> Callable[[Callable[[int], None]], None]: + """A ``run_batch_downloads`` job callable wrapping ``download_with_resume``. + + Forwards the runner's positional tracker as the ``progress`` keyword. + """ + + def fetch(tracker: Callable[[int], None]) -> None: + download_with_resume(url, dest, progress=tracker, **kwargs) + + return fetch + + +def warn_prefetch_failures( + failures: list[tuple[str, BaseException]], + message: str = "Could not prefetch %s: %s", +) -> None: + """Warn per failed batch-prefetch job; the caller's installer retries them.""" + for name, err in failures: + # failure_reason: a message-less exception must not log blank + _LOGGER.warning(message, name, failure_reason(err)) + _LOGGER.debug("Prefetch failure detail", exc_info=err) + + def download_with_resume( url: str, dest: PathType, @@ -1022,7 +1060,7 @@ def download_with_resume( streamed = True if offset == 0: validator = _response_validator(resp) - expected_total = _content_length(resp) + expected_total = content_length(resp) # Recorded so a later run can prove an If-Range # resume of this part file safe. _write_download_meta(meta, url, validator, expected_total) diff --git a/esphome/git.py b/esphome/git.py index 9815377f51..14145a639b 100644 --- a/esphome/git.py +++ b/esphome/git.py @@ -457,6 +457,15 @@ def _clone_complete_marker_path(repo_dir: Path) -> Path: return repo_dir / ".git" / _CLONE_COMPLETE_MARKER +def has_complete_clone( + url: str, ref: str | None, domain: str, subpath: Path | None = None +) -> bool: + """Lock-free probe for a complete clone; can go stale immediately, so + best-effort decisions only, never a substitute for ``clone_or_update``.""" + repo_dir = _repo_entry_dir(_cache_key(url, ref), domain, subpath) + return _clone_complete_marker_path(repo_dir).is_file() + + def _clear_clone_complete_marker(repo_dir: Path) -> None: """Best-effort removal of the completion marker. diff --git a/esphome/helpers.py b/esphome/helpers.py index 4397111c2e..3ccf0fe65a 100644 --- a/esphome/helpers.py +++ b/esphome/helpers.py @@ -1,6 +1,6 @@ from __future__ import annotations -from collections.abc import Iterable, MutableMapping +from collections.abc import Callable, Iterable, MutableMapping from contextlib import suppress import ipaddress import logging @@ -402,6 +402,15 @@ def sort_ip_addresses(address_list: list[str]) -> list[str]: return [socket.getnameinfo(r[4], socket.NI_NUMERICHOST)[0] for r in res] +def get_usable_cpu_count() -> int: + """Return the number of CPUs usable by this process (affinity-aware + on Python 3.13+); 1 when the count is undeterminable.""" + count = ( + os.process_cpu_count() if hasattr(os, "process_cpu_count") else os.cpu_count() + ) + return count or 1 + + def get_bool_env(var, default=False): """Read a boolean env var: the ``cv.boolean`` spellings plus ``1``/``0``; anything else falls through to ``bool(value)``.""" @@ -447,23 +456,55 @@ def add_git_ceiling_directory(env: MutableMapping[str, str], directory: Path) -> env["GIT_CEILING_DIRECTORIES"] = os.pathsep.join(parts) -def rmtree(path: Path | str) -> None: - """Remove a directory tree, handling read-only files on Windows. +# Deletion attempts when a directory keeps being repopulated mid-delete +RMTREE_MAX_ATTEMPTS = 3 - On Windows, git pack files and other files may be marked read-only, - causing shutil.rmtree to fail. This handles that by removing the - read-only flag and retrying. + +def rmtree(path: Path | str) -> None: + """Remove a directory tree, tolerating common filesystem races. + + Read-only files (e.g. git pack files on Windows) get the read-only flag + removed and are retried. Paths that are already gone, whether the target + itself or entries vanishing mid-delete, are treated as removed. + Directories repopulated mid-delete (e.g. Finder recreating .DS_Store on + macOS) are retried a few times. """ + import errno import shutil + import time - def _onexc(func, path, exc): + def _onexc(func: Callable[..., object], path: str | Path, exc: OSError) -> None: + if isinstance(exc, FileNotFoundError): + _LOGGER.debug("rmtree: %s already gone", path) + return if os.access(path, os.W_OK): raise exc Path(path).chmod(stat.S_IWUSR | stat.S_IRUSR) func(path) - shutil.rmtree(path, onexc=_onexc) + last_err: OSError | None = None + for attempt in range(RMTREE_MAX_ATTEMPTS - 1): + try: + shutil.rmtree(path, onexc=_onexc) + return + except OSError as err: + if err.errno not in (errno.ENOTEMPTY, errno.EEXIST): + raise + _LOGGER.debug( + "rmtree: %s repopulated mid-delete (attempt %d): %s", + path, + attempt + 1, + err, + ) + last_err = err + # Give the racing writer (e.g. Finder) time to settle + time.sleep(0.05 * (attempt + 1)) + try: + shutil.rmtree(path, onexc=_onexc) + except OSError as err: + # Keep the earlier races visible in the traceback + raise err from last_err def walk_files(path: Path): diff --git a/esphome/idf_component.yml b/esphome/idf_component.yml index 62fd597845..e817a253d9 100644 --- a/esphome/idf_component.yml +++ b/esphome/idf_component.yml @@ -24,7 +24,7 @@ dependencies: espressif/esp32-camera: version: 2.1.7 espressif/mdns: - version: 1.11.3 + version: 1.12.0 espressif/esp_wifi_remote: version: 1.6.3 rules: diff --git a/esphome/platformio/library.py b/esphome/platformio/library.py index 1792647d6b..3ff60f8aaa 100644 --- a/esphome/platformio/library.py +++ b/esphome/platformio/library.py @@ -13,7 +13,7 @@ regardless of which toolchain consumes the result. """ from collections import deque -from collections.abc import Callable, Iterable +from collections.abc import Callable, Hashable, Iterable from dataclasses import dataclass, field from functools import partial import glob @@ -35,6 +35,7 @@ from esphome.framework_helpers import ( failure_reason, rmdir, run_batch_downloads, + warn_prefetch_failures, ) _LOGGER = logging.getLogger(__name__) @@ -73,6 +74,11 @@ SOURCE_KIND_FOR_SUFFIX: dict[str, str] = { ".ASM": "asm", } SRC_FILE_EXTENSIONS = list(SOURCE_KIND_FOR_SUFFIX) +# Suffixes that count as headers when probing whether a library has any +# usable files at all (compare against Path.suffix.lower()) +LIBRARY_HEADER_SUFFIXES = frozenset( + {".h", ".hpp", ".hh", ".hxx", ".inc", ".ipp", ".tcc"} +) DOMAIN = "pio_components" @@ -93,6 +99,17 @@ class Source: ) -> Path: raise NotImplementedError + def prefetch_key(self, dir_suffix: str) -> Hashable | None: + """Prefetch dedup identity; None = not prefetchable. Sources that + could write one cache dir must return equal keys (workers must never + share a dir); a coarser key only skips a prefetch.""" + return None + + def is_cached(self, dir_suffix: str, salt: str = "", namespace: str = "") -> bool: + """Whether a completed fetch exists; only consulted when + ``prefetch_key()`` is not None, True is the safe default.""" + return True + def source_root(self, build_path: Path) -> Path: """Directory holding the library's own files (manifest + sources). @@ -121,6 +138,9 @@ class URLSource(Source): h.update(salt.encode()) return base_dir / h.hexdigest()[:8] / dir_suffix + def prefetch_key(self, dir_suffix: str) -> Hashable | None: + return self.url if self.size else None + def is_cached(self, dir_suffix: str, salt: str = "", namespace: str = "") -> bool: """Whether a completed extraction already exists for this source.""" return ( @@ -171,14 +191,29 @@ class GitSource(Source): self.url = url self.ref = ref - def download( - self, dir_suffix: str, force: bool = False, salt: str = "", namespace: str = "" - ) -> Path: + @staticmethod + def _domain(salt: str, namespace: str) -> str: domain = DOMAIN if namespace: domain = f"{domain}/{namespace}" if salt: domain = f"{domain}/{salt}" + return domain + + def prefetch_key(self, dir_suffix: str) -> Hashable | None: + # The clone target dir is hash(url@ref)/ + return (self.url, self.ref, dir_suffix) + + def is_cached(self, dir_suffix: str, salt: str = "", namespace: str = "") -> bool: + """Whether a completed clone already exists for this source.""" + return git.has_complete_clone( + self.url, self.ref, self._domain(salt, namespace), Path(dir_suffix) + ) + + def download( + self, dir_suffix: str, force: bool = False, salt: str = "", namespace: str = "" + ) -> Path: + domain = self._domain(salt, namespace) path, _ = git.clone_or_update( url=self.url, ref=self.ref, @@ -328,6 +363,11 @@ class LibraryBackend: framework: str emit: Callable[["ConvertedLibrary"], None] cache_key: str + # Owner-less names this returns True for are skipped by the walk; + # the backend supplies them itself (e.g. core-bundled libraries) and + # reconciles provided_requests after resolving + provides: Callable[[str], bool] | None = None + provided_requests: set[str] = field(default_factory=set) def ensure_list[T](obj: T | list[T]) -> list[T]: @@ -468,7 +508,7 @@ def _valid_manifest_shape(data: Any) -> bool: ) -def check_library_data(data: dict, platform: str | None, framework: str): +def check_library_data(data: dict, platform: str | None, framework: str | None): """ Check whether a library manifest is compatible with the target toolchain. @@ -485,7 +525,8 @@ def check_library_data(data: dict, platform: str | None, framework: str): for targets (e.g. Zephyr) where PIO manifests rarely declare the platform yet portable libraries still build. framework: The active framework name (e.g. ``espidf``, ``arduino``, - ``zephyr``) the manifest is expected to declare. + ``zephyr``) the manifest is expected to declare. ``None`` skips + the framework check (and its warning), mirroring ``platform``. Raises: InvalidLibrary: If the library does not support the target platform. @@ -516,7 +557,7 @@ def check_library_data(data: dict, platform: str | None, framework: str): # under the target framework, and there's no way to opt out of the check at # this layer. Warn instead of failing so the user isn't forced to fork the # library to fix the manifest. - valid_framework = "*" in frameworks or framework in frameworks + valid_framework = framework is None or "*" in frameworks or framework in frameworks if not valid_framework: _LOGGER.warning( @@ -913,6 +954,56 @@ def is_lib_ignored(name: str | None, lib_ignore: set[str]) -> bool: ) +def _reconcile_versionless_skips( + skipped_versionless: list[tuple[Any, Any, str]], + components: dict[str, ConvertedLibrary], + backend: LibraryBackend, +) -> None: + """Warn for version-less deps nothing satisfied, and record the + backend-provided ones in ``backend.provided_requests`` for its + post-emit reconciliation; a silent drop surfaces as link errors far + from the cause.""" + resolved_manifest_names = {c.data.get("name") for c in components.values()} + # A treeless backend can never supply a bundled name; noise for it + log = _LOGGER.warning if backend.provides is not None else _LOGGER.debug + warned: set[str] = set() + for dep_name, dep_owner, requester in skipped_versionless: + if not isinstance(dep_name, str) or not dep_name or dep_name in warned: + continue + if dep_name in components: + # A version-less dep's request key is the name itself + continue + if ( + not dep_owner + and backend.provides is not None + and backend.provides(dep_name) + ): + # provides() only satisfies owner-less names (same guard as + # the walk's skip); record for the post-emit reconciliation. + # Checked before the manifest-name evidence so the overlap + # case warns once, in the backend's own suppression loop + backend.provided_requests.add(dep_name) + continue + if dep_name in resolved_manifest_names: + # Name-only evidence: a coincidental collision must stay + # visible where the user could pin it + warned.add(dep_name) + log( + "Version-less dependency %s of %s assumed satisfied by a " + "resolved library's manifest name only", + dep_name, + requester, + ) + continue + warned.add(dep_name) + log( + "Dependency %s of %s has no version to resolve and nothing " + "provides it; skipping", + dep_name, + requester, + ) + + def _fetch_source( component: ConvertedLibrary, salt: str, @@ -926,65 +1017,83 @@ def _fetch_source( ) +def _clone_source( + component: ConvertedLibrary, + salt: str, + namespace: str, + tracker: Callable[[int], None], +) -> None: + # No byte progress from git; one tick so a cancelled batch stops here + tracker(0) + component.source.download( + component.get_sanitized_name(), salt=salt, namespace=namespace + ) + + def _prefetch_wave( wave: list[tuple[str, ConvertedLibrary]], salt: str, namespace: str ) -> None: - """Best-effort parallel download of a wave's registry archives. + """Best-effort parallel fetch of a wave's registry archives and git clones. - The walk's own ``download()`` stays authoritative; duplicate URLs + The walk's own ``download()`` stays authoritative; duplicate sources prefetch once so two threads never share a cache directory. Archives whose size the registry did not report are left to the sequential loop, whose per-file bars don't interleave. A node a sibling in the - same wave supersedes has its archive fetched in vain (knowing better + same wave supersedes has its source fetched in vain (knowing better would need the manifests being downloaded). """ try: - components: list[ConvertedLibrary] = [] - seen: set[str] = set() + archives: list[ConvertedLibrary] = [] + clones: list[ConvertedLibrary] = [] + seen: set[Hashable] = set() for _key, component in wave: source = component.source - if not isinstance(source, URLSource) or not source.size: + name = component.get_sanitized_name() + dedup_key = source.prefetch_key(name) + if dedup_key is None or dedup_key in seen: continue - if source.url in seen: - continue - seen.add(source.url) + seen.add(dedup_key) try: - cached = source.is_cached( - component.get_sanitized_name(), salt=salt, namespace=namespace - ) + cached = source.is_cached(name, salt=salt, namespace=namespace) except OSError as err: # Best-effort, but visibly: a systematic probe failure makes - # every warm build re-download every archive + # every warm build re-fetch every source _LOGGER.warning("Cache probe for %s failed: %s", component.name, err) cached = False if cached: # A warm build must stay silent continue - components.append(component) - if not components: + (archives if isinstance(source, URLSource) else clones).append(component) + if not archives and not clones: return # Single-item waves (a dependency chain discovers one archive per # wave) go through the same runner: one download method, one bar - _LOGGER.info( - "Downloading %d library archive(s): %s", - len(components), - ", ".join(c.name for c in components), - ) + if archives: + _LOGGER.info( + "Downloading %d library archive(s): %s", + len(archives), + ", ".join(c.name for c in archives), + ) + if clones: + _LOGGER.info( + "Cloning %d library repo(s): %s", + len(clones), + ", ".join(c.name for c in clones), + ) failures = run_batch_downloads( "Downloading libraries", [ (c.name, c.source.size, partial(_fetch_source, c, salt, namespace)) - for c in components - ], + for c in archives + ] + # Size 0: clones share the worker pool without skewing the + # byte bar, whose total stays the archive sum + + [(c.name, 0, partial(_clone_source, c, salt, namespace)) for c in clones], + ) + # The sequential call below retries and raises the real error + warn_prefetch_failures( + failures, "Prefetch of %s failed (retrying sequentially): %s" ) - for name, err in failures: - # The sequential call below retries and raises the real error - _LOGGER.warning( - "Prefetch of %s failed (retrying sequentially): %s", - name, - failure_reason(err), - ) - _LOGGER.debug("Prefetch failure detail", exc_info=err) except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught # Same policy as the ESP-IDF twin: the prefetch must never become a # new way for the build to fail @@ -1086,6 +1195,8 @@ def convert_libraries( components: dict[str, ConvertedLibrary] = {} resolved_requirements: dict[str, frozenset[str]] = {} top_level_keys = set(top_level) + # (name, owner, requester) reconciled against the final resolution set + skipped_versionless: list[tuple[Any, Any, str]] = [] worklist = deque(dict.fromkeys(top_level)) while worklist: # Drain the frontier sequentially (spec resolution mutates shared @@ -1190,13 +1301,23 @@ def convert_libraries( component.data.get("dependencies"), component.name ): if "version" not in dependency: - # Cannot resolve from the registry; common for bundled - # names (Wire, SPI) -- unactionable noise above debug + # Cannot resolve from the registry; the post-emit + # reconciliation owns the drop warning + dep_name = dependency.get("name") _LOGGER.debug( "Skip version-less dependency %r of %s", - dependency.get("name"), + dep_name, component.name, ) + if not is_lib_ignored( + dep_name, lib_ignore + ) and dependency_is_usable( + dependency, backend.platform, backend.framework, component.name + ): + # Filtered or ignored deps are deliberately absent + skipped_versionless.append( + (dep_name, dependency.get("owner"), component.name) + ) continue if not dependency_is_usable( dependency, backend.platform, backend.framework, component.name @@ -1208,11 +1329,31 @@ def convert_libraries( if is_lib_ignored(dep_name, lib_ignore): _LOGGER.debug("Skip ignored dependency %s", dep_name) continue - # The version field may actually be a URL (git/archive dependency). + # The version may be a URL (git/archive), which names one + # specific source; never substitute a bundled library for it dep_version = dependency["version"] dep_url = _url_or_none(dep_version) if dep_url is not None: dep_version = None + elif ( + backend.provides is not None + and not dependency.get("owner") + and backend.provides(dep_name) + ): + # The backend adds it from its own tree; resolving here + # would fetch a same-named registry package + if dep_version and dep_version != "*": + # The pin is discarded; make the substitution visible + _LOGGER.warning( + "Dependency %s pins version %s; using the library " + "bundled with the framework instead", + dep_name, + dep_version, + ) + else: + _LOGGER.debug("Skip backend-provided dependency %s", dep_name) + backend.provided_requests.add(dep_name) + continue dep_key = add_spec(dep_name, dep_version, dep_url) node.edges.add(dep_key) worklist.append(dep_key) @@ -1266,4 +1407,6 @@ def convert_libraries( for component in components.values(): backend.emit(component) + _reconcile_versionless_skips(skipped_versionless, components, backend) + return [components[key] for key in top_level if key in components] diff --git a/esphome/platformio/prefetch.py b/esphome/platformio/prefetch.py new file mode 100644 index 0000000000..5097239065 --- /dev/null +++ b/esphome/platformio/prefetch.py @@ -0,0 +1,996 @@ +"""Parallel prefetch and install of the packages a PlatformIO run needs. + +Downloads the archives concurrently into PlatformIO's own download cache +(identical ``compute_download_path`` keys), then installs them through +PlatformIO's own ``_install`` with one worker per usable core, so +extraction (the serial, single-core half of a cold install) parallelizes +too and ``pio run`` finds every package already installed. Runs in a +subprocess like all PlatformIO execution: loading a platform executes +its code (pioarduino's penv setup rewrites ``sys.path``). A sentinel in +the build dir lets warm builds skip the spawn. Best-effort: any failure +logs and PlatformIO downloads and installs as before. Across processes +sharing a core dir every download destination is serialized by a file +lock; checksum-less URL downloads additionally stage under a stable +name and promote with an atomic rename. +""" + +from __future__ import annotations + +from collections.abc import Iterator +from concurrent.futures import ThreadPoolExecutor +from contextlib import contextmanager, suppress +import hashlib +import json +import logging +import os +from pathlib import Path +from queue import SimpleQueue +import signal +import subprocess +import sys +import threading +import time +from typing import Any, NamedTuple + +from esphome.framework_helpers import ( + content_length, + discard_partial_download, + failure_reason, + resume_fetch_job, + run_batch_downloads, + warn_prefetch_failures, +) +from esphome.helpers import get_bool_env, get_usable_cpu_count, rmtree + +_LOGGER = logging.getLogger(__name__) + + +@contextmanager +def _preserved_sys_path() -> Iterator[None]: + """Platform setup may rewrite sys.path (pioarduino's penv does); undo it.""" + saved = list(sys.path) + try: + yield + finally: + sys.path[:] = saved + + +# Concurrent registry resolutions / HEAD probes (each is network-bound) +_RESOLVE_WORKERS = 8 + +# A hung child must not block the build; downloads resume on the next run +_PREFETCH_TIMEOUT = 20 * 60 + +# Waiting on another process's URL download; past this, leave it to pio +_DOWNLOAD_LOCK_TIMEOUT = 60 + +# Child exit for a handled, already-warned failure; 1 would collide with +# the interpreter's own import-failure exit +_EXIT_HANDLED = 3 + +# Short lock-acquire slices so a waiting worker still observes Ctrl-C +_URI_LOCK_POLL = 1 + +# Resolution errored (vs a clean skip); suppresses the warm sentinel +_RESOLVE_FAILED = object() + + +def _sweep_stale_sidecars(download_dir: Path, expire_seconds: int) -> None: + """Prune resume sidecars pio's usage.db pruner cannot see. + + A version bump strands an aborted archive's sidecars forever. Lock + files stay: a held lock can carry an ancient mtime (O_TRUNC keeps + it), and unlinking one reopens the single-writer hole it guards. + """ + cutoff = time.time() - expire_seconds + try: + for f in download_dir.iterdir(): + if f.suffix not in (".part", ".meta", ".prefetch"): + continue + try: + if f.stat().st_mtime < cutoff: + f.unlink() + except OSError as err: + _LOGGER.debug("Could not remove %s: %s", f, err) + except OSError: + _LOGGER.debug("Could not sweep %s", download_dir, exc_info=True) + + +class _Resolved(NamedTuple): + """A registry spec resolved to its archive; ``cached`` skips the download.""" + + spec: Any + name: str + size: int + url: str + dl_path: Path + checksum: str + cached: bool + + +class _Group(NamedTuple): + """The installable ``(name, spec)`` entries of one package manager.""" + + manager: Any + entries: list[tuple[str, Any]] + is_platform: bool + + +# Child records a no-work run; the parent skips the next spawn while valid +_SENTINEL_NAME = ".esphome_prefetch.json" +_SENTINEL_SCHEMA = 1 + + +def _ini_sha256(build_dir: Path) -> str: + return hashlib.sha256((build_dir / "platformio.ini").read_bytes()).hexdigest() + + +def _sentinel_state(build_dir: Path) -> dict[str, Any]: + """The environment fingerprint a sentinel must match to stay valid.""" + # Same fingerprint as the heal stamp: the sentinel's dirs die with its wipe + from esphome.platformio.toolchain import current_python_minor + + return { + "schema": _SENTINEL_SCHEMA, + "ini_sha256": _ini_sha256(build_dir), + "python": current_python_minor(), + "core_dir_env": os.environ.get("PLATFORMIO_CORE_DIR", ""), + } + + +def _prefetch_is_warm(build_dir: Path) -> bool: + """Whether the last prefetch found nothing to do and nothing changed since.""" + try: + data = json.loads((build_dir / _SENTINEL_NAME).read_text(encoding="utf-8")) + dirs = data.pop("dirs") + return ( + data == _sentinel_state(build_dir) + and bool(dirs) + and all(Path(d).is_dir() for d in dirs) + ) + except FileNotFoundError: + return False + except (OSError, ValueError, KeyError, AttributeError, TypeError): + _LOGGER.debug("Ignoring invalid prefetch sentinel", exc_info=True) + return False + + +def prefetch_platformio_packages() -> None: + """Warm PlatformIO's download cache for the current project, in parallel.""" + from esphome.core import CORE + from esphome.platformio.toolchain import ( + default_libdeps_dir, + heal_platformio_python_env, + ) + + # Heal first: its Python-version wipe would discard freshly warmed + # caches and the sentinel's dirs (the later heal call is a no-op) + heal_platformio_python_env() + build_dir = Path(CORE.build_path) + if _prefetch_is_warm(build_dir): + return + # The child is esphome itself: PYTHONPATH stays so it imports this + # tree's esphome (tests/integration pins the source tree through it) + env = dict(os.environ) + # Must match run_platformio_cli's default or warm builds re-resolve + # every library + env.setdefault("PLATFORMIO_LIBDEPS_DIR", default_libdeps_dir()) + # -v/-vv must reach the child's debug logging or the swallowed + # failure detail is undiagnosable in the field + env["ESPHOME_PREFETCH_LOG_LEVEL"] = str(logging.getLogger().getEffectiveLevel()) + if CORE.dashboard: + # The child's progress bar and log escaping key off CORE.dashboard + env["ESPHOME_PREFETCH_DASHBOARD"] = "1" + cmd = [ + sys.executable, + "-m", + "esphome.platformio.prefetch", + str(build_dir), + CORE.name, + ] + try: + # Not a with-block: the lifetime spans the wait/terminate arms + proc = subprocess.Popen(cmd, env=env) # pylint: disable=consider-using-with + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + # The prefetch must never become a new way for the build to fail + _LOGGER.warning("PlatformIO package prefetch skipped: %s", failure_reason(err)) + _LOGGER.debug("Prefetch failure detail", exc_info=True) + return + try: + returncode = proc.wait(timeout=_PREFETCH_TIMEOUT) + except subprocess.TimeoutExpired: + _stop_child(proc) + _LOGGER.warning("PlatformIO package prefetch timed out; continuing without it") + return + except BaseException as err: + # SIGKILL (subprocess.run's choice on interrupt) could land inside + # a package-directory copy pio run would then trust; ask first + _stop_child(proc) + if isinstance(err, Exception): + # An unexpected wait() failure must degrade, not fail the build + _LOGGER.warning( + "PlatformIO package prefetch skipped: %s", failure_reason(err) + ) + return + raise + if returncode == _EXIT_HANDLED: + # The child already warned with the reason; a second line is noise + _LOGGER.debug("Prefetch child reported a handled failure") + elif returncode != 0: + # Exit 1 stays here: the interpreter exits 1 for import/module + # failures before main() ever runs, a wiring break worth a warning + _LOGGER.warning("PlatformIO package prefetch skipped (exit %d)", returncode) + + +def _stop_child(proc: subprocess.Popen) -> None: + """Stop the child without cutting an in-flight package install short. + + Wait first (a terminal interrupt already unwinds the child), then + SIGTERM for the clean unwind main() installs, then kill. On Windows + terminate() cannot reach the handler, so its arm is a plain wait. + """ + if proc.poll() is None: + _LOGGER.info("Waiting for the prefetch child to finish its current install") + try: + with suppress(subprocess.TimeoutExpired): + proc.wait(timeout=5) + return + if sys.platform != "win32": + proc.terminate() + with suppress(subprocess.TimeoutExpired): + proc.wait(timeout=30) + return + proc.kill() + proc.wait(timeout=5) + # The kill can land mid-copy; the uncertainty must be visible + _LOGGER.warning("Prefetch child killed; a package install may be incomplete") + except KeyboardInterrupt: + # Kill so an interrupted stop cannot orphan a still-writing child + # (BaseException: a further interrupt must not skip the kill), + # then re-raise so the build aborts + with suppress(BaseException): + proc.kill() + proc.wait(timeout=5) + if proc.poll() is None: + _LOGGER.warning("The prefetch child could not be confirmed stopped") + raise + except Exception: # noqa: BLE001 # pylint: disable=broad-exception-caught + # A surviving child may still be writing packages pio run trusts + _LOGGER.warning("The prefetch child could not be confirmed stopped") + _LOGGER.debug("Stop detail", exc_info=True) + + +def _project_platform_and_config(ini: Path, env: str) -> tuple[str | None, Any]: + """The env's platform spec and the ProjectConfig for the given ini.""" + from platformio import app + from platformio.project.config import ProjectConfig + + # PlatformBase.config reads the default ProjectConfig; it must see + # this ini's env options + app.set_session_var("custom_project_conf", str(ini)) + config = ProjectConfig.get_instance(str(ini)) + return config.get(f"env:{env}", "platform", None), config + + +def _sibling_manager(manager: Any) -> Any: + """A same-store manager equivalent to the shared one.""" + # Hard read: a renamed attribute must fail loudly, not silently drop + # the qualifiers wave-1 installs resolve with; is-not-None so a falsy + # PackageCompatibility still propagates + if (compatibility := manager.compatibility) is not None: + return manager.__class__(manager.package_dir, compatibility=compatibility) + return manager.__class__(manager.package_dir) + + +def _registry_jobs( + manager: Any, specs: list[Any], seen: set[str] +) -> tuple[list[tuple[str, int, Any]], int, list[tuple[str, Any]]]: + """Resolve registry specs to ``(name, size, fetch)`` batch jobs. + + Mirrors PlatformIO's install path: best version, systype file, first + mirror, and the same sha1(url + checksum) download-cache key. Also + returns how many resolutions errored (a clean skip is not an error) + and the ``(name, spec)`` pairs whose archives will be installable. + """ + from platformio.registry.mirror import RegistryFileMirrorIterator + + local = threading.local() + errors: list[str] = [] + + def _resolve(spec) -> _Resolved | object | None: + # One manager (and registry HTTP session) per worker thread; + # installed-state was already checked on the shared manager + if (mgr := getattr(local, "mgr", None)) is None: + mgr = local.mgr = _sibling_manager(manager) + try: + packages = mgr.search_registry_packages(spec) + if not packages: + _LOGGER.debug("%s is unknown to the registry", spec) + return None # let PlatformIO report it + package, version = mgr.find_best_registry_version(packages, spec) + if not package or not version: + _LOGGER.debug("%s has no matching registry version", spec) + return None + pkgfile = mgr.pick_compatible_pkg_file(version["files"]) + if not pkgfile: + _LOGGER.debug("%s has no file for this systype", spec) + return None + url, checksum = next(RegistryFileMirrorIterator(pkgfile["download_url"])) + checksum = checksum or pkgfile["checksum"]["sha256"] + dl_path = Path(mgr.compute_download_path(url, checksum)) + cached = dl_path.is_file() # fetched by an earlier run + size = pkgfile.get("size") + if not cached and not size: + _LOGGER.debug("%s has no size; PlatformIO fetches it", spec) + return None # no size, no bar share + name = f"{package['name']}@{version['name']}" + return _Resolved(spec, name, size or 0, url, dl_path, checksum, cached) + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + # One flaky spec must not discard the rest of the batch + _LOGGER.debug("Could not resolve %s", spec, exc_info=True) + errors.append(failure_reason(err)) + return _RESOLVE_FAILED + + # Serial disk lookups on the shared manager: a fully warm build + # resolves nothing, and duplicate specs resolve once + unique: dict[tuple[str | None, str, str], Any] = {} + for s in specs: + if not s.uri and not manager.get_package(s): + unique.setdefault((s.owner, s.name, str(s.requirements)), s) + pending = list(unique.values()) + if not pending: + return [], 0, [] + # Serial resolutions (registry GET + mirror HEAD each) dominate + with ThreadPoolExecutor(max_workers=min(_RESOLVE_WORKERS, len(pending))) as ex: + results = list(ex.map(_resolve, pending)) + jobs: list[tuple[str, int, Any]] = [] + installable: list[tuple[str, Any]] = [] + for res in results: + if res is None or res is _RESOLVE_FAILED: + continue + installable.append((res.name, res.spec)) + if res.cached or str(res.dl_path) in seen: + continue # already fetched, or a duplicate must not share a .part + seen.add(str(res.dl_path)) + jobs.append( + ( + res.name, + res.size, + _registry_fetch_job( + manager, res.url, res.dl_path, res.checksum, res.size + ), + ) + ) + if failed := len(errors): + # Visible once per build, naming a cause so an API break does not + # read as an outage; per-spec detail stays at debug + _LOGGER.warning( + "Could not resolve %d of %d PlatformIO package(s) (%s); " + "PlatformIO will download them serially", + failed, + len(pending), + errors[0], + ) + return jobs, failed, installable + + +def _uri_jobs( + manager: Any, specs: list[Any], seen: set[str] +) -> tuple[list[tuple[str, int, Any]], int, list[tuple[str, Any]]]: + """Jobs for direct-URL specs; a HEAD sizes each for the combined bar. + + Also returns how many HEAD probes errored (an absent length is not an + error) and the ``(name, spec)`` pairs whose archives will be + installable. + """ + from esphome.net_retry import fetch_with_retry, http_request + + candidates: list[tuple[str, str, Path, Any]] = [] + installable: list[tuple[str, Any]] = [] + for spec in specs: + url = spec.uri + if not url or not url.startswith(("http://", "https://")): + continue # git+/file specs are cloned/copied, not downloaded + if url.split("#", 1)[0].endswith(".git"): + continue # bare-URL VCS spec; PlatformIO clones it + if manager.get_package(spec): + continue + name = spec.name or url.rsplit("/", 1)[-1] + # PlatformIO downloads URL specs with no checksum + dl_path = Path(manager.compute_download_path(url, "")) + if dl_path.is_file(): + if spec.has_custom_name(): + # Only a custom name (Foo=https://...) is the destination + # dir; a URI-derived name's destination comes from the + # archive manifest, so its dedupe key could collide with + # another name and race one directory. pio run installs it. + installable.append((name, spec)) # fetched by an earlier run + continue + if str(dl_path) in seen: + continue # another spec already claimed this .part + seen.add(str(dl_path)) + candidates.append((spec.name, url, dl_path, spec)) + + errors: list[str] = [] + + def _head_size(url: str) -> int: + try: + resp = fetch_with_retry(url, lambda: http_request("HEAD", url, timeout=30)) + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + _LOGGER.debug("HEAD %s failed", url, exc_info=True) + errors.append(failure_reason(err)) + return -1 + if not resp.ok: + # An error page's Content-Length is not a download size + _LOGGER.debug("HEAD %s returned %s", url, resp.status_code) + if resp.status_code in (401, 403, 408, 429) or resp.status_code >= 500: + # 401/403 included: registries rate-limit with them + errors.append(f"HTTP {resp.status_code}") + return -1 # transient; must not be cached as warm + # Permanent (405/501 HEAD-unsupported, 401/403/404): a clean + # skip so the warm sentinel is not disabled forever; pio run + # surfaces a genuinely broken URL when it downloads + return 0 + return content_length(resp) + + if not candidates: + return [], 0, installable + with ThreadPoolExecutor(max_workers=min(_RESOLVE_WORKERS, len(candidates))) as ex: + sizes = list(ex.map(_head_size, [url for _, url, _, _ in candidates])) + jobs: list[tuple[str, int, Any]] = [] + failed = 0 + for (name, url, dl_path, spec), size in zip(candidates, sizes, strict=True): + if size < 0: + failed += 1 + elif size: + jobs.append((name, size, _uri_fetch_job(manager, url, dl_path, size))) + if spec.has_custom_name(): + # See above: derived-name specs stay with pio run's installer + installable.append((name, spec)) + else: + # Missing or unusable Content-Length; visible under -v + _LOGGER.debug("%s reports no usable length; PlatformIO fetches it", url) + if failed: + _LOGGER.warning( + "Could not size %d of %d PlatformIO package URL(s) (%s); " + "PlatformIO will download them serially", + failed, + len(candidates), + errors[0], + ) + return jobs, failed, installable + + +def _serialized_fetch_job( + dl_path: Path, lock_path: str, body: Any, unlocked_ok: bool = True +) -> Any: + """Wrap ``body`` so the shared destination is single-writer. + + Interleaved writers truncate each other's ``.part`` bytes (see + registry.py). The bounded poll observes Ctrl-C via the tracker; a + blown deadline is a clean skip (the holder's copy is what the build + needs). On a lock-less filesystem a sha256-verified body runs + unlocked with one warning; a checksum-less one + (``unlocked_ok=False``) is a counted failure instead. + """ + + def run(tracker: Any) -> None: + from filelock import FileLock, Timeout + + # fallback_to_soft would leave a stale marker on lock-less + # filesystems that blocks every later build (see git.py) + lock = FileLock(lock_path, fallback_to_soft=False) + deadline = time.monotonic() + _DOWNLOAD_LOCK_TIMEOUT + while True: + try: + lock.acquire(timeout=_URI_LOCK_POLL) + break + except Timeout: + tracker(0) # raises when the batch is cancelled + if time.monotonic() >= deadline: + # Another process is fetching this same file; its copy + # is what the build needs (a large framework archive + # can hold the lock far longer than this deadline) + _LOGGER.debug("Leaving %s to its current downloader", dl_path.name) + return + except OSError as err: + if not unlocked_ok: + # A body with no checksum to catch interleaved corruption + raise + lock = None + _LOGGER.warning( + "Could not lock %s (%s); downloading unlocked", + dl_path.name, + err, + ) + break + try: + if dl_path.is_file(): + return # another process finished it while we waited + body(tracker) + finally: + if lock is not None: + lock.release() + + return run + + +# usage.db is a whole-file rewrite behind pio's self-unlinking LockFile; +# concurrent writers could reset every recorded entry +_REGISTER_LOCK = threading.Lock() + + +def _register_download(manager: Any, dl_path: Path) -> None: + """Hand the archive to pio's usage.db pruner; an unregistered one is + never expired (disk garbage, never a bad build).""" + try: + with _REGISTER_LOCK: + manager.set_download_utime(str(dl_path)) + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + _LOGGER.debug("Could not register %s with pio's cache: %s", dl_path, err) + + +def _registry_fetch_job( + manager: Any, url: str, dl_path: Path, checksum: str, size: int +) -> Any: + """A locked fetch straight to the cache path; sha256 verifies it.""" + # .esphome.lock: pio's own LockFile(dl_path) owns .lock and + # deletes it on release, which would unlink a held filelock + fetch = _serialized_fetch_job( + dl_path, + f"{dl_path}.esphome.lock", + resume_fetch_job(url, dl_path, sha256=checksum, size=size), + ) + + def run(tracker: Any) -> None: + fetch(tracker) + if dl_path.is_file(): + # The deadline skip can end with no archive landed + _register_download(manager, dl_path) + + return run + + +def _uri_fetch_job(manager: Any, url: str, dl_path: Path, size: int) -> Any: + """Fetch to a locked staging path, then rename into the cache. + + The stable staging name keeps resume working across interrupted + runs; the rename makes the promotion atomic. + """ + tmp = dl_path.with_name(f"{dl_path.name}.prefetch") + # attempts=2: the size is only a HEAD probe's word, and a HEAD/GET + # disagreement would otherwise re-download the archive five times + fetch = resume_fetch_job(url, tmp, size=size, attempts=2) + + def promote(tracker: Any) -> None: + fetch(tracker) + if (actual := tmp.stat().st_size) != size: + # A wrong-length checksum-less body must never be published + discard_partial_download(tmp) + raise ValueError(f"expected {size} bytes, fetched {actual}") + tmp.replace(dl_path) + + def run(tracker: Any) -> None: + _serialized_fetch_job(dl_path, f"{tmp}.lock", promote, unlocked_ok=False)( + tracker + ) + if dl_path.is_file(): + # Won or lost, the race is over; staging files left behind + # are dead weight PlatformIO's cache never prunes + discard_partial_download(tmp) + _register_download(manager, dl_path) + + return run + + +# (name, spec) from wave 1, (name, spec, compatibility) from dep waves +_Entry = tuple[str, Any] | tuple[str, Any, Any] + + +def _dependency_entries( + manager: Any, entries: list[_Entry], seen_names: set[str] +) -> list[_Entry]: + """Registry dependencies of the installed entries, one per new name. + + Mostly local manifest reads; the builtin probe walks installed + platforms (each may run platform code). Name-only platform libs stay + with pio run. + """ + + # Hard read: losing this filter would pre-install incompatible + # packages pio run then trusts + compatibility = manager.compatibility + # Tool managers have no builtin table; the contract test pins the name + is_builtin = getattr(manager, "is_builtin_lib", None) + deps: dict[str, Any] = {} + skipped = 0 + for name, spec, *_ in entries: + try: + deps_of = _entry_dependencies(manager, spec, compatibility, is_builtin) + except Exception: # noqa: BLE001 # pylint: disable=broad-exception-caught + # One unreadable manifest must not drop the group's whole wave + _LOGGER.debug("Skipping dependencies of %s", name, exc_info=True) + skipped += 1 + continue + for key, entry in deps_of: + if key not in seen_names: + deps.setdefault(key, entry) + if skipped: + # Visible at default verbosity: a dropped subtree silently + # degrades the wave; per-entry detail stays at debug + _LOGGER.warning( + "Could not read dependencies of %d of %d package(s)", + skipped, + len(entries), + ) + return list(deps.values()) + + +def _entry_dependencies( + manager: Any, spec: Any, compatibility: Any, is_builtin: Any +) -> list[tuple[str, _Entry]]: + from platformio.package.meta import PackageCompatibility + + out: list[tuple[str, _Entry]] = [] + if (pkg := manager.get_package(spec)) is None: + # Only successful installs are walked, so this is a real anomaly + # (stale memcache, name/dir mismatch, a pio API change); raising + # folds it into the caller's aggregate dropped-subtree warning + raise RuntimeError(f"just-installed {spec} is not resolvable") + for dep in manager.get_pkg_dependencies(pkg) or []: + if not (dep.get("owner") or dep.get("version")): + continue + if compatibility and not PackageCompatibility.from_dependency( + dep + ).is_compatible(compatibility): + continue # pio's install_dependency would skip it too + dspec = manager.dependency_to_spec(dep) + if ( + is_builtin + and not dspec.owner + and not dspec.external + and is_builtin(dspec.name) + ): + # pio's LibraryPackageManager.install_dependency skips + # builtins; a registry copy would shadow the bundled one + continue + if not (key := (dspec.name or "").lower()): + _LOGGER.debug("Dependency %r of %s has no name; left to pio run", dep, spec) + continue + if manager.get_package(dspec) is not None: + continue # already installed + # Carry the dep's compatibility so _install searches the + # registry qualified, exactly like pio's install_dependency + out.append( + (key, (dspec.name, dspec, PackageCompatibility.from_dependency(dep))) + ) + return out + + +def _clean_failed_install(mgr: Any, name: str, spec: Any) -> None: + # A post-copy failure leaves a package pio run would trust; remove it + # so pio run genuinely reinstalls it + try: + mgr.memcache_reset() + if (pkg := mgr.get_package(spec)) is not None: + # Dropping the metadata is the invariant: pio's own install + # overwrites a metadata-less dir, so a stuck tree cannot be + # trusted. The rmtree is best-effort tidiness. + (Path(pkg.path) / ".piopm").unlink(missing_ok=True) + with suppress(OSError): + rmtree(pkg.path) + else: + # Nothing was moved into place; the common failure shape + _LOGGER.debug("No on-disk install of %s to remove", name) + except Exception as cleanup_err: # noqa: BLE001 # pylint: disable=broad-exception-caught + _LOGGER.warning( + "Could not remove the failed install of %s: %s", + name, + failure_reason(cleanup_err), + ) + + +def _preinstall( + manager: Any, entries: list[_Entry], seen_names: set[str] | None = None +) -> None: + """Install downloaded packages in parallel via pio's own ``_install``. + + ``entries`` are ``_Entry`` tuples, one per destination directory. + The lock is held around each wave's pool, safe only because pio's + private ``_install`` never re-acquires it (a same-process re-lock + would hang, not fail). Waves skip dependencies; the installed + manifests feed the next wave. Any failure falls back to pio run. + """ + workers = min(get_usable_cpu_count(), len(entries)) + # One manager per worker (_install mutates instance state); built + # serially because construction rewires the shared manager logger + managers: SimpleQueue = SimpleQueue() + for _ in range(workers): + managers.put(_sibling_manager(manager)) + local = threading.local() + + def _install_one(entry) -> bool: + # Wave-1 entries are (name, spec); dependency waves add compatibility + name, spec, *rest = entry + compat = rest[0] if rest else None + if (mgr := getattr(local, "mgr", None)) is None: + # at most `workers` pool threads, one dequeue each + mgr = local.mgr = managers.get_nowait() + try: + mgr._install( # pylint: disable=protected-access # noqa: SLF001 + spec, skip_dependencies=True, compatibility=compat + ) + return True + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + _LOGGER.warning("Could not pre-install %s: %s", name, failure_reason(err)) + _LOGGER.debug("Pre-install failure detail", exc_info=True) + _clean_failed_install(mgr, name, spec) + return False + except BaseException: + # A SystemExit from a postinstall must not skip the cleanup + # and leave a torn dir pio run trusts + _clean_failed_install(mgr, name, spec) + raise + + _LOGGER.info( + "Installing %d PlatformIO package(s) with %d extraction worker(s): %s", + len(entries), + workers, + ", ".join(name for name, *_ in entries), + ) + # Postinstall scripts chdir process-globally; the cwd is restored + # after the pool. Concurrent postinstalls can still race pio's + # non-reentrant fs.cd mid-pool; that install fails, warns, and is + # redone serially by pio run. Suppress interleaved progress bars. + os.environ.setdefault("PLATFORMIO_DISABLE_PROGRESSBAR", "true") + # get_tmp_dir/get_download_dir create without exist_ok; racing workers + # would FileExistsError, so create them serially first. Concurrent + # usage.db updates can drop download bookkeeping; never a bad build. + manager.get_tmp_dir() + manager.get_download_dir() + cwd = Path.cwd() + manager.lock() + try: + with ThreadPoolExecutor(max_workers=workers) as ex: + try: + results = list(ex.map(_install_one, entries)) + except BaseException: + # Drop queued installs; in-flight ones finish so no + # package directory is left half copied + ex.shutdown(wait=True, cancel_futures=True) + raise + finally: + # Cleanup must not mask an in-flight exception or skip a step + # Each step runs even if an earlier one fails, and none may + # displace the in-flight exception (SIGTERM's SystemExit + # included) with a downgradeable one + wave_ok = True + for step, label in ( + (manager.memcache_reset, "reset the storage cache"), + (manager.unlock, "release the manager lock"), + (lambda: os.chdir(cwd), "restore the working dir"), + ): + try: + step() + except Exception: # noqa: BLE001,PERF203 # pylint: disable=broad-exception-caught + wave_ok = False + _LOGGER.warning("Could not %s", label) + _LOGGER.debug("Teardown detail", exc_info=True) + if len(entries) > 1 and not any(results): + # A systematic fault, not one bad archive; pio run installs serially + _LOGGER.warning( + "Could not pre-install any of %d PlatformIO package(s)", len(entries) + ) + + seen = seen_names if seen_names is not None else set() + # All entries join seen (failures must not be re-queued); only + # successful installs feed the dependency walk + seen.update(name.split("@", 1)[0].lower() for name, *_ in entries) + installed = [e for e, ok in zip(entries, results, strict=True) if ok] + if not wave_ok: + # A stale cache, an unknown lock state, or a lost cwd would + # poison the next wave; pio run installs the rest cleanly + _LOGGER.warning("Skipping the dependency wave") + return + # The builtin probe may construct platforms + with _preserved_sys_path(): + next_entries = _dependency_entries(manager, installed, seen) + if next_entries: + # Terminates without a cap: every wave admits only never-seen + # names, so a cycle yields an empty next wave + _preinstall(manager, next_entries, seen) + + +def _prefetch(build_dir: Path, env: str) -> None: + from platformio.dependencies import get_core_dependencies + from platformio.package.manager.library import LibraryPackageManager + from platformio.package.manager.platform import PlatformPackageManager + from platformio.package.meta import PackageCompatibility, PackageSpec + from platformio.platform.factory import PlatformFactory + + platform_spec, config = _project_platform_and_config( + build_dir / "platformio.ini", env + ) + if not platform_spec: + # An env mismatch must not disable the feature with no trace + _LOGGER.debug( + "No platform for env %s in %s; nothing to prefetch", env, build_dir + ) + return + + # The platform (manifest plus build scripts) installs first and + # resolves the rest + with _preserved_sys_path(): + pm = PlatformPackageManager() + _sweep_stale_sidecars(Path(pm.get_download_dir()), pm.DOWNLOAD_CACHE_EXPIRE) + pkg = pm.install(platform_spec, skip_dependencies=True) + p = PlatformFactory.new(pkg) + p.configure_project_packages(env, ["run"]) + + specs = [ + p.get_package_spec(name) + for name, opts in p.packages.items() + if not opts.get("optional") + ] + # PIO's build engine installs tool-scons by its own registry spec at build + # start; a platform URL copy has no owner to match it, so prefetch that spec + specs = [s for s in specs if s.name != "tool-scons"] + specs.append( + PackageSpec( + owner="platformio", + name="tool-scons", + requirements=get_core_dependencies()["tool-scons"], + ) + ) + lib_deps = config.get(f"env:{env}", "lib_deps", []) + # pio run's storage dir for this env, with its compatibility + # qualifiers: an unqualified library install could land a different + # owner's package pio run would then trust + qualifiers: dict[str, Any] = {"platforms": [p.name]} + if framework := config.get(f"env:{env}", "framework", None): + qualifiers["frameworks"] = framework + libdeps_dir = Path(config.get("platformio", "libdeps_dir")) / env + lm = LibraryPackageManager( + str(libdeps_dir), compatibility=PackageCompatibility(**qualifiers) + ) + # A bare name is usually a framework built-in (WiFi, SPI); with no + # lib builders here to tell built-in from registry, skip it. The only + # cost is that an owner-less user library is not prefetched + lib_specs = [ + spec + for dep in lib_deps + if dep and not dep.startswith("$") + if (spec := PackageSpec(dep)).external or spec.owner + ] + + seen: set[str] = set() + jobs: list[tuple[str, int, Any]] = [] + groups: list[_Group] = [] + unresolved = 0 + for mgr, batch, is_platform in ((p.pm, specs, True), (lm, lib_specs, False)): + entries: list[tuple[str, Any]] = [] + for build_jobs in (_registry_jobs, _uri_jobs): + batch_jobs, failed, installable = build_jobs(mgr, batch, seen) + jobs += batch_jobs + unresolved += failed + entries += installable + if entries: + groups.append(_Group(mgr, entries, is_platform)) + + sentinel = build_dir / _SENTINEL_NAME + if jobs or groups: + # Real work invalidates any previous no-work record + sentinel.unlink(missing_ok=True) + failed_names: set[str] = set() + if jobs: + _LOGGER.info( + "Prefetching %d PlatformIO package(s): %s", + len(jobs), + ", ".join(name for name, _, _ in jobs), + ) + # PlatformIO retries failed packages itself, without resume + failures = run_batch_downloads("Downloading PlatformIO packages", jobs) + warn_prefetch_failures(failures) + failed_names = {name for name, _ in failures} + elif not groups and not unresolved: + # Record the no-work run so the parent skips the next spawn. + # A failed resolution is not "no work": a registry outage must + # not be cached as warm. + dirs = [config.get("platformio", "packages_dir")] + if lib_specs: + dirs.append(str(libdeps_dir)) + sentinel.write_text( + json.dumps({**_sentinel_state(build_dir), "dirs": dirs}), + encoding="utf-8", + ) + + platform_packages_installed = False + for mgr, entries, is_platform in groups: + # One install per destination: pio derives the directory from + # the package name, so key on the name part + to_install = { + name.split("@", 1)[0].lower(): (name, spec) + for name, spec in entries + if name not in failed_names + } + if to_install: + try: + _preinstall(mgr, list(to_install.values())) + if is_platform: + platform_packages_installed = True + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + # Each group degrades independently; pio run installs + # whatever this one did not + _LOGGER.warning( + "Pre-install failed for the %s group: %s", + mgr.__class__.__name__, + failure_reason(err), + ) + _LOGGER.debug("Pre-install group failure detail", exc_info=True) + if platform_packages_installed: + # pioarduino installs its real toolchains from configure (the registry + # package is a stub); settle that here so pio run does not redo it + with _preserved_sys_path(), ThreadPoolExecutor(max_workers=1) as ex: + # A worker so SIGTERM joins it; exception() so a postinstall exit only warns + err = ex.submit(p.configure_project_packages, env, ["run"]).exception() + if err is not None: + _LOGGER.warning( + "Could not settle platform packages: %s", failure_reason(err) + ) + _LOGGER.debug("Platform settle failure detail", exc_info=err) + + +def _sigterm(_signum, _frame) -> None: + # Raised in the main thread: the pool's BaseException arm cancels + # queued installs while in-flight copies finish, then finally runs + raise SystemExit(143) + + +def main(argv: list[str]) -> int: + """Subprocess entry point: ``prefetch ``.""" + from esphome.core import CORE + from esphome.log import setup_log + + signal.signal(signal.SIGTERM, _sigterm) + raw_level = os.environ.get("ESPHOME_PREFETCH_LOG_LEVEL") + try: + level = int(raw_level) if raw_level is not None else logging.INFO + except ValueError: + level = logging.INFO + # Mirror the parent's log setup: warnings keep their level prefix and + # color, and the download bar still draws under the dashboard + CORE.dashboard = get_bool_env("ESPHOME_PREFETCH_DASHBOARD") + setup_log(level) + # pio's managers attach their own handler and still propagate; without + # this every manager line also prints through the root handler. Their + # construction re-pins the logger to INFO, so a logger-level filter + # (which survives pio's handler reset) enforces a quiet level instead. + for cls_name in ( + "ToolPackageManager", + "LibraryPackageManager", + "PlatformPackageManager", + ): + manager_logger = logging.getLogger(cls_name.replace("Package", " ")) + manager_logger.propagate = False + manager_logger.addFilter(lambda record: record.levelno >= level) + if len(argv) != 2: + # A wiring bug, not a network failure; make it distinguishable + _LOGGER.warning("prefetch usage: ") + return 2 + build_dir, env = argv + try: + _prefetch(Path(build_dir), env) + except KeyboardInterrupt: + # Shared process group: exit quietly, no traceback on the terminal + _LOGGER.debug("Prefetch interrupted", exc_info=True) + return 130 + except Exception as err: # noqa: BLE001 # pylint: disable=broad-exception-caught + # The parent treats any exit as warn-and-continue, never a failure + _LOGGER.warning("PlatformIO package prefetch skipped: %s", failure_reason(err)) + _LOGGER.debug("Prefetch failure detail", exc_info=True) + return _EXIT_HANDLED + return 0 + + +if __name__ == "__main__": # pragma: no cover + sys.exit(main(sys.argv[1:])) diff --git a/esphome/platformio/toolchain.py b/esphome/platformio/toolchain.py index cf2094dfe0..97b32420da 100644 --- a/esphome/platformio/toolchain.py +++ b/esphome/platformio/toolchain.py @@ -96,7 +96,7 @@ def _clean_platformio_python_env(config: "ProjectConfig", core_dir: Path) -> Non rmtree(penv) -def _current_python_minor() -> str: +def current_python_minor() -> str: """Return the running interpreter's ``major.minor`` (e.g. ``3.13``).""" return f"{sys.version_info.major}.{sys.version_info.minor}" @@ -161,7 +161,7 @@ def heal_platformio_python_env() -> None: def _check_platformio_python_stamp(config: "ProjectConfig") -> None: """Compare the stamp to the running interpreter; wipe and restamp on mismatch.""" - current = _current_python_minor() + current = current_python_minor() stamp_dir = _pio_stamp_dir(config) # Host the stamp/lock even before PlatformIO's first run creates the dir. stamp_dir.mkdir(parents=True, exist_ok=True) @@ -289,6 +289,12 @@ def copy_ccache_script() -> None: ) +def default_libdeps_dir() -> str: + """The PLATFORMIO_LIBDEPS_DIR value a pio run defaults to; the package + prefetch must resolve installed libraries against the same dir.""" + return str(CORE.relative_piolibdeps_path().absolute()) + + def run_platformio_cli(*args, **kwargs) -> str | int: # Re-provision the PlatformIO cache if the interpreter's major.minor changed # since it was last built; a stale platform otherwise rejects the new Python @@ -296,9 +302,7 @@ def run_platformio_cli(*args, **kwargs) -> str | int: heal_platformio_python_env() os.environ["PLATFORMIO_FORCE_COLOR"] = "true" os.environ["PLATFORMIO_BUILD_DIR"] = str(CORE.relative_pioenvs_path().absolute()) - os.environ.setdefault( - "PLATFORMIO_LIBDEPS_DIR", str(CORE.relative_piolibdeps_path().absolute()) - ) + os.environ.setdefault("PLATFORMIO_LIBDEPS_DIR", default_libdeps_dir()) # Suppress Python syntax warnings from third-party scripts during compilation os.environ.setdefault("PYTHONWARNINGS", "ignore::SyntaxWarning") # Increase uv retry count to handle transient network errors (default is 3) @@ -346,6 +350,9 @@ def run_platformio_cli_run(config, verbose, *args, **kwargs) -> str | int: def run_compile(config, verbose): + from esphome.platformio.prefetch import prefetch_platformio_packages + + prefetch_platformio_packages() args = [] if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]: args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"] diff --git a/esphome/yaml_util.py b/esphome/yaml_util.py index c280e550c9..7c6cf691b9 100644 --- a/esphome/yaml_util.py +++ b/esphome/yaml_util.py @@ -1057,11 +1057,19 @@ def _load_yaml_internal_with_type( loader.dispose() -def dump(dict_, show_secrets=False, sort_keys=False, relative_to: Path | None = None): +def dump( + dict_, + show_secrets=False, + sort_keys=False, + relative_to: Path | None = None, + data_dir: Path | None = None, +): """Dump YAML to a string and remove null. When ``relative_to`` is given, Path values are dumped relative to that - directory (POSIX form) so the output is machine independent. + directory (POSIX form) so the output is machine independent; Path values + under ``data_dir`` are then dumped as ``.esphome/``. ``data_dir`` + has no effect unless ``relative_to`` is also given. """ if show_secrets: _SECRET_VALUES.clear() @@ -1073,6 +1081,7 @@ def dump(dict_, show_secrets=False, sort_keys=False, relative_to: Path | None = class _Dumper(ESPHomeDumper): _redact_sensitive = not show_secrets _relative_to = relative_to + _data_dir = data_dir return yaml.dump( dict_, @@ -1231,6 +1240,9 @@ class ESPHomeDumper(yaml.SafeDumper): # directory (in POSIX form) so the output does not depend on where the # config lives on the machine that produced it. _relative_to: Path | None = None + # Paths under this directory are dumped as ``.esphome/`` so the + # add-on's ``/data`` mount matches the CLI layout. + _data_dir: Path | None = None def represent_mapping(self, tag, mapping, flow_style=None): value = [] @@ -1274,6 +1286,12 @@ class ESPHomeDumper(yaml.SafeDumper): # path that still cannot be relativized (e.g. a different drive) # keeps its POSIX form so separators stay stable across OSes. path = Path(os.path.normpath(value)) + # Checked first: the default data dir sits inside the config dir. + if self._data_dir is not None and path.is_relative_to( + data_dir := os.path.normpath(self._data_dir) + ): + rel = Path(".esphome") / path.relative_to(data_dir) + return self.represent_stringify(rel.as_posix()) with suppress(ValueError): path = path.relative_to( os.path.normpath(self._relative_to), walk_up=True diff --git a/platformio.ini b/platformio.ini index b2a36e687c..fcf7caa7c7 100644 --- a/platformio.ini +++ b/platformio.ini @@ -46,7 +46,7 @@ lib_deps = ${common.lib_deps_base} https://github.com/dudanov/MideaUART.git#eeea6c3e9b4474f067054592b435be1c4e466815 ; midea esphome/noise-c@0.1.21 ; noise (api, ota) - improv/Improv@1.2.6 ; improv_serial / esp32_improv + improv/Improv@1.2.7 ; improv_serial / esp32_improv kikuchan98/pngle@1.1.0 ; online_image ; Using the repository directly, otherwise ESP-IDF can't use the library https://github.com/bitbank2/JPEGDEC.git#1.8.4 ; online_image @@ -248,7 +248,7 @@ lib_deps = ESP32Async/AsyncTCP@3.4.5 ; async_tcp DNSServer ; captive_portal heman/AsyncMqttClient-esphome@2.0.0 ; mqtt - improv/Improv@1.2.6 ; improv_serial + improv/Improv@1.2.7 ; improv_serial kikuchan98/pngle@1.1.0 ; online_image https://github.com/bitbank2/JPEGDEC.git#1.8.4 ; online_image build_flags = diff --git a/requirements.txt b/requirements.txt index de00f07836..594b44432d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,6 +1,6 @@ # cryptography 49+ ships no Intel macOS wheels (arm64 only); esptool caps <49 there. # Keep 48.0.1, the last universal2 release, so esphome stays installable on Intel Macs. -cryptography==50.0.0; platform_system != "Darwin" or platform_machine != "x86_64" +cryptography==50.0.1; platform_system != "Darwin" or platform_machine != "x86_64" cryptography==48.0.1; platform_system == "Darwin" and platform_machine == "x86_64" voluptuous==0.16.0 PyYAML==6.0.3 @@ -12,22 +12,22 @@ pyserial==3.5 platformio==6.1.19 esptool==5.3.1 click==8.3.3 -aioesphomeapi==46.2.1 +aioesphomeapi==46.3.0 aiohappyeyeballs==2.7.1 # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi -zeroconf==0.150.0 +zeroconf==0.151.2 puremagic==2.2.0 ruamel.yaml==0.19.1 # dashboard_import ruamel.yaml.clib==0.2.15 # dashboard_import esphome-glyphsets==0.2.0 pillow==12.3.0 -resvg-py==0.4.0 +resvg-py==0.5.0 freetype-py==2.5.1 jinja2==3.1.6 bleak==3.0.2 smpclient==7.2.0 requests==2.34.2 py7zr==1.1.3 -platformdirs==4.11.3 # native esp-idf toolchain global cache dir +platformdirs==4.11.5 # native esp-idf toolchain global cache dir ninja==1.13.0 # native esp8266 arduino toolchain build driver filelock==3.32.4 # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg diff --git a/requirements_test.txt b/requirements_test.txt index cf4b028b0e..b1309ec63b 100644 --- a/requirements_test.txt +++ b/requirements_test.txt @@ -1,8 +1,8 @@ -pylint==4.0.7 +pylint==4.0.8 flake8==7.3.0 # also change in .pre-commit-config.yaml when updating -ruff==0.16.4 # also change in .pre-commit-config.yaml when updating +ruff==0.16.5 # also change in .pre-commit-config.yaml when updating pyupgrade==3.21.2 # also change in .pre-commit-config.yaml when updating -prek==0.4.14 # also change in .github/workflows/ci.yml when updating +prek==0.5.0 # also change in .github/workflows/ci.yml when updating # Unit tests pytest==9.1.1 diff --git a/script/ci-custom.py b/script/ci-custom.py index 2d2da20995..f481fda860 100755 --- a/script/ci-custom.py +++ b/script/ci-custom.py @@ -247,6 +247,8 @@ def lint_ext_check(fname): "CLAUDE.md", "GEMINI.md", ".github/copilot-instructions.md", + # Symlink to the real wifi scan_list.h so the test stub cannot drift + "tests/integration/fixtures/external_components/wifi/scan_list.h", ] ) def lint_executable_bit(fname: Path) -> str | None: @@ -317,6 +319,154 @@ def lint_no_long_delays(fname, match): ) +# An if/else/for/while whose only body is an unbraced ESP_LOG*() call. When the build's compile-time +# log level drops that macro, the body expands to nothing and the compiler warns (-Wempty-body). +# clang-tidy's brace check does not catch these (ShortStatementLines allows short unbraced bodies), so +# this fills that gap. Matched against comment/string-masked content, so commented-out or quoted code +# is ignored. Both spellings are covered: core/log.h defines the uppercase ESP_LOG*() macros and +# the lowercase esph_log_*() ones, and both expand to nothing below their log level. +# 'for' allows ';' inside its parentheses (the classic C-style header); 'if'/'while' do not, so their +# condition cannot run past the statement it guards. The 'for' header permits one level of nested +# parens so it stays bounded to its own statement: without that, it can run past the loop body and +# latch onto a later ')', mis-reporting the line and skipping the '#' preprocessor check below. +ESP_LOG_NEEDS_BRACES_RE = re.compile( + r"(?:\bif\s*\([^{};]*\)|\bwhile\s*\([^{};]*\)|\bfor\s*\((?:[^{}()]|\([^{}()]*\))*\)|\belse\b)" + r"[ \t]*\n?[ \t]*(?:ESP_LOG[A-Z]*|esph_log_[a-z]+)\s*\(", + re.MULTILINE, +) + + +def _mask_cpp_comments_strings(s): + """Return s with // and /* */ comments and string/char/raw-string literals blanked to spaces + (length and newlines preserved) so a regex only matches real code. Parentheses in real code are + kept, so callers can still balance them on the masked text.""" + out = list(s) + i = 0 + n = len(s) + while i < n: + c = s[i] + # Raw string literal: an optional encoding prefix, then R"delim( ... )delim". The body may + # contain quotes, //, /* and unbalanced parens, so it must be consumed as one unit. + if c == "R" and i + 1 < n and s[i + 1] == '"': + j = i + 2 + delim = "" + while j < n and s[j] not in "( \t\r\n\\" and len(delim) < 16: + delim += s[j] + j += 1 + if j < n and s[j] == "(": + closing = ")" + delim + '"' + end = s.find(closing, j + 1) + end = n if end == -1 else end + len(closing) + for k in range(i, end): + if s[k] != "\n": + out[k] = " " + i = end + continue + i += 1 + elif c == "/" and i + 1 < n and s[i + 1] == "/": + while i < n and s[i] != "\n": + out[i] = " " + i += 1 + elif c == "/" and i + 1 < n and s[i + 1] == "*": + out[i] = out[i + 1] = " " + i += 2 + while i < n and not (s[i] == "*" and i + 1 < n and s[i + 1] == "/"): + if s[i] != "\n": + out[i] = " " + i += 1 + if i < n: + out[i] = " " + if i + 1 < n: + out[i + 1] = " " + i += 2 + # A "'" after an alphanumeric or '_' is a C++ digit separator (1'000), not a literal opener. + elif c == '"' or ( + c == "'" and not (i and (s[i - 1].isalnum() or s[i - 1] == "_")) + ): + quote = c + out[i] = " " + i += 1 + while i < n: + if s[i] == "\\": + out[i] = " " + if i + 1 < n: + out[i + 1] = " " + i += 2 + continue + if s[i] == quote: + out[i] = " " + i += 1 + break + if s[i] != "\n": + out[i] = " " + i += 1 + else: + i += 1 + return "".join(out) + + +def _log_statement_end(masked, open_paren): + """Index of the ';' ending the ESP_LOG call whose '(' is at open_paren, or None. Balanced on the + masked text so quotes/comments inside the arguments do not confuse the paren count.""" + depth = 0 + i = open_paren + n = len(masked) + while i < n: + ch = masked[i] + if ch == "(": + depth += 1 + elif ch == ")": + depth -= 1 + if depth == 0: + j = i + 1 + while j < n and masked[j] != ";": + if not masked[j].isspace(): + return None + j += 1 + return j if j < n else None + i += 1 + return None + + +@lint_content_check(include=cpp_include) +def lint_esp_log_needs_braces(fname, content): + # Cheap bailout: no log call means nothing to flag, and skips masking the file entirely. + if "ESP_LOG" not in content and "esph_log_" not in content: + return [] + masked = _mask_cpp_comments_strings(content) + errors = [] + for match in ESP_LOG_NEEDS_BRACES_RE.finditer(masked): + pos = match.start() + line_start = content.rfind("\n", 0, pos) + 1 + # Skip preprocessor conditionals (#if/#else/#elif): not C++ control statements. + if content[line_start:pos].lstrip().startswith("#"): + continue + # A '// NOLINT' may sit at the end of the log line (where the message says to put it) or on the + # control-statement line, so scan the whole statement rather than only up to the ESP_LOG token. + stmt_end = _log_statement_end(masked, match.end() - 1) + nolint_end = ( + content.find("\n", stmt_end) if stmt_end is not None else match.end() + ) + if nolint_end == -1: + nolint_end = len(content) + if "NOLINT" in content[pos:nolint_end]: + continue + snippet = content[pos : match.end()].replace("\n", " ").strip() + errors.append( + ( + content.count("\n", 0, pos) + 1, + pos - line_start + 1, + ( + f"{highlight(snippet)} - an if/else/for/while body that is a single log " + "call must be wrapped in braces. When the log level compiles the macro out, the " + "body becomes empty and the compiler warns (-Wempty-body). Add { } around the " + "log call (or a '// NOLINT' comment if this is genuinely intended)." + ), + ) + ) + return errors + + @lint_content_check( include=[ "esphome/const.py", diff --git a/script/clang_tidy_hash.py b/script/clang_tidy_hash.py index f4fd5a4dff..bdc97bd766 100644 --- a/script/clang_tidy_hash.py +++ b/script/clang_tidy_hash.py @@ -1,13 +1,10 @@ -"""Files that affect clang-tidy results, and a content hash over them. +"""Files that affect clang-tidy results and the idedata built from them. -``CLANG_TIDY_GLOBAL_FILES`` (plus ``SDKCONFIG_DEFAULTS_PREFIX``) is the single -source of truth for which files influence clang-tidy output. A change to any of -them can surface warnings in source files a PR didn't touch, so: - -* ``script/determine-jobs.py`` runs a full clang-tidy scan when one changes, and -* ``calculate_clang_tidy_hash()`` folds them into the idedata cache key used by - ``script/helpers.py`` (a content hash, unlike an mtime check, stays correct - across git checkouts). +``CLANG_TIDY_GLOBAL_FILES`` (plus ``SDKCONFIG_DEFAULTS_PREFIX``) lists the files +that influence clang-tidy output; ``script/determine-jobs.py`` runs a full scan +when one changes. ``ESP_IDF_INFRA_TRIGGER_*`` lists the native ESP-IDF build +code. ``idedata_cache_hash()`` folds the right set into the idedata cache key +used by ``script/helpers.py`` and the CI cache action. """ from __future__ import annotations @@ -31,6 +28,18 @@ CLANG_TIDY_GLOBAL_FILES = ( # this prefix at the repo root. SDKCONFIG_DEFAULTS_PREFIX = "sdkconfig.defaults" +# Native ESP-IDF build infra: determine-jobs forces an esp32 compile when these +# change, and they feed the clang-tidy idedata cache key. +ESP_IDF_INFRA_TRIGGER_PATH_PREFIXES = ("esphome/espidf/", "esphome/build_helpers/") +ESP_IDF_INFRA_TRIGGER_FILES = frozenset( + { + "esphome/build_gen/espidf.py", + "esphome/framework_helpers.py", + "esphome/platformio/library.py", + "esphome/platformio/extra_script.py", + } +) + def read_file_bytes(path: Path) -> bytes: """Read bytes from a file.""" @@ -66,3 +75,33 @@ def calculate_clang_tidy_hash(repo_root: Path | None = None) -> str: hasher.update(read_file_bytes(path)) return hasher.hexdigest() + + +def calculate_idedata_cache_hash(repo_root: Path | None = None) -> str: + """Clang-tidy hash plus the Python that generates the idedata.""" + repo_root = _ensure_repo_root(repo_root) + + hasher = hashlib.sha256() + hasher.update(calculate_clang_tidy_hash(repo_root).encode()) + + paths = {repo_root / name for name in ESP_IDF_INFRA_TRIGGER_FILES} + for prefix in ESP_IDF_INFRA_TRIGGER_PATH_PREFIXES: + # .pyc files appear between the CI key computation and load_idedata's. + paths.update( + path + for path in (repo_root / prefix).rglob("*") + if "__pycache__" not in path.parts + ) + for path in sorted(paths): + if path.is_file(): + hasher.update(str(path.relative_to(repo_root)).encode()) + hasher.update(read_file_bytes(path)) + + return hasher.hexdigest() + + +def idedata_cache_hash(environment: str, repo_root: Path | None = None) -> str: + """Hash gating the cached idedata of one clang-tidy environment.""" + if "esp32" in environment: + return calculate_idedata_cache_hash(repo_root) + return calculate_clang_tidy_hash(repo_root) diff --git a/script/determine-jobs.py b/script/determine-jobs.py index 2bdf7807a9..f5412af21d 100755 --- a/script/determine-jobs.py +++ b/script/determine-jobs.py @@ -53,16 +53,25 @@ from collections import Counter from enum import StrEnum from functools import cache import json +import math import os from pathlib import Path +import statistics import sys from typing import Any -from clang_tidy_hash import CLANG_TIDY_GLOBAL_FILES, SDKCONFIG_DEFAULTS_PREFIX +from clang_tidy_hash import ( + CLANG_TIDY_GLOBAL_FILES, + ESP_IDF_INFRA_TRIGGER_FILES, + ESP_IDF_INFRA_TRIGGER_PATH_PREFIXES, + SDKCONFIG_DEFAULTS_PREFIX, +) from helpers import ( CPP_FILE_EXTENSIONS, ESPHOME_TESTS_COMPONENTS_PATH, + INTEGRATION_TESTS_PATH, PYTHON_FILE_EXTENSIONS, + all_integration_test_files, base_python_changed, changed_files, core_changed, @@ -78,6 +87,8 @@ from helpers import ( get_target_branch, git_ls_files, is_validate_only_file, + load_integration_durations, + lpt_partition, root_path, ) from split_components_for_ci import create_intelligent_batches @@ -91,24 +102,24 @@ CLANG_TIDY_SPLIT_THRESHOLD = 65 # Isolated components count as 10x, groupable components count as 1x COMPONENT_TEST_BATCH_SIZE = 40 -# Integration test bucketing: when more than the threshold tests are scheduled, -# fan out across this many parallel jobs. Below the threshold, a single job runs. +# Above the threshold, fan out across up to this many jobs, balanced by the +# recorded per-file durations. The target is serial junit-time weight per +# bucket, not wall time (calibrated with the conftest compile cap); it +# sizes the bucket count for small subsets. INTEGRATION_TESTS_SPLIT_THRESHOLD = 10 -INTEGRATION_TESTS_SPLIT_BUCKETS = 3 +INTEGRATION_TESTS_SPLIT_BUCKETS = 5 +INTEGRATION_TESTS_TARGET_BUCKET_WEIGHT = 360.0 - -def _split_list(items: list[str], n: int) -> list[list[str]]: - """Split a list into n roughly-equal contiguous parts (matches script/clang-tidy).""" - k, m = divmod(len(items), n) - return [items[i * k + min(i, m) : (i + 1) * k + min(i + 1, m)] for i in range(n)] - - -def _all_integration_test_files() -> list[str]: - """Return all integration test file paths, sorted, relative to repo root.""" - return sorted( - str(p.relative_to(root_path)) - for p in (Path(root_path) / "tests" / "integration").glob("test_*.py") - ) +# platformio and aioesphomeapi (requirements.txt), the pytest stack +# (requirements_test.txt) and the fixture every session compiles; a change +# to any runs the full matrix +INTEGRATION_TESTS_TRIGGER_FILES = frozenset( + { + "requirements.txt", + "requirements_test.txt", + "tests/integration/fixtures/cache_init.yaml", + } +) def _compute_integration_test_buckets( @@ -117,7 +128,7 @@ def _compute_integration_test_buckets( ) -> tuple[bool, list[dict[str, Any]]]: """Compute (run_integration, buckets) from the determine_integration_tests result. - Pure function for unit testing — no I/O beyond `_all_integration_test_files` + Pure function for unit testing — no I/O beyond `all_integration_test_files` when `integration_run_all` is set. `buckets` is a list of `{name, tests}` dicts where `tests` is a JSON-friendly @@ -125,7 +136,7 @@ def _compute_integration_test_buckets( shell word-splitting / glob hazards. """ if integration_run_all: - files = _all_integration_test_files() + files = all_integration_test_files() else: files = sorted(integration_test_files) @@ -136,12 +147,23 @@ def _compute_integration_test_buckets( return False, [] if len(files) > INTEGRATION_TESTS_SPLIT_THRESHOLD: - parts = [ - part for part in _split_list(files, INTEGRATION_TESTS_SPLIT_BUCKETS) if part - ] + durations = load_integration_durations() + # Unrecorded files weigh the recording's median; with no recording a + # file weighs a whole bucket, which keeps the full fan-out + default = ( + statistics.median(durations.values()) + if durations + else INTEGRATION_TESTS_TARGET_BUCKET_WEIGHT + ) + weights = {f: durations.get(f, default) for f in files} + count = min( + INTEGRATION_TESTS_SPLIT_BUCKETS, + math.ceil(sum(weights.values()) / INTEGRATION_TESTS_TARGET_BUCKET_WEIGHT), + ) + # count <= SPLIT_BUCKETS < threshold < len(files): no group is empty + parts = [sorted(part) for part in lpt_partition(files, weights, count)] buckets = [ - {"name": f"{i + 1}/{len(parts)}", "tests": part} - for i, part in enumerate(parts) + {"name": f"{i + 1}/{count}", "tests": part} for i, part in enumerate(parts) ] else: buckets = [{"name": "1/1", "tests": files}] @@ -216,12 +238,15 @@ def determine_integration_tests(branch: str | None = None) -> tuple[bool, list[s 3. Integration test infrastructure files changed - conftest.py, types.py, const.py, entity_utils.py, state_utils.py, etc. + 4. A file in INTEGRATION_TESTS_TRIGGER_FILES changed + - The dependency pins and the session init fixture affect every test + Returns (run_all=False, [test_files...]) when: - 4. Specific integration test files changed + 5. Specific integration test files changed - Only those specific test files are returned - 5. Components used by integration tests (or their dependencies) changed + 6. Components used by integration tests (or their dependencies) changed - Only test files whose fixtures use the changed components are returned Args: @@ -239,12 +264,15 @@ def determine_integration_tests(branch: str | None = None) -> tuple[bool, list[s # If any core files changed, run all integration tests return (True, []) + if any(f in INTEGRATION_TESTS_TRIGGER_FILES for f in files): + return (True, []) + # If infrastructure Python files changed (conftest, utils, etc.), run all tests # Excludes test files (test_*.py), fixtures, and non-Python files (README.md) if any( - f.startswith("tests/integration/") + f.startswith(INTEGRATION_TESTS_PATH) and f.endswith(".py") - and not f.startswith("tests/integration/test_") + and not f.startswith(f"{INTEGRATION_TESTS_PATH}test_") and "/fixtures/" not in f for f in files ): @@ -255,9 +283,9 @@ def determine_integration_tests(branch: str | None = None) -> tuple[bool, list[s fixture_to_test_files = get_fixture_to_test_files() for f in files: - if f.startswith("tests/integration/test_") and f.endswith(".py"): + if f.startswith(f"{INTEGRATION_TESTS_PATH}test_") and f.endswith(".py"): test_files.add(f) - elif f.startswith("tests/integration/fixtures/"): + elif f.startswith(f"{INTEGRATION_TESTS_PATH}fixtures/"): if f.endswith(".yaml"): # Fixture YAML changed - add corresponding test file(s) test_files.update(fixture_to_test_files.get(Path(f).stem, ())) @@ -524,23 +552,6 @@ def _esp32_platformio_path_or_file_trigger(files: list[str]) -> bool: return False -# Native-build infra: changes under esphome/espidf/, the shared -# esphome/build_helpers/ package, or the modules the native ESP-IDF build -# imports affect every esp32 IDF build (now the default toolchain) but aren't -# components, so the component matrix wouldn't otherwise force any esp32 -# compile. When they change we fold the `esp32` component into the matrix so -# the default native-IDF build path is still compiled on an infra-only PR. -ESP_IDF_INFRA_TRIGGER_PATH_PREFIXES = ("esphome/espidf/", "esphome/build_helpers/") -ESP_IDF_INFRA_TRIGGER_FILES = frozenset( - { - "esphome/build_gen/espidf.py", - "esphome/framework_helpers.py", - "esphome/platformio/library.py", - "esphome/platformio/extra_script.py", - } -) - - def _esp_idf_infra_changed(files: list[str]) -> bool: """Whether any changed file is ESP-IDF build/runner infrastructure.""" for file in files: @@ -1410,6 +1421,7 @@ def main() -> None: output: dict[str, Any] = { "core_ci": run_core_ci, "integration_tests": run_integration, + "integration_run_all": integration_run_all, "integration_test_buckets": integration_test_buckets, "clang_tidy": run_clang_tidy, "clang_tidy_mode": clang_tidy_mode, diff --git a/script/git-hooks/post-checkout b/script/git-hooks/post-checkout new file mode 100755 index 0000000000..8f4085ae6e --- /dev/null +++ b/script/git-hooks/post-checkout @@ -0,0 +1,20 @@ +#!/bin/sh +# Prepare the dev environment for a new checkout or worktree. +# +# Installed into the git hooks directory by script/setup. Deliberately tiny and +# self-contained: it stays valid on branches where script/setup does not exist, +# and simply does nothing there. + +# $3 is 1 for a branch checkout, 0 for a file checkout. +[ "$3" = "1" ] || exit 0 + +top=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0 + +# This also runs on ordinary branch switches, where there is nothing to do. +[ -x "$top/venv/bin/python" ] && exit 0 +[ -x "$top/script/setup" ] || exit 0 + +# Clear VIRTUAL_ENV so a checkout made from a shell with an environment already +# activated still gets its own, rather than having the active one repointed at +# this working tree. +exec env -u VIRTUAL_ENV "$top/script/setup" diff --git a/script/helpers.py b/script/helpers.py index 9e3969e5ce..bf22e15808 100644 --- a/script/helpers.py +++ b/script/helpers.py @@ -43,6 +43,53 @@ ESPHOME_TESTS_COMPONENTS_PATH = "tests/components/" # Tuple of component and test paths for efficient startswith checks COMPONENT_AND_TESTS_PATHS = (ESPHOME_COMPONENTS_PATH, ESPHOME_TESTS_COMPONENTS_PATH) +# Integration tests path prefix +INTEGRATION_TESTS_PATH = "tests/integration/" + +# Per-file integration test durations from CI junit output; shared by the +# reader (determine-jobs) and writer (update_integration_test_durations) +INTEGRATION_TEST_DURATIONS_FILE = "tests/integration/integration_test_durations.json" + + +def all_integration_test_files() -> list[str]: + """Return all integration test file paths, sorted, relative to repo root.""" + return sorted( + p.relative_to(root_path).as_posix() + for p in (Path(root_path) / "tests" / "integration").glob("test_*.py") + ) + + +def load_integration_durations() -> dict[str, float]: + """Return recorded per-file pytest durations in seconds; empty when unavailable.""" + try: + raw = json.loads( + (Path(root_path) / INTEGRATION_TEST_DURATIONS_FILE).read_text() + ) + if not isinstance(raw, dict): + print( + f"integration durations unavailable: expected an object, " + f"got {type(raw).__name__}", + file=sys.stderr, + ) + return {} + except (OSError, ValueError) as err: + # The file ships in the repo; degrade to unweighted bucketing, loudly + print(f"integration durations unavailable: {err}", file=sys.stderr) + return {} + durations = { + key: seconds + for key, value in raw.items() + if isinstance(value, (int, float)) and (seconds := float(value)) > 0 + } + if len(durations) != len(raw): + # One bad entry must not discard the whole recording + print( + f"dropped {len(raw) - len(durations)} invalid duration entries", + file=sys.stderr, + ) + return durations + + # Base bus components - these ARE the bus implementations and should not # be flagged as needing migration since they are the platform/base components BASE_BUS_COMPONENTS = { @@ -809,17 +856,14 @@ def load_idedata(environment: str) -> dict[str, Any]: start_time = time.time() print(f"Loading IDE data for environment '{environment}'...") - # Reuse the clang-tidy input hash as the cache key: it already covers every - # file baked into the generated idedata (platformio.ini, sdkconfig.defaults, - # esphome/idf_component.yml), so this can't drift from that file list. A - # content hash -- unlike an mtime comparison -- stays correct across git - # checkouts, which don't preserve mtimes. - from clang_tidy_hash import calculate_clang_tidy_hash + # Content hash of the idedata inputs (data files and the generator code); a + # content hash, unlike mtimes, stays correct across git checkouts. + from clang_tidy_hash import idedata_cache_hash temp_idedata = Path(temp_folder) / f"idedata-{environment}.json" temp_hash = Path(temp_folder) / f"idedata-{environment}.hash" - cache_key = calculate_clang_tidy_hash() + cache_key = idedata_cache_hash(environment) changed = ( not temp_idedata.is_file() or not temp_hash.is_file() @@ -1548,3 +1592,21 @@ def get_cpp_changed_components(files: list[str]) -> list[str]: if file.startswith(ESPHOME_COMPONENTS_PATH): affected.update(find_children_of_component(components_graph, component)) return sorted(c for c in affected if has_cpp_unit_tests(c, tests_dir)) + + +def lpt_partition( + items: list[str], weights: dict[str, float], count: int +) -> list[list[str]]: + """Partition items into `count` weight-balanced groups (LPT greedy). + + Heaviest item first into the lightest group. Ties keep input order, so + pass pre-sorted items for deterministic output. script/clang-tidy's + split_list is the unweighted contiguous sibling. + """ + groups: list[list[str]] = [[] for _ in range(count)] + group_weights = [0.0] * count + for item in sorted(items, key=lambda i: -weights[i]): + lightest = min(range(count), key=group_weights.__getitem__) + groups[lightest].append(item) + group_weights[lightest] += weights[item] + return groups diff --git a/script/platformio_install_deps.py b/script/platformio_install_deps.py index 8f7261efc3..1c4fb28b30 100755 --- a/script/platformio_install_deps.py +++ b/script/platformio_install_deps.py @@ -3,58 +3,375 @@ # all platformio libraries in the global storage import argparse +from concurrent.futures import ThreadPoolExecutor import configparser +from contextlib import suppress +import os +from pathlib import Path +import queue import subprocess +import threading +import traceback -config = configparser.ConfigParser(inline_comment_prefixes=(";",)) +# esphome is not installed at this docker layer; pio's fs.rmtree is the +# same chmod-on-readonly shape its own installer uses +try: + from platformio import fs + from platformio.cache import ContentCache + from platformio.package.manager.base import BasePackageManager + from platformio.package.manager.library import LibraryPackageManager + from platformio.package.manager.tool import ToolPackageManager + from platformio.package.meta import PackageCompatibility -parser = argparse.ArgumentParser(description="") -parser.add_argument("file", help="Path to platformio.ini", nargs=1) -parser.add_argument("-l", "--libraries", help="Install libraries", action="store_true") -parser.add_argument("-p", "--platforms", help="Install platforms", action="store_true") -parser.add_argument("-t", "--tools", help="Install tools", action="store_true") + PARALLEL_AVAILABLE = True +except ImportError as err: # pragma: no cover + # A moved pio module must degrade to the serial pass, not kill the + # image build; the tripwire test makes the drift loud in CI + PARALLEL_AVAILABLE = False + IMPORT_ERROR = repr(err) -args = parser.parse_args() - -config.read(args.file) +# Network-bound downloads release the GIL, so the pool oversubscribes +# the cores. This bypasses pio's 500ms registry throttle and races its +# self-unlinking cache LockFiles; both are cache-only and self-healing. +MAX_WORKERS = 16 -libs = [] -tools = [] -platforms = [] -# Extract from every lib_deps key in all sections -for section in config.sections(): - conf = config[section] - if "lib_deps" in conf and args.libraries: - for lib_dep in conf["lib_deps"].splitlines(): - if not lib_dep: - # Empty line or comment - continue - if lib_dep.startswith("${"): - # Extending from another section - continue - if "@" not in lib_dep: - # No version pinned, this is an internal lib - continue - libs.append("-l") - libs.append(lib_dep) - if "platform" in conf and args.platforms: - platforms.append("-p") - platforms.append(conf["platform"]) - if "platform_packages" in conf and args.tools: - for tool in conf["platform_packages"].splitlines(): - if not tool: - # Empty line or comment - continue - if tool.startswith("${"): - # Extending from another section - continue - if tool.find("https://github.com") != -1: - split = tool.find("@") - tool = tool[split + 1 :] - tools.append("-t") - tools.append(tool) +class CleanupError(RuntimeError): + """A torn destination could not be removed; the serial pass would + trust it, so the build must fail rather than bake a corrupt image.""" -subprocess.check_call( - ["platformio", "pkg", "install", "-g", *libs, *platforms, *tools], close_fds=False -) + +class LockReleaseError(RuntimeError): + """The manager lock could not be released; the serial pass would + block on it, so the build must fail with the cause named.""" + + +def parse_specs(path: str, args: argparse.Namespace) -> tuple[list, list, list]: + """Extract lib/platform/tool specs from every section of a platformio.ini.""" + config = configparser.ConfigParser(inline_comment_prefixes=(";",)) + if not config.read(path): + # ConfigParser silently ignores unreadable files; an empty spec + # list would build an image with no dependencies at all + raise SystemExit(f"Could not read {path}") + libs = [] + tools = [] + platforms = [] + for section in config.sections(): + conf = config[section] + if "lib_deps" in conf and args.libraries: + for lib_dep in conf["lib_deps"].splitlines(): + if not lib_dep: + # Empty line or comment + continue + if lib_dep.startswith("${"): + # Extending from another section + continue + if "@" not in lib_dep: + # No version pinned, this is an internal lib + continue + libs.append(lib_dep) + if "platform" in conf and args.platforms: + platforms.append(conf["platform"]) + if "platform_packages" in conf and args.tools: + for tool in conf["platform_packages"].splitlines(): + if not tool: + # Empty line or comment + continue + if tool.startswith("${"): + # Extending from another section + continue + if tool.find("https://github.com") != -1: + split = tool.find("@") + tool = tool[split + 1 :] + tools.append(tool) + # Exact-string dedupe only: name-level dedupe would change which + # version conflicts the pkg install pass reconciles + return ( + list(dict.fromkeys(libs)), + list(dict.fromkeys(platforms)), + list(dict.fromkeys(tools)), + ) + + +def piopm_matches(package_dir: str, spec) -> list[Path]: + """Dirs whose .piopm metadata names this spec; a positive match beats + guessing the manifest-derived dirname from the registry name.""" + want = (BasePackageManager.ensure_spec(spec).name or "").lower() + matches: list[Path] = [] + if not want: + return matches + try: + entries = list(Path(package_dir).iterdir()) + except FileNotFoundError: + return matches + for d in entries: + if not d.is_dir(): + continue # pio's get_installed skips files and *.pio-link too + try: + meta = fs.load_json(str(d / ".piopm")) + except FileNotFoundError: + continue # no metadata means pio does not trust it either + except (OSError, ValueError): + if d.name.lower() == want: + # A corrupt .piopm under this spec's own name would crash + # pio's whole storage scan; remove it + matches.append(d) + continue + mspec = meta.get("spec") or {} + if (mspec.get("name") or meta.get("name") or "").lower() == want: + matches.append(d) + return matches + + +def remove_dir(spec, dest: Path) -> None: + # fs.rmtree never raises (errors go to a printing onexc handler); + # only the destination's absence proves the cleanup worked + fs.rmtree(str(dest)) + if dest.exists(): + # Failing the build beats baking a corrupt image + raise CleanupError( + f"could not remove the failed pre-install of {spec} at {dest}" + ) + print(f"Removed torn destination {dest}", flush=True) + + +def cleanup_or_die(mgr, spec) -> None: + """Cleanup that did not demonstrably succeed must fail the build.""" + try: + clean_torn(mgr, spec) + except CleanupError: + raise + except Exception as err: # noqa: BLE001 + raise CleanupError(f"cleanup failed for {spec}: {err!r}") from err + + +def clean_torn(mgr, spec) -> None: + """Remove a torn destination so the serial pass cannot trust it.""" + pkg = None + with suppress(Exception): + # get_package memoizes a pre-install snapshot; reset to see the + # torn dir. It also recognizes manifest-only legacy dirs pio's + # storage scan would trust, which the .piopm fallback cannot see. + mgr.memcache_reset() + pkg = mgr.get_package(spec) + if pkg is not None: + remove_dir(spec, Path(pkg.path)) + elif dests := piopm_matches(mgr.package_dir, spec): + # A .piopm naming this spec is the exact shape the serial pass + # trusts; a dir without one is overwritten by pio's own install + for dest in dests: + remove_dir(spec, dest) + else: + print(f"No resolvable destination to clean for {spec}", flush=True) + + +def spec_key(spec) -> str | None: + """The destination identity of a spec: PlatformIO installs by package + name, so two specs sharing a name share a directory. ``None`` means + the name could not be derived; such a spec must stay out of the wave + (a raw-string key would break the one-per-destination guarantee).""" + name = BasePackageManager.ensure_spec(spec).name + return name.lower() if name else None + + +def dependency_specs(manager, specs: list) -> list: + """``(spec, compatibility)`` registry dependencies of installed + packages, from local manifest reads. Name-only dependencies + (platform-bundled libs like SPI) stay with the ``pkg install`` pass; + the compatibility qualifiers mirror pio's install_dependency, so a + qualified dep resolves to the same package the serial pass picks.""" + return [ + (manager.dependency_to_spec(dep), PackageCompatibility.from_dependency(dep)) + for spec in specs + if (pkg := manager.get_package(spec)) is not None + for dep in manager.get_pkg_dependencies(pkg) or [] + if dep.get("owner") or dep.get("version") + ] + + +def parallel_install(manager_cls, specs: list, prior_names: set | None = None) -> None: + """Best-effort parallel top-level install. + + PlatformIO's own installer downloads and unpacks one package at a time + on one core. Dependencies are skipped (two packages sharing one must + not extract into the same directory from two threads) and failures are + only reported: the stock ``pkg install`` pass afterwards installs + whatever is missing and is the authority on the final state. + """ + if not specs: + return + manager = manager_cls(None) + # One spec per destination: two threads must not extract into the + # same directory. Second versions of a name and URL specs (their dir + # comes from the archive manifest) stay with the pkg install pass. + seen_names: set = prior_names if prior_names is not None else set() + # Wave-1 items are strings; dependency waves carry (spec, compatibility) + pairs = [item if isinstance(item, tuple) else (item, None) for item in specs] + unique = {} + for spec, compat in pairs: + # Normalize once: a dependency's URL version surfaces as spec.uri + parsed = BasePackageManager.ensure_spec(spec) + if parsed.uri: + continue + if (key := spec_key(parsed)) is None: + # No name, no destination identity; leave it to the serial pass + print(f"Skipping unresolvable spec {spec!r} in the wave", flush=True) + continue + unique.setdefault(key, (spec, compat)) # first-wins, like pio's walk + pending = [ + (spec, compat) + for spec, compat in unique.values() + if not manager.get_package(spec) + ] + if not pending: + # Nothing to install, but a warm store's dependencies must still + # feed the next wave (a transitive dep may be missing) + _next_wave(manager_cls, manager, unique, seen_names) + return + workers = min(len(pending), MAX_WORKERS) + # One manager per worker (_install mutates instance state); built + # serially because construction rewires the shared manager logger + managers: queue.SimpleQueue = queue.SimpleQueue() + for _ in range(workers): + managers.put(manager_cls(None)) + local = threading.local() + + def install_one(item) -> bool: + spec, compat = item + if (mgr := getattr(local, "mgr", None)) is None: + mgr = local.mgr = managers.get_nowait() + try: + mgr._install( # noqa: SLF001 + spec, skip_dependencies=True, compatibility=compat + ) + return True + except Exception as err: # noqa: BLE001 + print(f"Pre-install of {spec} failed ({err!r})", flush=True) + cleanup_or_die(mgr, spec) + return False + except BaseException: + # A worker SystemExit (main() guards against it) must not skip + # the cleanup and leave a torn dir the serial pass trusts + cleanup_or_die(mgr, spec) + raise + + print(f"Preinstalling {len(pending)} package(s) with {workers} workers", flush=True) + # The serial getter calls create pio's lazy dirs (made without + # exist_ok) before cold-cache workers can race the creation + manager.get_download_dir() + manager.get_tmp_dir() + ContentCache("http") + cwd = Path.cwd() + manager.lock() + try: + with ThreadPoolExecutor(max_workers=workers) as ex: + futures = [ex.submit(install_one, item) for item in pending] + # The with-block joined every future; drain them all so a + # concurrent CleanupError is never dropped + errors = [err for f in futures if (err := f.exception()) is not None] + for err in errors: + # Every failure is on the record; the raised one is a summary + print(f"Wave failure: {err!r}", flush=True) + if errors: + raise next((e for e in errors if isinstance(e, CleanupError)), errors[0]) + results = [f.result() for f in futures] + finally: + try: + manager.unlock() + except Exception as unlock_err: # noqa: BLE001 + # A held flock would hang the serial pass in another process; + # failing loudly beats an unexplained stuck docker build. Any + # in-flight error stays attached as the context. + raise LockReleaseError( + f"could not release the manager lock: {unlock_err!r}" + ) from unlock_err + # Worker postinstall scripts chdir process-wide (pio's fs.cd); + # restore between waves. The serial pass pins its own cwd. + with suppress(OSError): + os.chdir(cwd) + if failures := len(results) - sum(results): + # The stock pass retries CLI specs and re-walks installed + # packages' dependencies, so failed deps retry too + print( + f"Pre-install failed for {failures} of {len(results)} package(s); " + "pkg install retries them serially", + flush=True, + ) + + # Waves skip dependencies (a shared one must not extract from two + # threads); the installed manifests feed the next wave + _next_wave(manager_cls, manager, unique, seen_names) + + +def _next_wave(manager_cls, manager, unique: dict, seen_names: set) -> None: + """Queue the dependency wave for every requested spec, installed or + freshly waved; a warm store can still be missing a transitive dep. + Terminates without a cap: each wave admits only never-seen names.""" + seen_names.update(unique) + # The pre-wave get_package calls memoized an empty storage snapshot + manager.memcache_reset() + next_specs = [ + item + for item in dependency_specs(manager, [spec for spec, _ in unique.values()]) + if spec_key(item[0]) not in seen_names + ] + if next_specs: + parallel_install(manager_cls, next_specs, seen_names) + + +def build_cli_args(libs: list, platforms: list, tools: list) -> list: + return [ + arg + for flag, specs in (("-l", libs), ("-p", platforms), ("-t", tools)) + for spec in specs + for arg in (flag, spec) + ] + + +def main() -> None: + parser = argparse.ArgumentParser(description="") + parser.add_argument("file", help="Path to platformio.ini", nargs=1) + parser.add_argument( + "-l", "--libraries", help="Install libraries", action="store_true" + ) + parser.add_argument( + "-p", "--platforms", help="Install platforms", action="store_true" + ) + parser.add_argument("-t", "--tools", help="Install tools", action="store_true") + args = parser.parse_args() + start_cwd = Path.cwd() + libs, platforms, tools = parse_specs(args.file[0], args) + + # Platforms stay serial: PlatformPackageManager.install runs an + # on_installed hook the private _install path would skip + if PARALLEL_AVAILABLE: + wave_groups = [(ToolPackageManager, tools), (LibraryPackageManager, libs)] + else: # pragma: no cover + wave_groups = [] + print( + f"PlatformIO layout changed ({IMPORT_ERROR}); serial install only", + flush=True, + ) + for manager_cls, specs in wave_groups: + try: + parallel_install(manager_cls, specs) + except (CleanupError, LockReleaseError, KeyboardInterrupt): + # A torn package or a held lock must fail the build + raise + except BaseException: # noqa: BLE001 + # BaseException: a worker postinstall's SystemExit must not + # skip the authoritative serial pass (partial deps, exit 0) + print("Parallel preinstall failed, falling back to serial", flush=True) + traceback.print_exc() + + # Postinstall scripts chdir process-wide (pio's fs.cd captures its + # restore path at construction); pin the authoritative pass's cwd + subprocess.check_call( + ["platformio", "pkg", "install", "-g", *build_cli_args(libs, platforms, tools)], + close_fds=False, + cwd=start_cwd, + ) + + +if __name__ == "__main__": + main() diff --git a/script/setup b/script/setup index 5dfc0efe5d..b96af6e8f3 100755 --- a/script/setup +++ b/script/setup @@ -7,13 +7,19 @@ cd "$(dirname "$0")/.." if [ -n "$VIRTUAL_ENV" ]; then # A virtual environment is already active (e.g. the devcontainer's pre-provisioned # esphome-venv). Install into it rather than creating a ./venv in the workspace. - created_venv=false + venv_state=active +elif [ -x venv/bin/python ]; then + # Reuse the environment from an earlier run, so this script can be run again + # at any time to pick up dependency changes. + venv_state=reused + source venv/bin/activate else - created_venv=true + venv_state=created + # --clear replaces a partial environment left behind by an interrupted run. if [ -x "$(command -v uv)" ]; then - uv venv --seed venv + uv venv --clear --seed venv else - python3 -m venv venv + python3 -m venv --clear venv fi source venv/bin/activate fi @@ -25,20 +31,41 @@ fi uv pip install setuptools wheel uv pip install -e ".[dev,test]" --config-settings editable_mode=compat -# --overwrite replaces any hook already in place. Without it, prek finds a -# previously installed pre-commit hook, moves it aside to -# .git/hooks/pre-commit.legacy and keeps calling it, so every commit would -# run both tools. -prek install --overwrite +# A worktree shares one git hooks directory with the main checkout it was +# created from, so hooks are installed from the main checkout only. Installing +# from a worktree would point the shared hook at that worktree's virtual +# environment, breaking it for everyone once the worktree is removed. +git_dir="$(git rev-parse --absolute-git-dir 2>/dev/null || true)" +common_dir="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true)" +if [ -n "$common_dir" ] && [ "$git_dir" = "$common_dir" ]; then + # --overwrite replaces any hook already in place. Without it, prek finds a + # previously installed pre-commit hook, moves it aside to + # .git/hooks/pre-commit.legacy and keeps calling it, so every commit would + # run both tools. + prek install --overwrite + + # Prepares the virtual environment for new checkouts and worktrees. Installed + # once here, it covers every worktree created from this checkout. + if [ -d "$common_dir/hooks" ]; then + cp script/git-hooks/post-checkout "$common_dir/hooks/post-checkout" + chmod +x "$common_dir/hooks/post-checkout" + fi +fi mkdir -p .temp echo echo -if [ "$created_venv" = true ]; then - echo "Virtual environment created at ./venv. Run 'source venv/bin/activate' to use it." -else - echo "Dependencies installed into the active virtual environment:" - echo " $VIRTUAL_ENV" - echo "It is already active in this shell, so no 'source venv/bin/activate' is needed." -fi +case "$venv_state" in + created) + echo "Virtual environment created at ./venv. Run 'source venv/bin/activate' to use it." + ;; + reused) + echo "Dependencies updated in the existing ./venv. Run 'source venv/bin/activate' to use it." + ;; + active) + echo "Dependencies installed into the active virtual environment:" + echo " $VIRTUAL_ENV" + echo "It is already active in this shell, so no 'source venv/bin/activate' is needed." + ;; +esac diff --git a/script/update_integration_test_durations.py b/script/update_integration_test_durations.py new file mode 100755 index 0000000000..bbb959c0b2 --- /dev/null +++ b/script/update_integration_test_durations.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +"""Merge CI junit output into tests/integration/integration_test_durations.json. + +The integration-tests CI job uploads one junit XML artifact per bucket on +full matrix dev runs. Download a run's artifacts and merge the per file +durations into the recording used by script/determine-jobs.py: + + gh run download --repo esphome/esphome -p "junit-integration-*" -D /tmp/junit + script/update_integration_test_durations.py /tmp/junit + +Missing files keep their previous recording and deleted files drop out; a +run covering under 90% of the test files aborts unless --allow-partial. +""" + +from __future__ import annotations + +import argparse +from collections import defaultdict +import json +from pathlib import Path +import sys +import xml.etree.ElementTree as ET + +from helpers import ( + INTEGRATION_TEST_DURATIONS_FILE, + INTEGRATION_TESTS_PATH, + all_integration_test_files, + load_integration_durations, + root_path, +) + +DURATIONS_FILE = Path(root_path) / INTEGRATION_TEST_DURATIONS_FILE +MIN_COVERAGE = 0.9 +# Exit code for the expected "run covers too few files" refusal, so the +# refresh workflow can move on to the next candidate run +EXIT_LOW_COVERAGE = 3 + + +def collect_durations(junit_dir: Path, known_files: set[str]) -> dict[str, float]: + """Sum junit testcase times per integration test file, in seconds.""" + durations: defaultdict[str, float] = defaultdict(float) + unmatched = 0 + xml_files = sorted(junit_dir.rglob("*.xml")) + if not xml_files: + raise SystemExit(f"no junit XML files found under {junit_dir}") + for xml_file in xml_files: + for testcase in ET.parse(xml_file).getroot().iter("testcase"): + # Skipped/errored testcases carry time="0"; recording them would + # overwrite a good previous duration + if any( + testcase.find(tag) is not None + for tag in ("skipped", "error", "failure") + ): + continue + # classname is the dotted module plus any test class, e.g. + # tests.integration.test_x or tests.integration.test_x.TestFoo + parts = testcase.get("classname", "").split(".") + if parts[:2] != ["tests", "integration"] or len(parts) < 3: + unmatched += 1 + continue + path = f"{INTEGRATION_TESTS_PATH}{parts[2]}.py" + if path not in known_files: + print(f"skipping unknown test module {path}", file=sys.stderr) + continue + durations[path] += float(testcase.get("time", "0")) + if unmatched: + # A junit naming change would otherwise shrink the recording silently + raise SystemExit( + f"{unmatched} testcases with unexpected classnames; the junit layout changed" + ) + # An all-skipped file totals 0.0; let the merge keep its previous entry + return {k: v for k, v in durations.items() if v > 0} + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "junit_dir", type=Path, help="directory containing downloaded junit XML files" + ) + parser.add_argument( + "--allow-partial", + action="store_true", + help="merge a run covering under 90%% of the test files", + ) + args = parser.parse_args() + + on_disk = set(all_integration_test_files()) + if not on_disk: + raise SystemExit("no integration test files found; wrong checkout root?") + collected = collect_durations(args.junit_dir, on_disk) + coverage = len(collected.keys() & on_disk) / len(on_disk) + if coverage < MIN_COVERAGE and not args.allow_partial: + print( + f"artifacts cover only {coverage:.0%} of {len(on_disk)} test files; " + "use a full matrix run or pass --allow-partial to merge anyway", + file=sys.stderr, + ) + return EXIT_LOW_COVERAGE + + # Validated load: a bad previous entry cannot survive the round trip, and + # an unreadable file aborts rather than being overwritten + previous = load_integration_durations() + if DURATIONS_FILE.is_file() and not previous: + raise SystemExit(f"{DURATIONS_FILE} is unreadable; refusing to overwrite it") + # New recordings win, absent files keep theirs, deleted files drop out + merged = { + path: collected.get(path, previous.get(path)) + for path in sorted(on_disk) + if path in collected or path in previous + } + DURATIONS_FILE.write_text( + json.dumps({k: round(v, 2) for k, v in merged.items()}, indent=2) + "\n" + ) + print(f"wrote {len(merged)} entries to {DURATIONS_FILE} ({coverage:.0%} fresh)") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/benchmarks/components/api/bench_list_entities.cpp b/tests/benchmarks/components/api/bench_list_entities.cpp index 02cef50d70..4c445c2bb6 100644 --- a/tests/benchmarks/components/api/bench_list_entities.cpp +++ b/tests/benchmarks/components/api/bench_list_entities.cpp @@ -49,7 +49,7 @@ static void Encode_ListEntitiesSensorResponse(benchmark::State &state) { auto msg = make_sensor_response(); APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -69,7 +69,7 @@ static void CalcAndEncode_ListEntitiesSensorResponse(benchmark::State &state) { for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } @@ -117,7 +117,7 @@ static void Encode_ListEntitiesBinarySensorResponse(benchmark::State &state) { auto msg = make_binary_sensor_response(); APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -137,7 +137,7 @@ static void CalcAndEncode_ListEntitiesBinarySensorResponse(benchmark::State &sta for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } @@ -202,7 +202,7 @@ static void Encode_ListEntitiesLightResponse(benchmark::State &state) { auto msg = make_light_response(); APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -222,7 +222,7 @@ static void CalcAndEncode_ListEntitiesLightResponse(benchmark::State &state) { for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } diff --git a/tests/benchmarks/components/api/bench_log_response.cpp b/tests/benchmarks/components/api/bench_log_response.cpp index 4ef57987be..f9060af65c 100644 --- a/tests/benchmarks/components/api/bench_log_response.cpp +++ b/tests/benchmarks/components/api/bench_log_response.cpp @@ -23,7 +23,7 @@ static void Encode_LogResponse_Typical(benchmark::State &state) { msg.level = enums::LOG_LEVEL_DEBUG; msg.set_message(reinterpret_cast(kTypicalLogLine), strlen(kTypicalLogLine)); uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -42,7 +42,7 @@ static void Encode_LogResponse_Short(benchmark::State &state) { msg.level = enums::LOG_LEVEL_INFO; msg.set_message(reinterpret_cast(kShortLogLine), strlen(kShortLogLine)); uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -84,7 +84,7 @@ static void CalcAndEncode_LogResponse_Typical(benchmark::State &state) { for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } @@ -105,7 +105,7 @@ static void CalcAndEncode_LogResponse_Typical_Fresh(benchmark::State &state) { for (int i = 0; i < kInnerIterations; i++) { APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); benchmark::DoNotOptimize(buffer.data()); diff --git a/tests/benchmarks/components/api/bench_plaintext_frame.cpp b/tests/benchmarks/components/api/bench_plaintext_frame.cpp index 74c640a093..07b479290c 100644 --- a/tests/benchmarks/components/api/bench_plaintext_frame.cpp +++ b/tests/benchmarks/components/api/bench_plaintext_frame.cpp @@ -33,7 +33,7 @@ static void PlaintextFrame_WriteSensorState(benchmark::State &state) { // Pre-init buffer to typical TCP MSS size to avoid benchmarking // heap allocation — in real use the buffer is reused across writes. APIBuffer buffer; - buffer.reserve(1460); + (void) buffer.reserve(1460); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -44,7 +44,7 @@ static void PlaintextFrame_WriteSensorState(benchmark::State &state) { msg.missing_state = false; uint32_t size = msg.calculate_size(); - buffer.resize(padding + size); + (void) buffer.resize(padding + size); ProtoWriteBuffer writer(&buffer, padding); msg.encode(writer); @@ -70,7 +70,7 @@ static void PlaintextFrame_WriteBatch5(benchmark::State &state) { // Pre-init buffer to typical TCP MSS size to avoid benchmarking // heap allocation — in real use the buffer is reused across writes. APIBuffer buffer; - buffer.reserve(1460); + (void) buffer.reserve(1460); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -85,7 +85,7 @@ static void PlaintextFrame_WriteBatch5(benchmark::State &state) { msg.missing_state = false; uint32_t size = msg.calculate_size(); - buffer.resize(offset + padding + size + footer); + (void) buffer.resize(offset + padding + size + footer); ProtoWriteBuffer writer(&buffer, offset + padding); msg.encode(writer); diff --git a/tests/benchmarks/components/api/bench_proto_decode.cpp b/tests/benchmarks/components/api/bench_proto_decode.cpp index 961c629f2a..0268e98035 100644 --- a/tests/benchmarks/components/api/bench_proto_decode.cpp +++ b/tests/benchmarks/components/api/bench_proto_decode.cpp @@ -16,7 +16,7 @@ static constexpr int kInnerIterations = 2000; template static APIBuffer encode_message(const T &msg) { APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); return buffer; diff --git a/tests/benchmarks/components/api/bench_proto_encode.cpp b/tests/benchmarks/components/api/bench_proto_encode.cpp index 1e2efcd281..e1383e8990 100644 --- a/tests/benchmarks/components/api/bench_proto_encode.cpp +++ b/tests/benchmarks/components/api/bench_proto_encode.cpp @@ -19,7 +19,7 @@ static void Encode_SensorStateResponse(benchmark::State &state) { msg.state = 23.5f; msg.missing_state = false; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -60,7 +60,7 @@ static void CalcAndEncode_SensorStateResponse(benchmark::State &state) { for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } @@ -84,7 +84,7 @@ static void CalcAndEncode_SensorStateResponse_Fresh(benchmark::State &state) { for (int i = 0; i < kInnerIterations; i++) { APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); benchmark::DoNotOptimize(buffer.data()); @@ -103,7 +103,7 @@ static void Encode_BinarySensorStateResponse(benchmark::State &state) { msg.state = true; msg.missing_state = false; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -126,7 +126,7 @@ static void Encode_HelloResponse(benchmark::State &state) { msg.server_info = StringRef::from_lit("esphome v2026.3.0"); msg.name = StringRef::from_lit("living-room-sensor"); uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -158,7 +158,7 @@ static void Encode_LightStateResponse(benchmark::State &state) { msg.warm_white = 0.0f; msg.effect = StringRef::from_lit("rainbow"); uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -243,7 +243,7 @@ static void Encode_DeviceInfoResponse(benchmark::State &state) { auto msg = make_device_info_response(); APIBuffer buffer; uint32_t total_size = msg.calculate_size(); - buffer.resize(total_size); + (void) buffer.resize(total_size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -264,7 +264,7 @@ static void CalcAndEncode_DeviceInfoResponse(benchmark::State &state) { for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } @@ -285,7 +285,7 @@ static void CalcAndEncode_DeviceInfoResponse_Fresh(benchmark::State &state) { for (int i = 0; i < kInnerIterations; i++) { APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); benchmark::DoNotOptimize(buffer.data()); @@ -335,7 +335,7 @@ static void Encode_BLERawAdvs12(benchmark::State &state) { auto msg = make_ble_raw_advs_12(); APIBuffer buffer; uint32_t total_size = msg.calculate_size(); - buffer.resize(total_size); + (void) buffer.resize(total_size); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -355,7 +355,7 @@ static void CalcAndEncode_BLERawAdvs12(benchmark::State &state) { for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); } @@ -372,7 +372,7 @@ static void CalcAndEncode_BLERawAdvs12_Fresh(benchmark::State &state) { for (int i = 0; i < kInnerIterations; i++) { APIBuffer buffer; uint32_t size = msg.calculate_size(); - buffer.resize(size); + (void) buffer.resize(size); ProtoWriteBuffer writer(&buffer, 0); msg.encode(writer); benchmark::DoNotOptimize(buffer.data()); diff --git a/tests/benchmarks/components/api/bench_proto_proxy.cpp b/tests/benchmarks/components/api/bench_proto_proxy.cpp index fa3191a969..05bbcc73dd 100644 --- a/tests/benchmarks/components/api/bench_proto_proxy.cpp +++ b/tests/benchmarks/components/api/bench_proto_proxy.cpp @@ -16,7 +16,7 @@ static constexpr int kInnerIterations = 2000; // Encodes `src` into `out`. Caller owns `out` and must keep it alive across // the decode loop (decoded messages may store pointers back into its bytes). template static void encode_into(APIBuffer &out, const T &src) { - out.resize(src.calculate_size()); + (void) out.resize(src.calculate_size()); ProtoWriteBuffer writer(&out, 0); src.encode(writer); } @@ -33,7 +33,7 @@ static void Encode_ZWaveProxyFrame(benchmark::State &state) { msg.data = kZWaveFrameData; msg.data_len = sizeof(kZWaveFrameData); APIBuffer buffer; - buffer.resize(msg.calculate_size()); + (void) buffer.resize(msg.calculate_size()); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -111,7 +111,7 @@ static void Encode_SerialProxyDataReceived(benchmark::State &state) { msg.instance = 0; msg.set_data(kSerialPayload, kSerialPayloadSize); APIBuffer buffer; - buffer.resize(msg.calculate_size()); + (void) buffer.resize(msg.calculate_size()); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -171,7 +171,7 @@ static void Encode_InfraredRFReceiveEvent(benchmark::State &state) { msg.key = 0xDEADBEEF; msg.timings = &get_ir_timings_100(); APIBuffer buffer; - buffer.resize(msg.calculate_size()); + (void) buffer.resize(msg.calculate_size()); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -254,7 +254,7 @@ static APIBuffer build_infrared_rf_transmit_wire() { put_varint(1); APIBuffer buf; - buf.resize(len); + (void) buf.resize(len); std::memcpy(buf.data(), bytes, len); return buf; } diff --git a/tests/benchmarks/components/api/bench_proto_varint.cpp b/tests/benchmarks/components/api/bench_proto_varint.cpp index 0b5ccc2b7d..ea7fd99aa5 100644 --- a/tests/benchmarks/components/api/bench_proto_varint.cpp +++ b/tests/benchmarks/components/api/bench_proto_varint.cpp @@ -58,7 +58,7 @@ BENCHMARK(ProtoVarInt_Parse_FiveByte); static void Encode_Varint_Small(benchmark::State &state) { APIBuffer buffer; - buffer.resize(16); + (void) buffer.resize(16); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -73,7 +73,7 @@ BENCHMARK(Encode_Varint_Small); static void Encode_Varint_Large(benchmark::State &state) { APIBuffer buffer; - buffer.resize(16); + (void) buffer.resize(16); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { @@ -88,7 +88,7 @@ BENCHMARK(Encode_Varint_Large); static void Encode_Varint_MaxUint32(benchmark::State &state) { APIBuffer buffer; - buffer.resize(16); + (void) buffer.resize(16); for (auto _ : state) { for (int i = 0; i < kInnerIterations; i++) { diff --git a/tests/benchmarks/core/bench_helpers.cpp b/tests/benchmarks/core/bench_helpers.cpp index 1ce9101ff6..4a1f3c5bcc 100644 --- a/tests/benchmarks/core/bench_helpers.cpp +++ b/tests/benchmarks/core/bench_helpers.cpp @@ -363,4 +363,47 @@ static void Snprintf_Uint32_Large(benchmark::State &state) { } BENCHMARK(Snprintf_Uint32_Large); +// --- step_to_accuracy_decimals() --- +// Called from climate traits and web_server for every number/climate step. + +static void StepToAccuracyDecimals_Tenth(benchmark::State &state) { + for (auto _ : state) { + int result = 0; + for (int i = 0; i < kInnerIterations; i++) { + result += step_to_accuracy_decimals(0.1f); + } + benchmark::DoNotOptimize(result); + } + state.SetItemsProcessed(state.iterations() * kInnerIterations); +} +BENCHMARK(StepToAccuracyDecimals_Tenth); + +static void StepToAccuracyDecimals_Whole(benchmark::State &state) { + for (auto _ : state) { + int result = 0; + for (int i = 0; i < kInnerIterations; i++) { + result += step_to_accuracy_decimals(1.0f); + } + benchmark::DoNotOptimize(result); + } + state.SetItemsProcessed(state.iterations() * kInnerIterations); +} +BENCHMARK(StepToAccuracyDecimals_Whole); + +static void StepToAccuracyDecimals_Mixed(benchmark::State &state) { + static constexpr float steps[] = { + 0.001f, 0.01f, 0.05f, 0.1f, 0.25f, 0.5f, 1.0f, 2.5f, 5.0f, 10.0f, + }; + static constexpr int num_steps = sizeof(steps) / sizeof(steps[0]); + for (auto _ : state) { + int result = 0; + for (int i = 0; i < kInnerIterations; i++) { + result += step_to_accuracy_decimals(steps[i % num_steps]); + } + benchmark::DoNotOptimize(result); + } + state.SetItemsProcessed(state.iterations() * kInnerIterations); +} +BENCHMARK(StepToAccuracyDecimals_Mixed); + } // namespace esphome::benchmarks diff --git a/tests/component_tests/api/test_action_metadata.py b/tests/component_tests/api/test_action_metadata.py new file mode 100644 index 0000000000..adbfdf306e --- /dev/null +++ b/tests/component_tests/api/test_action_metadata.py @@ -0,0 +1,155 @@ +"""Tests for user-defined action field metadata (description / example).""" + +from collections.abc import Callable +from pathlib import Path + +import pytest + +from esphome.components.api import ( + _action_strings, + _action_strings_size, + _has_action_metadata, + _validate_esp8266_action_strings, + validate_variable, +) +from esphome.config_validation import Invalid +from esphome.const import PlatformFramework +from esphome.core import CORE +from esphome.cpp_generator import safe_exp +from esphome.helpers import fnv1_hash +from tests.component_tests.helpers import get_define_value +from tests.component_tests.types import SetCoreConfigCallable + +CONFIG = "tests/component_tests/api/test_action_metadata.yaml" +CONFIG_ESP8266 = "tests/component_tests/api/test_action_metadata_esp8266.yaml" +CONFIG_SHORTHAND = "tests/component_tests/api/test_action_metadata_shorthand.yaml" + + +def test_metadata_is_emitted_as_progmem_table( + generate_main: Callable[[str | Path], str], +) -> None: + """Every action string is a PROGMEM array referenced from one PROGMEM table.""" + main_cpp = generate_main(CONFIG) + + assert ( + 'static constexpr char api_action_str0[] PROGMEM = "play_buzzer";' in main_cpp + ) + assert ( + 'static constexpr char api_action_str1[] PROGMEM = "Play an RTTTL melody on the buzzer";' + in main_cpp + ) + assert ( + 'static constexpr char api_action_str4[] PROGMEM = "two_short:d=4,o=5,b=100:16e6,16e6";' + in main_cpp + ) + assert ( + "static constexpr const char * api_action0_strings[] PROGMEM = {" + "api_action_str0, api_action_str1, api_action_str2, api_action_str3, " + "api_action_str4, api_action_str5, nullptr, nullptr};" in main_cpp + ) + # An action without metadata still carries the metadata slots (as nullptr) + assert ( + "static constexpr const char * api_action1_strings[] PROGMEM = {" + "api_action_str6, nullptr, api_action_str7, nullptr, nullptr};" in main_cpp + ) + assert f"(api_action0_strings, {safe_exp(fnv1_hash('play_buzzer'))});" in main_cpp + assert "USE_API_USER_DEFINED_ACTION_METADATA" in {d.name for d in CORE.defines} + assert get_define_value("API_USER_ACTION_STRINGS_SCRATCH_SIZE") is None + + +def test_esp8266_sizes_scratch_buffer_for_largest_action( + generate_main: Callable[[str | Path], str], +) -> None: + """ESP8266 gets a scratch buffer define equal to the byte total of the largest action.""" + generate_main(CONFIG_ESP8266) + + # play_buzzer: name, description, two variable names, one description, one example, + # each with a terminator + assert get_define_value("API_USER_ACTION_STRINGS_SCRATCH_SIZE") == "117" + + +def test_shorthand_variables_emit_no_metadata( + generate_main: Callable[[str | Path], str], +) -> None: + """The name: type shorthand emits a name-only table and no define.""" + main_cpp = generate_main(CONFIG_SHORTHAND) + + assert ( + "static constexpr const char * api_action0_strings[] PROGMEM = " + "{api_action_str0, api_action_str1};" in main_cpp + ) + assert "USE_API_USER_DEFINED_ACTION_METADATA" not in {d.name for d in CORE.defines} + + +def test_variable_shorthand_normalizes_to_mapping() -> None: + """A bare type string validates to the mapping form.""" + assert validate_variable("string") == {"type": "string"} + + +@pytest.mark.parametrize( + "value", + [ + {"description": "no type given"}, + {"type": "string", "selector": "text"}, + "stringy", + {"type": "stringy"}, + ], +) +def test_variable_rejects_invalid(value: object) -> None: + """Missing or unknown type and unknown keys raise in both forms.""" + with pytest.raises(Invalid): + validate_variable(value) + + +def _oversized_action_config() -> dict: + return { + "actions": [ + { + "action": "big", + "description": "x" * 300, + "variables": {"a": {"type": "string", "example": "y" * 300}}, + } + ] + } + + +def test_esp8266_rejects_actions_over_string_budget( + set_core_config: SetCoreConfigCallable, +) -> None: + set_core_config(PlatformFramework.ESP8266_ARDUINO) + with pytest.raises(Invalid, match="ESP8266 allows at most 384 bytes"): + _validate_esp8266_action_strings(_oversized_action_config()) + + +def test_other_platforms_have_no_string_budget( + set_core_config: SetCoreConfigCallable, +) -> None: + set_core_config(PlatformFramework.ESP32_IDF) + config = _oversized_action_config() + assert _validate_esp8266_action_strings(config) is config + + +def test_empty_metadata_is_unset_and_not_counted() -> None: + """An empty description or example emits nullptr and takes no scratch space.""" + conf = { + "action": "a", + "description": "", + "variables": {"b": {"type": "int", "description": "", "example": "ex"}}, + } + strings = _action_strings(conf, has_metadata=True) + assert strings == ["a", None, "b", None, "ex"] + # Every emitted string counts its terminator: "a" + "b" + "ex" + assert _action_strings_size(strings) == 2 + 2 + 3 + + +def test_empty_metadata_does_not_enable_the_define() -> None: + actions = [ + { + "action": "a", + "description": "", + "variables": {"b": {"type": "int", "example": ""}}, + } + ] + assert not _has_action_metadata(actions) + actions[0]["variables"]["b"]["example"] = "1" + assert _has_action_metadata(actions) diff --git a/tests/component_tests/api/test_action_metadata.yaml b/tests/component_tests/api/test_action_metadata.yaml new file mode 100644 index 0000000000..c998713874 --- /dev/null +++ b/tests/component_tests/api/test_action_metadata.yaml @@ -0,0 +1,14 @@ +esphome: + name: test + +esp32: + board: esp32dev + +wifi: + ssid: MySSID + password: password1 + +logger: + +packages: + api: !include test_action_metadata_common.yaml diff --git a/tests/component_tests/api/test_action_metadata_common.yaml b/tests/component_tests/api/test_action_metadata_common.yaml new file mode 100644 index 0000000000..bd161efe63 --- /dev/null +++ b/tests/component_tests/api/test_action_metadata_common.yaml @@ -0,0 +1,18 @@ +api: + actions: + - action: play_buzzer + description: Play an RTTTL melody on the buzzer + variables: + song_str: + type: string + description: RTTTL melody string + example: "two_short:d=4,o=5,b=100:16e6,16e6" + volume: + type: int + then: + - logger.log: Action Called + - action: plain_action + variables: + value: int + then: + - logger.log: Action Called diff --git a/tests/component_tests/api/test_action_metadata_esp8266.yaml b/tests/component_tests/api/test_action_metadata_esp8266.yaml new file mode 100644 index 0000000000..94a5839b28 --- /dev/null +++ b/tests/component_tests/api/test_action_metadata_esp8266.yaml @@ -0,0 +1,14 @@ +esphome: + name: test + +esp8266: + board: d1_mini + +wifi: + ssid: MySSID + password: password1 + +logger: + +packages: + api: !include test_action_metadata_common.yaml diff --git a/tests/component_tests/api/test_action_metadata_shorthand.yaml b/tests/component_tests/api/test_action_metadata_shorthand.yaml new file mode 100644 index 0000000000..aa2e1ab424 --- /dev/null +++ b/tests/component_tests/api/test_action_metadata_shorthand.yaml @@ -0,0 +1,19 @@ +esphome: + name: test + +esp32: + board: esp32dev + +wifi: + ssid: MySSID + password: password1 + +logger: + +api: + actions: + - action: plain_action + variables: + value: int + then: + - logger.log: Action Called diff --git a/tests/component_tests/api/test_homeassistant_action.py b/tests/component_tests/api/test_homeassistant_action.py index 611353e7c5..6ee5ac3412 100644 --- a/tests/component_tests/api/test_homeassistant_action.py +++ b/tests/component_tests/api/test_homeassistant_action.py @@ -9,7 +9,7 @@ def test_synchronous_chain_keeps_zero_copy_args(generate_main): assert ( "api::UserServiceTrigger" - '("zero_copy_args", {"message"})' in main_cpp + "(api_action0_strings," in main_cpp ) @@ -22,7 +22,7 @@ def test_response_callback_args_are_owning(generate_main): assert ( "api::UserServiceTrigger" - '("response_args", {"message"})' in main_cpp + "(api_action1_strings," in main_cpp ) assert "api::HomeAssistantServiceCallAction" in main_cpp assert "api::HomeAssistantServiceCallAction" not in main_cpp diff --git a/tests/component_tests/epaper_spi/config/uc8179_e1001_test.yaml b/tests/component_tests/epaper_spi/config/uc8179_e1001_test.yaml new file mode 100644 index 0000000000..73f956c8ee --- /dev/null +++ b/tests/component_tests/epaper_spi/config/uc8179_e1001_test.yaml @@ -0,0 +1,15 @@ +esphome: + name: test + +esp32: + board: esp32-s3-devkitc-1 + variant: esp32s3 + +spi: + clk_pin: GPIO7 + mosi_pin: GPIO9 + +display: + - platform: epaper_spi + id: epaper_display + model: seeed-reterminal-e1001 diff --git a/tests/component_tests/epaper_spi/test_init.py b/tests/component_tests/epaper_spi/test_init.py index 7a0507542e..5e2e7d6013 100644 --- a/tests/component_tests/epaper_spi/test_init.py +++ b/tests/component_tests/epaper_spi/test_init.py @@ -439,6 +439,23 @@ def test_enable_pin_multiple( assert all(pin["mode"]["output"] is True for pin in enable_pins) +def test_uc8179_e1001_code_generation( + generate_main: Callable[[str | Path], str], + component_config_path: Callable[[str], Path], +) -> None: + """Test that the reTerminal E1001 model generates the UC8179 driver and init sequence.""" + main_cpp = generate_main(component_config_path("uc8179_e1001_test.yaml")) + + # The model must instantiate the UC8179 driver class with the panel dimensions + assert "epaper_spi::EPaperUC8179" in main_cpp + assert re.search(r'"SEEED-RETERMINAL-E1001",\s*800,\s*480', main_cpp) + + # The generated init sequence must contain the UC8179 resolution setting + # for 800x480: command 0x61, 4 data bytes 0x03 0x20 0x01 0xE0 + # (rendered as decimal in the generated array) + assert "97, 4, 3, 32, 1, 224" in main_cpp + + def test_enable_pin_code_generation( generate_main: Callable[[str | Path], str], component_config_path: Callable[[str], Path], diff --git a/tests/component_tests/esp32/config/exclusion_reincludes_espnow.yaml b/tests/component_tests/esp32/config/exclusion_reincludes_espnow.yaml new file mode 100644 index 0000000000..2ede6c42df --- /dev/null +++ b/tests/component_tests/esp32/config/exclusion_reincludes_espnow.yaml @@ -0,0 +1,11 @@ +esphome: + name: test + +esp32: + board: esp32dev + framework: + type: esp-idf + +espnow: + channel: 1 + auto_add_peer: true diff --git a/tests/component_tests/esp32/config/exclusion_reincludes_internal_temperature.yaml b/tests/component_tests/esp32/config/exclusion_reincludes_internal_temperature.yaml new file mode 100644 index 0000000000..d5a0aaf157 --- /dev/null +++ b/tests/component_tests/esp32/config/exclusion_reincludes_internal_temperature.yaml @@ -0,0 +1,11 @@ +esphome: + name: test + +esp32: + board: esp32dev + framework: + type: esp-idf + +sensor: + - platform: internal_temperature + name: Internal Temperature diff --git a/tests/component_tests/esp32/config/exclusion_reincludes_wifi_ble.yaml b/tests/component_tests/esp32/config/exclusion_reincludes_wifi_ble.yaml new file mode 100644 index 0000000000..883abdb5fa --- /dev/null +++ b/tests/component_tests/esp32/config/exclusion_reincludes_wifi_ble.yaml @@ -0,0 +1,13 @@ +esphome: + name: test + +esp32: + board: esp32dev + framework: + type: esp-idf + +wifi: + ssid: MySSID + password: password1 + +esp32_ble_tracker: diff --git a/tests/component_tests/esp32/config/exclusion_stays_internal_temperature_s3.yaml b/tests/component_tests/esp32/config/exclusion_stays_internal_temperature_s3.yaml new file mode 100644 index 0000000000..6d4dbf90b5 --- /dev/null +++ b/tests/component_tests/esp32/config/exclusion_stays_internal_temperature_s3.yaml @@ -0,0 +1,11 @@ +esphome: + name: test + +esp32: + board: esp32-s3-devkitc-1 + framework: + type: esp-idf + +sensor: + - platform: internal_temperature + name: Internal Temperature diff --git a/tests/component_tests/esp32/config/execute_from_psram_s31.yaml b/tests/component_tests/esp32/config/execute_from_psram_s31.yaml new file mode 100644 index 0000000000..493c9f989e --- /dev/null +++ b/tests/component_tests/esp32/config/execute_from_psram_s31.yaml @@ -0,0 +1,13 @@ +esphome: + name: test + +esp32: + variant: esp32s31 + board: esp32-s31-devkitc + framework: + type: esp-idf + advanced: + execute_from_psram: true + +psram: + mode: octal diff --git a/tests/component_tests/esp32/config/network_ethernet_only.yaml b/tests/component_tests/esp32/config/network_ethernet_only.yaml index 73d11e0a13..4f357e40e6 100644 --- a/tests/component_tests/esp32/config/network_ethernet_only.yaml +++ b/tests/component_tests/esp32/config/network_ethernet_only.yaml @@ -6,6 +6,8 @@ esp32: framework: type: esp-idf +mdns: + ethernet: type: W5500 clk_pin: 19 diff --git a/tests/component_tests/esp32/config/network_wifi_only.yaml b/tests/component_tests/esp32/config/network_wifi_only.yaml index 61dfde3e03..3abc17e324 100644 --- a/tests/component_tests/esp32/config/network_wifi_only.yaml +++ b/tests/component_tests/esp32/config/network_wifi_only.yaml @@ -6,6 +6,8 @@ esp32: framework: type: esp-idf +mdns: + wifi: ssid: "test_ssid" password: "test_password" diff --git a/tests/component_tests/esp32/test_esp32.py b/tests/component_tests/esp32/test_esp32.py index 297844b4e6..759020c732 100644 --- a/tests/component_tests/esp32/test_esp32.py +++ b/tests/component_tests/esp32/test_esp32.py @@ -24,6 +24,7 @@ from esphome.components.esp32 import ( ) from esphome.components.esp32.const import ( KEY_ESP32, + KEY_EXCLUDE_COMPONENTS, KEY_NETWORK_SDKCONFIG, KEY_SDKCONFIG_OPTIONS, KEY_VARIANT, @@ -202,6 +203,18 @@ def test_esp32_rejects_unsupported_cli_toolchain( r"'execute_from_psram' requires PSRAM to be configured @ data\['framework'\]\['advanced'\]\['execute_from_psram'\]", id="execute_from_psram_requires_psram_p4_config", ), + pytest.param( + { + "variant": "esp32s31", + "board": "esp32-s31-devkitc", + "framework": { + "type": "esp-idf", + "advanced": {"execute_from_psram": True}, + }, + }, + r"'execute_from_psram' requires PSRAM to be configured @ data\['framework'\]\['advanced'\]\['execute_from_psram'\]", + id="execute_from_psram_requires_psram_s31_config", + ), pytest.param( { "variant": "esp32s3", @@ -298,6 +311,26 @@ def test_esp32_configuration_errors( ("esp-tls", "esp_http_client"), id="nextion", ), + pytest.param( + # esp_wifi/wpa_supplicant from request_wifi(), bt from + # request_bluetooth(), esp_coex from esp32_ble_tracker's software + # coexistence (defaults on with wifi). esp_phy stays excluded; + # IDF requirement expansion pulls it back via esp_wifi. + "exclusion_reincludes_wifi_ble.yaml", + ("esp_wifi", "wpa_supplicant", "bt", "esp_coex"), + id="wifi_ble", + ), + pytest.param( + "exclusion_reincludes_espnow.yaml", + ("esp_wifi",), + id="espnow", + ), + pytest.param( + # temprature_sens_read() on the original ESP32 lives in the esp_phy blob. + "exclusion_reincludes_internal_temperature.yaml", + ("esp_phy",), + id="internal_temperature", + ), ], ) def test_default_exclusions_reincluded_by_owning_components( @@ -309,8 +342,6 @@ def test_default_exclusions_reincluded_by_owning_components( """Components whose IDF driver is excluded by default must re-include it during codegen; a dropped include_builtin_idf_component() call would only surface as a missing-header failure in a full compile job.""" - from esphome.components.esp32.const import KEY_EXCLUDE_COMPONENTS - generate_main(component_config_path(config_file)) excluded = CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] @@ -324,13 +355,20 @@ def test_default_exclusions_reincluded_by_owning_components( assert ("esp_http_server" in excluded) == ("esp_http_server" not in reincluded) +def test_esp_phy_stays_excluded_for_internal_temperature_on_newer_variants( + generate_main: Callable[[str | Path], str], + component_config_path: Callable[[str], Path], +) -> None: + """Only the original ESP32 reads the PHY blob; other variants use esp_driver_tsens.""" + generate_main(component_config_path("exclusion_stays_internal_temperature_s3.yaml")) + assert "esp_phy" in CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] + + def test_nvs_sec_provider_stays_excluded_when_encryption_is_off( generate_main: Callable[[str | Path], str], component_config_path: Callable[[str], Path], ) -> None: """An explicit CONFIG_NVS_ENCRYPTION=n keeps nvs_sec_provider excluded.""" - from esphome.components.esp32.const import KEY_EXCLUDE_COMPONENTS - generate_main(component_config_path("exclusion_stays_nvs_sdkconfig_off.yaml")) assert "nvs_sec_provider" in CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] @@ -396,12 +434,12 @@ def test_execute_from_psram_s3_sdkconfig( generate_main: Callable[[str | Path], str], component_config_path: Callable[[str], Path], ) -> None: - """Test that execute_from_psram on ESP32-S3 sets the correct sdkconfig options.""" + """Test that execute_from_psram on ESP32-S3 sets the correct sdkconfig option.""" generate_main(component_config_path("execute_from_psram_s3.yaml")) sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] - assert sdkconfig.get("CONFIG_SPIRAM_FETCH_INSTRUCTIONS") is True - assert sdkconfig.get("CONFIG_SPIRAM_RODATA") is True - assert "CONFIG_SPIRAM_XIP_FROM_PSRAM" not in sdkconfig + assert sdkconfig.get("CONFIG_SPIRAM_XIP_FROM_PSRAM") is True + assert "CONFIG_SPIRAM_FETCH_INSTRUCTIONS" not in sdkconfig + assert "CONFIG_SPIRAM_RODATA" not in sdkconfig def test_execute_from_psram_p4_sdkconfig( @@ -416,6 +454,18 @@ def test_execute_from_psram_p4_sdkconfig( assert "CONFIG_SPIRAM_RODATA" not in sdkconfig +def test_execute_from_psram_s31_sdkconfig( + generate_main: Callable[[str | Path], str], + component_config_path: Callable[[str], Path], +) -> None: + """Test that execute_from_psram on ESP32-S31 sets the correct sdkconfig option.""" + generate_main(component_config_path("execute_from_psram_s31.yaml")) + sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] + assert sdkconfig.get("CONFIG_SPIRAM_XIP_FROM_PSRAM") is True + assert "CONFIG_SPIRAM_FETCH_INSTRUCTIONS" not in sdkconfig + assert "CONFIG_SPIRAM_RODATA" not in sdkconfig + + def test_nvs_encryption_sdkconfig( generate_main: Callable[[str | Path], str], component_config_path: Callable[[str], Path], @@ -939,6 +989,14 @@ def test_network_wifi_only_reconciles_end_to_end( sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] assert sdkconfig.get("CONFIG_ESP_WIFI_SOFTAP_SUPPORT") is False assert sdkconfig.get("CONFIG_LWIP_DHCPS") is False + # request_wifi() also puts the WiFi components back in the build set; + # esp_phy stays excluded, IDF requirement expansion pulls it back. + excluded = CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] + assert "esp_wifi" not in excluded + assert "wpa_supplicant" not in excluded + assert "esp_phy" in excluded + # With wifi present mdns keeps its predefined interfaces. + assert "CONFIG_MDNS_PREDEF_NETIF_STA" not in sdkconfig # WiFi stack stays enabled (no ethernet) and no Bluetooth requested. assert "CONFIG_ESP_WIFI_ENABLED" not in sdkconfig assert "CONFIG_BT_ENABLED" not in sdkconfig @@ -954,6 +1012,12 @@ def test_network_ethernet_only_reconciles_end_to_end( sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS] assert sdkconfig.get("CONFIG_ESP_WIFI_ENABLED") is False assert sdkconfig.get("CONFIG_SW_COEXIST_ENABLE") is False + # The whole radio stack stays out of the build set as well. + excluded = CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] + assert {"esp_wifi", "wpa_supplicant", "esp_phy", "esp_coex", "bt"} <= excluded + # Without wifi, mdns drops its predefined STA/AP interfaces. + assert sdkconfig.get("CONFIG_MDNS_PREDEF_NETIF_STA") is False + assert sdkconfig.get("CONFIG_MDNS_PREDEF_NETIF_AP") is False def test_network_wifi_ble_coexistence_reconciles_end_to_end( @@ -1228,3 +1292,50 @@ def test_parse_pio_platform_version(value: str, expected: str) -> None: from esphome.components.esp32 import _parse_pio_platform_version assert _parse_pio_platform_version(value) == expected + + +def test_esp32_s31_gpio_validation( + set_core_config: SetCoreConfigCallable, + caplog: pytest.LogCaptureFixture, +) -> None: + """S31: GPIO26-28/30-32 are reserved for the SPI flash interface, GPIO29 + and GPIO41 do not exist, GPIO33 is a normal pin, and GPIO36 is a + strapping pin.""" + from esphome.components.esp32.const import VARIANT_ESP32S31 + from esphome.components.esp32.gpio import validate_supports + from esphome.const import CONF_INPUT, CONF_MODE, CONF_OPEN_DRAIN, CONF_OUTPUT + + set_core_config( + PlatformFramework.ESP32_IDF, platform_data={KEY_VARIANT: VARIANT_ESP32S31} + ) + + input_mode = {CONF_INPUT: True, CONF_OUTPUT: False, CONF_OPEN_DRAIN: False} + + # Not reserved; a normal GPIO + pin = {CONF_NUMBER: 33, CONF_IGNORE_PIN_VALIDATION_ERROR: False} + assert validate_gpio_pin(pin)[CONF_NUMBER] == 33 + + # Reserved for the SPI flash interface, but can be bypassed with + # ignore_pin_validation_error + for num in (26, 27, 28, 30, 31, 32): + with pytest.raises(cv.Invalid, match=f"GPIO{num} is reserved"): + validate_gpio_pin( + {CONF_NUMBER: num, CONF_IGNORE_PIN_VALIDATION_ERROR: False} + ) + pin = {CONF_NUMBER: num, CONF_IGNORE_PIN_VALIDATION_ERROR: True} + assert validate_gpio_pin(pin)[CONF_NUMBER] == num + + for num in (29, 41): + with pytest.raises(cv.Invalid, match=f"GPIO{num} does not exist"): + validate_gpio_pin( + {CONF_NUMBER: num, CONF_IGNORE_PIN_VALIDATION_ERROR: False} + ) + # Also rejected in validate_supports so ignore_pin_validation_error + # cannot bypass it + with pytest.raises(cv.Invalid, match=f"GPIO{num} does not exist"): + validate_supports({CONF_NUMBER: num, CONF_MODE: input_mode}) + + pin = {CONF_NUMBER: 36, CONF_MODE: input_mode} + with caplog.at_level("WARNING"): + validate_supports(pin) + assert "GPIO36 is a strapping PIN" in caplog.text diff --git a/tests/component_tests/external_components/test_init.py b/tests/component_tests/external_components/test_init.py index d3813ecc75..78cb32af54 100644 --- a/tests/component_tests/external_components/test_init.py +++ b/tests/component_tests/external_components/test_init.py @@ -1,16 +1,21 @@ -"""Tests for the external_components skip-update behavior driven by CORE.skip_external_update.""" +"""Tests for the external_components config pass.""" +import logging from pathlib import Path from typing import Any from unittest.mock import MagicMock +import pytest + from esphome.components.external_components import do_external_components_pass from esphome.const import ( CONF_EXTERNAL_COMPONENTS, + CONF_PATH, CONF_REFRESH, CONF_SOURCE, CONF_URL, TYPE_GIT, + TYPE_LOCAL, ) from esphome.core import CORE, TimePeriodSeconds @@ -69,3 +74,112 @@ def test_external_components_normal_refresh( mock_clone_or_update.assert_called_once() call_args = mock_clone_or_update.call_args assert call_args.kwargs["refresh"] == TimePeriodSeconds(days=1) + + +def test_external_components_logs_built_in_override( + tmp_path: Path, + mock_clone_or_update: MagicMock, + mock_install_meta_finder: MagicMock, + caplog: pytest.LogCaptureFixture, +) -> None: + """A source that provides a component with the same name as a built-in one logs an info message.""" + mock_clone_or_update.return_value = (tmp_path, None) + config = _make_config(tmp_path) + + for name in ("gpio", "some_custom_component"): + component_dir = tmp_path / "components" / name + component_dir.mkdir() + (component_dir / "__init__.py").write_text("# Test component") + + with caplog.at_level(logging.INFO): + do_external_components_pass(config) + + assert ( + "External components are overriding built-in components:\n" + " source: https://github.com/test/components\n" + " components: gpio" in caplog.text + ) + assert "some_custom_component" not in caplog.text + + +def test_external_components_override_log_includes_ref( + tmp_path: Path, + mock_clone_or_update: MagicMock, + mock_install_meta_finder: MagicMock, + caplog: pytest.LogCaptureFixture, +) -> None: + """A git source with a ref logs the ref appended to the url.""" + mock_clone_or_update.return_value = (tmp_path, None) + config = _make_config(tmp_path) + config[CONF_EXTERNAL_COMPONENTS][0][CONF_SOURCE] = "github://test/components@main" + + component_dir = tmp_path / "components" / "gpio" + component_dir.mkdir() + (component_dir / "__init__.py").write_text("# Test component") + + with caplog.at_level(logging.INFO): + do_external_components_pass(config) + + assert " source: https://github.com/test/components.git@main\n" in caplog.text + + +def test_external_components_override_log_includes_git_path( + tmp_path: Path, + mock_clone_or_update: MagicMock, + mock_install_meta_finder: MagicMock, + caplog: pytest.LogCaptureFixture, +) -> None: + """A git source with a subdirectory path logs the path after the url.""" + mock_clone_or_update.return_value = (tmp_path, None) + config = _make_config(tmp_path) + config[CONF_EXTERNAL_COMPONENTS][0][CONF_SOURCE][CONF_PATH] = "components" + + component_dir = tmp_path / "components" / "gpio" + component_dir.mkdir() + (component_dir / "__init__.py").write_text("# Test component") + + with caplog.at_level(logging.INFO): + do_external_components_pass(config) + + assert " source: https://github.com/test/components (components)\n" in caplog.text + + +def test_external_components_override_log_local_source( + tmp_path: Path, + mock_install_meta_finder: MagicMock, + caplog: pytest.LogCaptureFixture, +) -> None: + """A local source logs its resolved path.""" + components_dir = tmp_path / "my_components" + gpio_dir = components_dir / "gpio" + gpio_dir.mkdir(parents=True) + (gpio_dir / "__init__.py").write_text("# Test component") + + CORE.config_path = tmp_path / "dummy.yaml" + config = { + CONF_EXTERNAL_COMPONENTS: [ + {CONF_SOURCE: {"type": TYPE_LOCAL, CONF_PATH: "my_components"}} + ] + } + + with caplog.at_level(logging.INFO): + do_external_components_pass(config) + + assert f" source: {components_dir}\n" in caplog.text + assert " components: gpio" in caplog.text + + +def test_external_components_no_override_no_log( + tmp_path: Path, + mock_clone_or_update: MagicMock, + mock_install_meta_finder: MagicMock, + caplog: pytest.LogCaptureFixture, +) -> None: + """A source that only provides components not shipped with ESPHome logs nothing.""" + mock_clone_or_update.return_value = (tmp_path, None) + config = _make_config(tmp_path) + + with caplog.at_level(logging.INFO): + do_external_components_pass(config) + + assert "are overriding built-in components" not in caplog.text diff --git a/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py b/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py index e85327c0ab..ac8e111ddb 100644 --- a/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py +++ b/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py @@ -10,7 +10,13 @@ from esphome import config_validation as cv # via ch422g) can be validated by the mipi_rgb CONFIG_SCHEMA in this test. import esphome.components.ch422g # noqa: F401 from esphome.components.display import get_display_metadata -from esphome.components.esp32 import KEY_BOARD, VARIANT_ESP32S3 +from esphome.components.esp32 import ( + KEY_BOARD, + VARIANT_ESP32C3, + VARIANT_ESP32P4, + VARIANT_ESP32S3, + VARIANT_ESP32S31, +) import esphome.components.pca9554 # noqa: F401 import esphome.components.xl9535 # noqa: F401 from esphome.const import ( @@ -135,3 +141,63 @@ def test_metadata_records_rotation( config = CONFIG_SCHEMA({**base, "id": "unrotated"}) assert get_display_metadata(config["id"]).rotation == 0 + + +@pytest.mark.parametrize( + ("variant", "board", "model"), + [ + # ESP32-8048S070 is a real Sunton board wired for ESP32-S3 (e.g. its + # default de_pin is GPIO41, which doesn't exist on S31), so it is + # only meaningful as a config on that variant. + (VARIANT_ESP32S3, "esp32-s3-devkitc-1", "ESP32-8048S070"), + # P4 and S31 use the pin-agnostic CUSTOM model so this only checks + # that the chip itself is accepted, independent of board wiring. + (VARIANT_ESP32P4, "esp32-p4-evboard", "CUSTOM"), + # No dedicated board is registered for ESP32-S31 yet; an unknown board + # name simply skips per-board pin validation. + (VARIANT_ESP32S31, "esp32-s31-devkitc", "CUSTOM"), + ], +) +def test_configuration_succeeds_on_supported_variants( + variant: str, board: str, model: str, set_core_config: SetCoreConfigCallable +) -> None: + """mipi_rgb requires a chip with an RGB LCD peripheral: S3, P4 or S31.""" + set_core_config( + PlatformFramework.ESP32_IDF, + platform_data={KEY_BOARD: board, KEY_VARIANT: variant}, + ) + + from esphome.components.mipi_rgb.display import CONFIG_SCHEMA + + config = {"model": model, "data_pins": DATA_PINS, "pclk_pin": 21} + if model == "CUSTOM": + config[CONF_INIT_SEQUENCE] = [[0xA0, 0x01]] + config[CONF_DIMENSIONS] = {CONF_WIDTH: 480, CONF_HEIGHT: 480} + CONFIG_SCHEMA(config) + + +def test_only_on_variant_rejects_unsupported_variant( + set_core_config: SetCoreConfigCallable, +) -> None: + """A variant without the RGB LCD peripheral (e.g. ESP32-C3) is rejected. + + Exercises the exact ``only_on_variant`` call used by ``mipi_rgb.display`` + directly, since building a full model config with GPIO numbers that are + also valid on an unsupported variant like ESP32-C3 is unrelated to what + this checks. + """ + from esphome.components.esp32 import only_on_variant + + set_core_config( + PlatformFramework.ESP32_IDF, + platform_data={KEY_VARIANT: VARIANT_ESP32C3}, + ) + + validator = only_on_variant( + supported=[VARIANT_ESP32S3, VARIANT_ESP32P4, VARIANT_ESP32S31] + ) + with pytest.raises( + cv.Invalid, + match=r"This feature is only available on ESP32S3, ESP32P4, ESP32S31", + ): + validator({}) diff --git a/tests/component_tests/modbus_controller/test_write_offset.py b/tests/component_tests/modbus_controller/test_write_offset.py new file mode 100644 index 0000000000..72bd3a933e --- /dev/null +++ b/tests/component_tests/modbus_controller/test_write_offset.py @@ -0,0 +1,74 @@ +"""Config validation for the byte offset on holding-register write entities. + +A 16-bit register write cannot target half a register, so an odd offset (or byte_offset) is +rejected for holding-register switches and outputs; even offsets and coil offsets pass. +""" + +import pytest +from voluptuous import Invalid, MultipleInvalid + +from esphome.components.modbus_controller.output import ( + CONFIG_SCHEMA as OUTPUT_CONFIG_SCHEMA, +) +from esphome.components.modbus_controller.switch import ( + CONFIG_SCHEMA as SWITCH_CONFIG_SCHEMA, +) +from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_OFFSET + + +def _switch_config(register_type: str, offset: int) -> dict: + return { + CONF_NAME: "test switch", + CONF_ADDRESS: 0x10, + "register_type": register_type, + CONF_OFFSET: offset, + } + + +def _output_config(register_type: str, offset: int) -> dict: + return { + CONF_ID: "test_output", + CONF_ADDRESS: 0x10, + "register_type": register_type, + CONF_OFFSET: offset, + } + + +def test_odd_offset_on_holding_switch_rejected() -> None: + with pytest.raises((Invalid, MultipleInvalid), match="odd"): + SWITCH_CONFIG_SCHEMA(_switch_config("holding", 3)) + + +def test_even_offset_on_holding_switch_accepted() -> None: + config = SWITCH_CONFIG_SCHEMA(_switch_config("holding", 2)) + assert config[CONF_OFFSET] == 2 + + +def test_odd_offset_on_coil_switch_accepted() -> None: + """A coil offset is a coil count, so odd values are fine.""" + config = SWITCH_CONFIG_SCHEMA(_switch_config("coil", 3)) + assert config[CONF_OFFSET] == 3 + + +def test_odd_byte_offset_on_holding_switch_rejected() -> None: + """byte_offset is the alias the validator must also catch.""" + config = _switch_config("holding", 0) + del config[CONF_OFFSET] + config["byte_offset"] = 3 + with pytest.raises((Invalid, MultipleInvalid), match="byte_offset"): + SWITCH_CONFIG_SCHEMA(config) + + +def test_odd_offset_on_holding_output_rejected() -> None: + with pytest.raises((Invalid, MultipleInvalid), match="odd"): + OUTPUT_CONFIG_SCHEMA(_output_config("holding", 3)) + + +def test_even_offset_on_holding_output_accepted() -> None: + config = OUTPUT_CONFIG_SCHEMA(_output_config("holding", 2)) + assert config[CONF_OFFSET] == 2 + + +def test_odd_offset_on_coil_output_accepted() -> None: + config = OUTPUT_CONFIG_SCHEMA(_output_config("coil", 3)) + assert config[CONF_OFFSET] == 3 diff --git a/tests/component_tests/noise/test_encryption_key.py b/tests/component_tests/noise/test_encryption_key.py index 62abae6487..10f1eb3d4c 100644 --- a/tests/component_tests/noise/test_encryption_key.py +++ b/tests/component_tests/noise/test_encryption_key.py @@ -5,7 +5,11 @@ from __future__ import annotations import pytest from esphome import config_validation as cv -from esphome.components.noise import decode_encryption_key, validate_encryption_key +from esphome.components.noise import ( + decode_encryption_key, + is_reserved_key, + validate_encryption_key, +) KEY = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" @@ -35,3 +39,8 @@ def test_decode_encryption_key_rejects_short_decode() -> None: a zero padded PSK on the device.""" with pytest.raises(cv.Invalid, match="32 bytes"): decode_encryption_key("AAECAw==") + + +def test_is_reserved_key() -> None: + assert is_reserved_key("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=") + assert not is_reserved_key(KEY) diff --git a/tests/component_tests/ota/test_esphome_ota.py b/tests/component_tests/ota/test_esphome_ota.py index cdac430ff7..873f162555 100644 --- a/tests/component_tests/ota/test_esphome_ota.py +++ b/tests/component_tests/ota/test_esphome_ota.py @@ -8,17 +8,25 @@ from typing import Any import pytest from esphome import config_validation as cv -from esphome.components.esphome.ota import ota_esphome_final_validate +from esphome.components.esphome.ota import ( + AUTO_LOAD, + FILTER_SOURCE_FILES, + _validate_no_password_with_encryption, + ota_esphome_final_validate, +) from esphome.const import ( + CONF_API, + CONF_ENCRYPTION, CONF_ESPHOME, CONF_ID, + CONF_KEY, CONF_OTA, CONF_PASSWORD, CONF_PLATFORM, CONF_PORT, CONF_VERSION, ) -from esphome.core import ID +from esphome.core import CORE, ID import esphome.final_validate as fv @@ -103,3 +111,305 @@ def test_non_esphome_ota_unaffected() -> None: assert len(updated[CONF_OTA]) == 3 finally: fv.full_config.reset(token) + + +API_KEY = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" +OTHER_KEY = "AQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyA=" +ZEROS_KEY = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=" + + +def test_encryption_key_inherited_from_api() -> None: + """A bare encryption block resolves to the api encryption key.""" + full_conf = { + CONF_API: {CONF_ENCRYPTION: {CONF_KEY: API_KEY}}, + CONF_OTA: [_make_ota_config(port=3232, **{CONF_ENCRYPTION: {}})], + } + token = fv.full_config.set(full_conf) + try: + ota_esphome_final_validate({}) + updated = fv.full_config.get() + assert updated[CONF_OTA][0][CONF_ENCRYPTION][CONF_KEY] == API_KEY + finally: + fv.full_config.reset(token) + + +def test_encryption_explicit_key_matching_api_accepted() -> None: + """An explicit ota key equal to the api key validates.""" + full_conf = { + CONF_API: {CONF_ENCRYPTION: {CONF_KEY: API_KEY}}, + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: API_KEY}}) + ], + } + token = fv.full_config.set(full_conf) + try: + ota_esphome_final_validate({}) + updated = fv.full_config.get() + assert updated[CONF_OTA][0][CONF_ENCRYPTION][CONF_KEY] == API_KEY + finally: + fv.full_config.reset(token) + + +def test_encryption_key_differing_from_api_rejected() -> None: + """There is one key per device; an ota key differing from the api key raises.""" + full_conf = { + CONF_API: {CONF_ENCRYPTION: {CONF_KEY: API_KEY}}, + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}) + ], + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="must match the 'api' encryption key"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) + + +def test_encryption_explicit_key_without_api_encryption_accepted() -> None: + """An explicit ota key with a plaintext api has nothing to match; it stands.""" + full_conf = { + CONF_API: {}, + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}) + ], + } + token = fv.full_config.set(full_conf) + try: + ota_esphome_final_validate({}) + updated = fv.full_config.get() + assert updated[CONF_OTA][0][CONF_ENCRYPTION][CONF_KEY] == OTHER_KEY + finally: + fv.full_config.reset(token) + + +def test_encryption_without_any_key_rejected() -> None: + """A bare encryption block with no api key to inherit raises.""" + full_conf = { + CONF_API: {}, + CONF_OTA: [_make_ota_config(port=3232, **{CONF_ENCRYPTION: {}})], + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="no 'api' encryption key to inherit"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) + + +def test_encryption_explicit_all_zeros_key_rejected() -> None: + """The all-zeros key is the provisioning sentinel; the device would treat + it as no PSK and accept plaintext, so it must fail validation.""" + full_conf = { + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: ZEROS_KEY}}) + ], + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="all-zeros key is reserved"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) + + +def test_encryption_inherited_all_zeros_key_rejected() -> None: + """An all-zeros api key must not silently disable ota encryption either.""" + full_conf = { + CONF_API: {CONF_ENCRYPTION: {CONF_KEY: ZEROS_KEY}}, + CONF_OTA: [_make_ota_config(port=3232, **{CONF_ENCRYPTION: {}})], + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="all-zeros key is reserved"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) + + +def test_encryption_key_mismatch_between_merged_configs_rejected() -> None: + """Same-port configs with different encryption keys raise.""" + full_conf = { + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: API_KEY}}), + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}), + ] + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="encryption is inconsistent"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) + + +@pytest.mark.parametrize("keyed_first", [True, False]) +def test_encryption_bare_and_keyed_blocks_merge(keyed_first: bool) -> None: + """A bare encryption block (package/device split) is compatible with a + keyed one on the same port; the merge resolves to the keyed result.""" + keyed = _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}) + bare = _make_ota_config(port=3232, **{CONF_ENCRYPTION: {}}) + full_conf = { + CONF_OTA: [keyed, bare] if keyed_first else [bare, keyed], + } + token = fv.full_config.set(full_conf) + try: + ota_esphome_final_validate({}) + updated = fv.full_config.get() + assert len(updated[CONF_OTA]) == 1 + assert updated[CONF_OTA][0][CONF_ENCRYPTION][CONF_KEY] == OTHER_KEY + finally: + fv.full_config.reset(token) + + +def test_encryption_runtime_provisioned_api_key_not_inheritable() -> None: + """A keyless api encryption block provisions its key at runtime; a bare + ota encryption block cannot inherit it and the message says so.""" + full_conf = { + CONF_API: {CONF_ENCRYPTION: {}}, + CONF_OTA: [_make_ota_config(port=3232, **{CONF_ENCRYPTION: {}})], + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="provisioned at runtime"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) + + +def test_encryption_explicit_key_with_runtime_provisioned_api_accepted() -> None: + """The documented remedy for a runtime-provisioned api key: set an + explicit ota key.""" + full_conf = { + CONF_API: {CONF_ENCRYPTION: {}}, + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}) + ], + } + token = fv.full_config.set(full_conf) + try: + ota_esphome_final_validate({}) + updated = fv.full_config.get() + assert updated[CONF_OTA][0][CONF_ENCRYPTION][CONF_KEY] == OTHER_KEY + finally: + fv.full_config.reset(token) + + +def test_encryption_with_web_server_ota_warns( + caplog: pytest.LogCaptureFixture, +) -> None: + """With the web_server component the plaintext /update endpoint is always + on; the combination validates with a warning.""" + full_conf = { + "web_server": {}, + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}), + {CONF_PLATFORM: "web_server", CONF_ID: ID("ota_ws", is_manual=False)}, + ], + } + token = fv.full_config.set(full_conf) + try: + with caplog.at_level(logging.WARNING): + ota_esphome_final_validate({}) + assert any("plaintext /update" in record.message for record in caplog.records) + finally: + fv.full_config.reset(token) + + +def test_encryption_with_captive_portal_web_server_ota_warns( + caplog: pytest.LogCaptureFixture, +) -> None: + """captive_portal auto-loads the web_server ota platform without the + web_server component; encryption stays usable and only warns, so the + fallback AP recovery path is not lost.""" + full_conf = { + "captive_portal": {}, + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}), + {CONF_PLATFORM: "web_server", CONF_ID: ID("ota_ws", is_manual=False)}, + ], + } + token = fv.full_config.set(full_conf) + try: + with caplog.at_level(logging.WARNING): + ota_esphome_final_validate({}) + assert any("captive_portal" in record.message for record in caplog.records) + esphome_conf = next( + conf + for conf in fv.full_config.get()[CONF_OTA] + if conf.get(CONF_PLATFORM) == CONF_ESPHOME + ) + assert esphome_conf[CONF_ENCRYPTION][CONF_KEY] == OTHER_KEY + finally: + fv.full_config.reset(token) + + +def test_web_server_ota_without_encryption_unaffected() -> None: + """web_server ota stays valid alongside an unencrypted esphome entry.""" + full_conf = { + CONF_OTA: [ + _make_ota_config(port=3232), + {CONF_PLATFORM: "web_server", CONF_ID: ID("ota_ws", is_manual=False)}, + ], + } + token = fv.full_config.set(full_conf) + try: + ota_esphome_final_validate({}) + assert len(fv.full_config.get()[CONF_OTA]) == 2 + finally: + fv.full_config.reset(token) + + +def test_auto_load_pulls_noise_only_for_encryption() -> None: + """A plain ota entry must never pull noise-c into the build.""" + assert AUTO_LOAD({CONF_PORT: 3232}) == ["sha256", "socket"] + assert "noise" in AUTO_LOAD({CONF_ENCRYPTION: {}}) + # Tooling probes must get the maximal set: None from dependency + # resolution, {} from the components-graph platform probe + assert "noise" in AUTO_LOAD(None) + assert "noise" in AUTO_LOAD({}) + + +def test_filter_source_files_excludes_noise_without_encryption() -> None: + """The noise transport source compiles only for encrypted builds.""" + old_config = CORE.config + try: + CORE.config = {CONF_OTA: [_make_ota_config(port=3232)]} + assert FILTER_SOURCE_FILES() == ["ota_esphome_noise.cpp"] + CORE.config = { + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: API_KEY}}) + ] + } + assert FILTER_SOURCE_FILES() == [] + finally: + CORE.config = old_config + + +def test_password_with_encryption_rejected() -> None: + """The password and encryption options are mutually exclusive.""" + config = {CONF_PASSWORD: "pw", CONF_ENCRYPTION: {CONF_KEY: API_KEY}} + with pytest.raises(cv.Invalid, match="cannot be combined"): + _validate_no_password_with_encryption(config) + + +def test_password_alone_accepted() -> None: + """A password without encryption still validates.""" + config = {CONF_PASSWORD: "pw"} + assert _validate_no_password_with_encryption(config) is config + + +def test_merged_password_and_encryption_rejected() -> None: + """A password block and an encryption block merged on one port raise.""" + full_conf = { + CONF_OTA: [ + _make_ota_config(port=3232, **{CONF_PASSWORD: "pw"}), + _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: API_KEY}}), + ] + } + token = fv.full_config.set(full_conf) + try: + with pytest.raises(cv.Invalid, match="cannot be combined"): + ota_esphome_final_validate({}) + finally: + fv.full_config.reset(token) diff --git a/tests/component_tests/provisioning/test_provisioning.py b/tests/component_tests/provisioning/test_provisioning.py index d3a3771bbc..83c31aeca6 100644 --- a/tests/component_tests/provisioning/test_provisioning.py +++ b/tests/component_tests/provisioning/test_provisioning.py @@ -11,6 +11,7 @@ from esphome.components.provisioning import ( CONFIG_SCHEMA, FINAL_VALIDATE_SCHEMA, register_source, + report_ap_without_sta, report_hardcoded_credentials, ) from esphome.const import CONF_TIMEOUT, PlatformFramework @@ -66,6 +67,32 @@ def test_provisioning_no_warning_without_hardcoded_credentials( assert "credentials" not in caplog.text +def test_provisioning_warns_on_ap_without_sta( + set_core_config: SetCoreConfigCallable, + caplog: pytest.LogCaptureFixture, +) -> None: + """An access point with no station credentials triggers a reachability warning.""" + set_core_config(PlatformFramework.ESP32_IDF) + register_source("network") + report_ap_without_sta() + with caplog.at_level(logging.WARNING): + FINAL_VALIDATE_SCHEMA({}) + assert "access point" in caplog.text + assert "unreachable" in caplog.text + + +def test_provisioning_no_warning_without_ap( + set_core_config: SetCoreConfigCallable, + caplog: pytest.LogCaptureFixture, +) -> None: + """No reachability warning when no AP-without-station setup is reported.""" + set_core_config(PlatformFramework.ESP32_IDF) + register_source("network") + with caplog.at_level(logging.WARNING): + FINAL_VALIDATE_SCHEMA({}) + assert "access point" not in caplog.text + + def test_provisioning_rejects_zero_timeout( set_core_config: SetCoreConfigCallable, ) -> None: diff --git a/tests/component_tests/spi/test_psram_dma.py b/tests/component_tests/spi/test_psram_dma.py new file mode 100644 index 0000000000..f721e0761b --- /dev/null +++ b/tests/component_tests/spi/test_psram_dma.py @@ -0,0 +1,227 @@ +"""Tests for SPI PSRAM DMA configuration validation.""" + +import pytest + +from esphome import config_validation as cv +from esphome.components.esp32 import ( + KEY_BOARD, + KEY_VARIANT, + VARIANT_ESP32, + VARIANT_ESP32S3, + VARIANT_ESP32S31, +) +from esphome.components.spi import ( + CONF_INTERFACE_INDEX, + CONF_PSRAM_DMA, + _final_validate, + spi_device_schema, +) +from esphome.config import Config +from esphome.const import CONF_ID, CONF_SPI_ID, KEY_FRAMEWORK_VERSION, PlatformFramework +from esphome.core import CORE, ID +from tests.component_tests.types import SetCoreConfigCallable + + +def _schema() -> cv.Schema: + return spi_device_schema( + cs_pin_required=False, + default_data_rate="1MHz", + default_mode="MODE0", + ) + + +def _stage( + set_core_config: SetCoreConfigCallable, + platform_framework: PlatformFramework, + variant: str, + version: cv.Version, +) -> None: + set_core_config( + platform_framework, + core_data={KEY_FRAMEWORK_VERSION: version}, + platform_data={KEY_BOARD: "test-board", KEY_VARIANT: variant}, + ) + CORE.loaded_integrations.add("psram") + + +def test_psram_dma_accepts_supported_idf_target( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_IDF, + VARIANT_ESP32S3, + cv.Version(5, 5, 3), + ) + + config = _schema()({CONF_PSRAM_DMA: True}) + + assert config[CONF_PSRAM_DMA] is True + + +def test_psram_dma_accepts_esp32s31( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_IDF, + VARIANT_ESP32S31, + cv.Version(6, 0, 0), + ) + + config = _schema()({CONF_PSRAM_DMA: True}) + + assert config[CONF_PSRAM_DMA] is True + + +def test_psram_dma_rejects_arduino( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_ARDUINO, + VARIANT_ESP32S3, + cv.Version(5, 5, 3), + ) + + with pytest.raises(cv.Invalid, match="only available with framework"): + _schema()({CONF_PSRAM_DMA: True}) + + +def test_psram_dma_rejects_target_without_capability( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_IDF, + VARIANT_ESP32, + cv.Version(5, 5, 3), + ) + + with pytest.raises(cv.Invalid, match="PSRAM DMA is only available"): + _schema()({CONF_PSRAM_DMA: True}) + + +def test_psram_dma_false_is_portable( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_ARDUINO, + VARIANT_ESP32, + cv.Version(5, 5, 2), + ) + + config = _schema()({CONF_PSRAM_DMA: False}) + + assert config[CONF_PSRAM_DMA] is False + + +def test_psram_dma_rejects_older_idf( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_IDF, + VARIANT_ESP32S3, + cv.Version(5, 5, 2), + ) + + with pytest.raises(cv.Invalid, match="requires at least framework version 5.5.3"): + _schema()({CONF_PSRAM_DMA: True}) + + +def test_psram_dma_requires_psram_component( + set_core_config: SetCoreConfigCallable, +) -> None: + _stage( + set_core_config, + PlatformFramework.ESP32_IDF, + VARIANT_ESP32S3, + cv.Version(5, 5, 3), + ) + CORE.loaded_integrations.remove("psram") + + with pytest.raises(cv.Invalid, match="requires component psram"): + _schema()({CONF_PSRAM_DMA: True}) + + +def _full_spi_config(*, hardware: bool, with_device: bool = True) -> tuple[Config, ID]: + bus_id = ID("spi_bus", is_declaration=True, type="SPIComponent") + bus = {CONF_ID: bus_id} + if hardware: + bus[CONF_INTERFACE_INDEX] = 0 + full = Config() + full["spi"] = [bus] + if with_device: + full["spi_device_test"] = { + CONF_SPI_ID: ID("spi_bus"), + CONF_PSRAM_DMA: True, + } + full.declare_ids.append((bus_id, ["spi", 0, CONF_ID])) + return full, ID("spi_bus", is_declaration=False, type="SPIComponent") + + +def test_psram_dma_accepts_hardware_spi( + set_core_config: SetCoreConfigCallable, +) -> None: + full_config, _ = _full_spi_config(hardware=True) + set_core_config(PlatformFramework.ESP32_IDF, full_config=full_config) + + _final_validate(full_config["spi"]) + + +def test_psram_dma_rejects_software_spi( + set_core_config: SetCoreConfigCallable, +) -> None: + full_config, _ = _full_spi_config(hardware=False) + set_core_config(PlatformFramework.ESP32_IDF, full_config=full_config) + + with pytest.raises(cv.Invalid, match="psram_dma requires a hardware SPI") as error: + _final_validate(full_config["spi"]) + + assert error.value.path[-2:] == ["spi_device_test", CONF_PSRAM_DMA] + + +def test_spi_bus_rejects_psram_dma_device_without_component_final_validation( + set_core_config: SetCoreConfigCallable, +) -> None: + full_config, bus_id = _full_spi_config(hardware=False, with_device=False) + full_config["device_without_final_validation"] = { + CONF_SPI_ID: bus_id, + CONF_PSRAM_DMA: True, + } + set_core_config(PlatformFramework.ESP32_IDF, full_config=full_config) + + with pytest.raises(cv.Invalid, match="psram_dma requires a hardware SPI") as error: + _final_validate(full_config["spi"]) + + assert error.value.path[-2:] == [ + "device_without_final_validation", + CONF_PSRAM_DMA, + ] + + +def test_psram_dma_accepts_hardware_device_with_mixed_buses( + set_core_config: SetCoreConfigCallable, +) -> None: + software_bus_id = ID("software_bus", is_declaration=True, type="SPIComponent") + hardware_bus_id = ID("hardware_bus", is_declaration=True, type="SPIComponent") + full_config = Config() + full_config["spi"] = [ + {CONF_ID: software_bus_id}, + {CONF_ID: hardware_bus_id, CONF_INTERFACE_INDEX: 0}, + ] + full_config["spi_device_test"] = { + CONF_SPI_ID: ID("hardware_bus"), + CONF_PSRAM_DMA: True, + } + full_config.declare_ids.extend( + ( + (software_bus_id, ["spi", 0, CONF_ID]), + (hardware_bus_id, ["spi", 1, CONF_ID]), + ) + ) + set_core_config(PlatformFramework.ESP32_IDF, full_config=full_config) + + _final_validate(full_config["spi"]) diff --git a/tests/components/api/common-base.yaml b/tests/components/api/common-base.yaml index c9eb200471..5e3139da48 100644 --- a/tests/components/api/common-base.yaml +++ b/tests/components/api/common-base.yaml @@ -61,8 +61,12 @@ api: reboot_timeout: 0min actions: - action: hello_world + description: Log a greeting variables: - name: string + name: + type: string + description: Name to greet + example: World then: - logger.log: format: Hello World %s! diff --git a/tests/components/api/common.yaml b/tests/components/api/common.yaml index 6115838b6d..42eb32a92a 100644 --- a/tests/components/api/common.yaml +++ b/tests/components/api/common.yaml @@ -1,4 +1,5 @@ -<<: !include common-base.yaml +packages: + base: !include common-base.yaml api: encryption: diff --git a/tests/components/api/test_proto_mac_varint.cpp b/tests/components/api/test_proto_mac_varint.cpp index f2a63e96f6..9ea6ce1cd9 100644 --- a/tests/components/api/test_proto_mac_varint.cpp +++ b/tests/components/api/test_proto_mac_varint.cpp @@ -54,7 +54,7 @@ static void verify_mac(uint64_t mac, size_t expected_bytes) { size_t ref_len = reference_encode(mac, ref_buf); APIBuffer api_buf; - api_buf.resize(16); + ASSERT_TRUE(api_buf.resize(16)); uint8_t *pos = api_buf.data(); #ifdef ESPHOME_DEBUG_API uint8_t *proto_debug_end_ = api_buf.data() + api_buf.size(); diff --git a/tests/components/core/test_helpers.cpp b/tests/components/core/test_helpers.cpp index 3767b24d86..baf688fc8a 100644 --- a/tests/components/core/test_helpers.cpp +++ b/tests/components/core/test_helpers.cpp @@ -1,4 +1,5 @@ #include +#include #include #include "esphome/core/alloc_helpers.h" @@ -280,4 +281,71 @@ TEST(Base64, Rfc4648Vectors) { } } +// --- step_to_accuracy_decimals() --- + +TEST(StepToAccuracyDecimals, TypicalSteps) { + EXPECT_EQ(step_to_accuracy_decimals(0.001f), 3); + EXPECT_EQ(step_to_accuracy_decimals(0.005f), 3); + EXPECT_EQ(step_to_accuracy_decimals(0.01f), 2); + EXPECT_EQ(step_to_accuracy_decimals(0.025f), 3); + EXPECT_EQ(step_to_accuracy_decimals(0.05f), 2); + EXPECT_EQ(step_to_accuracy_decimals(0.1f), 1); + EXPECT_EQ(step_to_accuracy_decimals(0.25f), 2); + EXPECT_EQ(step_to_accuracy_decimals(0.5f), 1); + EXPECT_EQ(step_to_accuracy_decimals(1.5f), 1); + EXPECT_EQ(step_to_accuracy_decimals(2.5f), 1); +} + +TEST(StepToAccuracyDecimals, WholeSteps) { + EXPECT_EQ(step_to_accuracy_decimals(1.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(2.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(5.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(10.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(100.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(1000.0f), 0); +} + +TEST(StepToAccuracyDecimals, FiveSignificantDigits) { + EXPECT_EQ(step_to_accuracy_decimals(1.23456f), 4); + EXPECT_EQ(step_to_accuracy_decimals(12.345f), 3); + EXPECT_EQ(step_to_accuracy_decimals(123.45f), 2); + EXPECT_EQ(step_to_accuracy_decimals(1234.5f), 1); + EXPECT_EQ(step_to_accuracy_decimals(12345.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(0.33333f), 5); + EXPECT_EQ(step_to_accuracy_decimals(0.0001f), 4); +} + +TEST(StepToAccuracyDecimals, TrailingZerosDropped) { + EXPECT_EQ(step_to_accuracy_decimals(0.3f), 1); + EXPECT_EQ(step_to_accuracy_decimals(0.7f), 1); + EXPECT_EQ(step_to_accuracy_decimals(0.125f), 3); + EXPECT_EQ(step_to_accuracy_decimals(0.0625f), 4); +} + +TEST(StepToAccuracyDecimals, RoundsUpToWholeNumber) { + // Rounds to five significant digits first, so this becomes 10 with no decimals. + EXPECT_EQ(step_to_accuracy_decimals(9.999999f), 0); +} + +TEST(StepToAccuracyDecimals, OutsideFixedNotationRange) { + // %.5g would print these in exponent form; the count is now the real one rather than a parse of "1e-05". + EXPECT_EQ(step_to_accuracy_decimals(0.00001f), 5); + EXPECT_EQ(step_to_accuracy_decimals(0.000125f), 6); + EXPECT_EQ(step_to_accuracy_decimals(123456.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(1000000.0f), 0); +} + +TEST(StepToAccuracyDecimals, SignIgnored) { + EXPECT_EQ(step_to_accuracy_decimals(-0.1f), 1); + EXPECT_EQ(step_to_accuracy_decimals(-0.25f), 2); + EXPECT_EQ(step_to_accuracy_decimals(-1.0f), 0); +} + +TEST(StepToAccuracyDecimals, NonFiniteAndZero) { + EXPECT_EQ(step_to_accuracy_decimals(0.0f), 0); + EXPECT_EQ(step_to_accuracy_decimals(NAN), 0); + EXPECT_EQ(step_to_accuracy_decimals(INFINITY), 0); + EXPECT_EQ(step_to_accuracy_decimals(-INFINITY), 0); +} + } // namespace esphome::core::testing diff --git a/tests/components/d01/common.yaml b/tests/components/d01/common.yaml new file mode 100644 index 0000000000..b59ec06ff0 --- /dev/null +++ b/tests/components/d01/common.yaml @@ -0,0 +1,3 @@ +sensor: + - platform: d01 + name: D01 PM2.5 Concentration diff --git a/tests/components/d01/test.esp32-idf.yaml b/tests/components/d01/test.esp32-idf.yaml new file mode 100644 index 0000000000..b658bfbede --- /dev/null +++ b/tests/components/d01/test.esp32-idf.yaml @@ -0,0 +1,7 @@ +substitutions: + tx_pin: GPIO4 + rx_pin: GPIO5 + +packages: + uart: !include ../../test_build_components/common/uart/esp32-idf.yaml + d01: !include common.yaml diff --git a/tests/components/d01/test.esp8266-ard.yaml b/tests/components/d01/test.esp8266-ard.yaml new file mode 100644 index 0000000000..876615ae9f --- /dev/null +++ b/tests/components/d01/test.esp8266-ard.yaml @@ -0,0 +1,7 @@ +substitutions: + tx_pin: GPIO0 + rx_pin: GPIO2 + +packages: + uart: !include ../../test_build_components/common/uart/esp8266-ard.yaml + d01: !include common.yaml diff --git a/tests/components/d01/test.rp2040-ard.yaml b/tests/components/d01/test.rp2040-ard.yaml new file mode 100644 index 0000000000..00ed175b42 --- /dev/null +++ b/tests/components/d01/test.rp2040-ard.yaml @@ -0,0 +1,7 @@ +substitutions: + tx_pin: GPIO4 + rx_pin: GPIO5 + +packages: + uart: !include ../../test_build_components/common/uart/rp2040-ard.yaml + d01: !include common.yaml diff --git a/tests/components/ds1603l/common.yaml b/tests/components/ds1603l/common.yaml new file mode 100644 index 0000000000..d47ef1b610 --- /dev/null +++ b/tests/components/ds1603l/common.yaml @@ -0,0 +1,3 @@ +sensor: + - platform: ds1603l + name: ds1603l Distance diff --git a/tests/components/ds1603l/test.esp32-idf.yaml b/tests/components/ds1603l/test.esp32-idf.yaml new file mode 100644 index 0000000000..544827f577 --- /dev/null +++ b/tests/components/ds1603l/test.esp32-idf.yaml @@ -0,0 +1,7 @@ +substitutions: + tx_pin: GPIO1 + rx_pin: GPIO3 + +packages: + uart: !include ../../test_build_components/common/uart/esp32-idf.yaml + ds1603l: !include common.yaml diff --git a/tests/components/ds1603l/test.esp8266-ard.yaml b/tests/components/ds1603l/test.esp8266-ard.yaml new file mode 100644 index 0000000000..878e45899b --- /dev/null +++ b/tests/components/ds1603l/test.esp8266-ard.yaml @@ -0,0 +1,7 @@ +substitutions: + tx_pin: GPIO0 + rx_pin: GPIO2 + +packages: + uart: !include ../../test_build_components/common/uart/esp8266-ard.yaml + ds1603l: !include common.yaml diff --git a/tests/components/epaper_spi/test.esp32-s3-idf.yaml b/tests/components/epaper_spi/test.esp32-s3-idf.yaml index 9cca528744..602aeb8d0e 100644 --- a/tests/components/epaper_spi/test.esp32-s3-idf.yaml +++ b/tests/components/epaper_spi/test.esp32-s3-idf.yaml @@ -255,3 +255,45 @@ display: it.filled_rectangle(0, 0, it.get_width(), it.get_height(), Color::WHITE); it.circle(it.get_width() / 2, it.get_height() / 2, 100, Color::BLACK); it.circle(it.get_width() / 2, it.get_height() / 2, 60, Color(255, 0, 0)); + + # Waveshare 7.5" V2 mono (800x480, UC8179 controller, EPD_7in5_V2) + # full_update_every > 1 exercises the fast/partial refresh paths + - platform: epaper_spi + spi_id: spi_bus + model: waveshare-7.5in-v2 + full_update_every: 4 + cs_pin: + allow_other_uses: true + number: GPIO5 + dc_pin: + allow_other_uses: true + number: GPIO17 + reset_pin: + allow_other_uses: true + number: GPIO16 + busy_pin: + allow_other_uses: true + number: GPIO4 + inverted: true + lambda: |- + it.filled_rectangle(0, 0, it.get_width(), it.get_height(), Color::WHITE); + it.circle(it.get_width() / 2, it.get_height() / 2, 100, Color::BLACK); + + # Seeed reTerminal E1001 - 7.5" mono e-paper (800x480, UC8179) + # Pins overridden to avoid conflicts with the E1002 defaults above + - platform: epaper_spi + spi_id: spi_bus + model: seeed-reterminal-e1001 + cs_pin: + allow_other_uses: true + number: GPIO5 + dc_pin: + allow_other_uses: true + number: GPIO17 + reset_pin: + allow_other_uses: true + number: GPIO16 + busy_pin: + allow_other_uses: true + number: GPIO4 + inverted: true diff --git a/tests/components/improv_base/benchmark.yaml b/tests/components/improv_base/benchmark.yaml new file mode 100644 index 0000000000..8781e614a1 --- /dev/null +++ b/tests/components/improv_base/benchmark.yaml @@ -0,0 +1,6 @@ +# The builder test compares against the Improv library's build_rpc_response, +# so the library must be part of the unit test build. +# Keep the version in sync with the pin in esphome/components/improv_base/__init__.py. +esphome: + libraries: + - improv/Improv@1.2.7 diff --git a/tests/components/improv_base/rpc_response_builder_test.cpp b/tests/components/improv_base/rpc_response_builder_test.cpp new file mode 100644 index 0000000000..d9d0ad90d8 --- /dev/null +++ b/tests/components/improv_base/rpc_response_builder_test.cpp @@ -0,0 +1,102 @@ +#include + +#include +#include +#include +#include +#include + +#include + +namespace esphome::improv_base::testing { + +namespace { + +std::vector build_with_builder(improv::Command command, const std::vector &datum, + bool add_checksum) { + std::array buf; + improv::RpcResponseBuilder builder(buf, command); + for (const auto &str : datum) { + EXPECT_TRUE(builder.add_string(str.c_str(), str.size())); + } + auto out = builder.finish(add_checksum); + return {out.begin(), out.end()}; +} + +} // namespace + +// The serial path sends builder output where build_rpc_response bytes went before, +// so the two must match exactly, including the trailing 0x00 when checksums are off. +TEST(RpcResponseBuilder, ByteIdenticalToBuildRpcResponse) { + const std::vector device_info = {"ESPHome", "2026.9.0", "ESP32", "test-device"}; + const std::vector network = {"MySSID", "-67", "YES"}; + const std::vector empty = {}; + const std::vector max_payload = {std::string(254, 'x')}; + + for (bool add_checksum : {false, true}) { + for (const auto *datum : {&device_info, &network, &empty, &max_payload}) { + EXPECT_EQ(build_with_builder(improv::GET_DEVICE_INFO, *datum, add_checksum), + improv::build_rpc_response(improv::GET_DEVICE_INFO, *datum, add_checksum)); + } + } +} + +// Golden bytes independent of the library: command, data length, string entries, +// then the trailing byte (0x00 without checksum, additive checksum with). +TEST(RpcResponseBuilder, GoldenBytes) { + EXPECT_EQ(build_with_builder(improv::GET_WIFI_NETWORKS, {}, false), (std::vector{0x04, 0x00, 0x00})); + EXPECT_EQ(build_with_builder(improv::GET_WIFI_NETWORKS, {"ab"}, false), + (std::vector{0x04, 0x03, 0x02, 'a', 'b', 0x00})); + // Checksum: 0x04 + 0x03 + 0x02 + 'a' + 'b' = 0xCC + EXPECT_EQ(build_with_builder(improv::GET_WIFI_NETWORKS, {"ab"}, true), + (std::vector{0x04, 0x03, 0x02, 'a', 'b', 0xCC})); +} + +// esp32_improv calls finish() and build_rpc_response() with no checksum flag, +// so the two defaults must agree +TEST(RpcResponseBuilder, DefaultChecksumFlagMatches) { + const std::vector urls = {"https://example.com"}; + std::array buf; + improv::RpcResponseBuilder builder(buf, improv::WIFI_SETTINGS); + for (const auto &str : urls) { + EXPECT_TRUE(builder.add_string(str.c_str(), str.size())); + } + auto out = builder.finish(); + EXPECT_EQ(std::vector(out.begin(), out.end()), improv::build_rpc_response(improv::WIFI_SETTINGS, urls)); +} + +TEST(RpcResponseBuilder, PayloadBudget) { + std::array buf; + + // 254 byte string fills the payload exactly; a second entry no longer fits + improv::RpcResponseBuilder full(buf, improv::GET_DEVICE_INFO); + const std::string big(254, 'x'); + EXPECT_TRUE(full.add_string(big.c_str(), big.size())); + EXPECT_FALSE(full.add_string("y", 1)); + + // 255 byte string can never fit (its length byte would exceed the budget) + improv::RpcResponseBuilder over(buf, improv::GET_DEVICE_INFO); + const std::string too_big(255, 'y'); + EXPECT_FALSE(over.add_string(too_big.c_str(), too_big.size())); + // A wildly out of range length must not wrap the position arithmetic + EXPECT_FALSE(over.add_string("z", static_cast(-1))); + auto out = over.finish(false); + EXPECT_EQ(std::vector(out.begin(), out.end()), (std::vector{0x03, 0x00, 0x00})); +} + +TEST(RpcResponseBuilder, FinishIsIdempotent) { + std::array buf; + improv::RpcResponseBuilder builder(buf, improv::GET_DEVICE_INFO); + EXPECT_TRUE(builder.add_string("abc", 3)); + auto first = builder.finish(true); + const std::vector expected(first.begin(), first.end()); + + EXPECT_FALSE(builder.add_string("late", 4)); + auto again = builder.finish(true); + EXPECT_EQ(std::vector(again.begin(), again.end()), expected); + // The checksum flag on a later call is ignored + auto no_checksum = builder.finish(false); + EXPECT_EQ(std::vector(no_checksum.begin(), no_checksum.end()), expected); +} + +} // namespace esphome::improv_base::testing diff --git a/tests/components/improv_serial/common-ethernet.yaml b/tests/components/improv_serial/common-ethernet.yaml new file mode 100644 index 0000000000..c1d8190c13 --- /dev/null +++ b/tests/components/improv_serial/common-ethernet.yaml @@ -0,0 +1,17 @@ +ethernet: + type: W5500 + clk_pin: 19 + mosi_pin: 21 + miso_pin: 17 + cs_pin: 18 + interrupt_pin: 36 + reset_pin: 12 + clock_speed: 10Mhz + +logger: + hardware_uart: UART0 + +# Exercises the per-interface webserver URL collection at compile time +web_server: + +improv_serial: diff --git a/tests/components/improv_serial/common-uart-bus.yaml b/tests/components/improv_serial/common-uart-bus.yaml new file mode 100644 index 0000000000..41ee00fce0 --- /dev/null +++ b/tests/components/improv_serial/common-uart-bus.yaml @@ -0,0 +1,11 @@ +wifi: + ssid: MySSID + password: password1 + +# Serial logging off; on a dedicated UART bus improv_serial must not +# require the logger's serial settings +logger: + baud_rate: 0 + +improv_serial: + uart_id: uart_bus diff --git a/tests/components/improv_serial/common-uart0.yaml b/tests/components/improv_serial/common-uart0.yaml index 7b7730fd46..45bf1e5c33 100644 --- a/tests/components/improv_serial/common-uart0.yaml +++ b/tests/components/improv_serial/common-uart0.yaml @@ -5,4 +5,6 @@ wifi: logger: hardware_uart: UART0 +# next_url compiles the USE_IMPROV_SERIAL_NEXT_URL branch and add_next_url_ improv_serial: + next_url: https://example.com/?device_name={{device_name}}&ip_address={{ip_address}} diff --git a/tests/components/improv_serial/test-ethernet.esp32-idf.yaml b/tests/components/improv_serial/test-ethernet.esp32-idf.yaml new file mode 100644 index 0000000000..2dd3a1551e --- /dev/null +++ b/tests/components/improv_serial/test-ethernet.esp32-idf.yaml @@ -0,0 +1,2 @@ +packages: + improv_serial: !include common-ethernet.yaml diff --git a/tests/components/improv_serial/test-uart-bus.esp32-idf.yaml b/tests/components/improv_serial/test-uart-bus.esp32-idf.yaml new file mode 100644 index 0000000000..235e3789a4 --- /dev/null +++ b/tests/components/improv_serial/test-uart-bus.esp32-idf.yaml @@ -0,0 +1,3 @@ +packages: + uart: !include ../../test_build_components/common/uart/esp32-idf.yaml + improv_serial: !include common-uart-bus.yaml diff --git a/tests/components/improv_serial/test-uart-bus.esp8266-ard.yaml b/tests/components/improv_serial/test-uart-bus.esp8266-ard.yaml new file mode 100644 index 0000000000..40a6b7f4fe --- /dev/null +++ b/tests/components/improv_serial/test-uart-bus.esp8266-ard.yaml @@ -0,0 +1,3 @@ +packages: + uart: !include ../../test_build_components/common/uart/esp8266-ard.yaml + improv_serial: !include common-uart-bus.yaml diff --git a/tests/components/light/test_gamma_correction.cpp b/tests/components/light/test_gamma_correction.cpp new file mode 100644 index 0000000000..4b8d83c544 --- /dev/null +++ b/tests/components/light/test_gamma_correction.cpp @@ -0,0 +1,92 @@ +#include + +#include +#include +#include +#include + +#include "esphome/components/light/esp_color_correction.h" + +namespace esphome::light::testing { + +namespace { + +// A representative fixture for ESPColorCorrection/gamma_table_reverse_search tests below -- +// not a spec for generate_gamma_table() itself, which the Python tests own. +std::array build_gamma_table(double gamma) { + std::array table{}; + table[0] = 0; + for (int i = 1; i < 256; i++) { + double raw = std::round(std::pow(i / 255.0, gamma) * 65535.0); + table[i] = static_cast(std::max(1.0, std::min(65535.0, raw))); + } + return table; +} + +// Bundles a table with an ESPColorCorrection pointing at it, since the correction only holds +// a raw pointer into the table and doesn't own it. +struct GammaFixture { + explicit GammaFixture(double gamma) : table(build_gamma_table(gamma)) { correction.set_gamma_table(table.data()); } + std::array table; + ESPColorCorrection correction; +}; + +} // namespace + +// Regression test for esphome/esphome#18842: ESPColorCorrection's own 16-bit -> 8-bit +// conversion must never round a non-zero table entry down to a zero 8-bit output. +TEST(GammaCorrection, NonZeroInputsSurviveConversion) { + for (double gamma : {1.0, 1.8, 2.0, 2.2, 2.8, 3.0, 4.0}) { + GammaFixture fixture(gamma); + for (int i = 1; i < 256; i++) { + EXPECT_GE(fixture.correction.color_correct_red(i), 1) << "gamma=" << gamma << " index=" << i; + } + } +} + +TEST(GammaCorrection, ZeroInputStaysZero) { + for (double gamma : {1.0, 2.2, 2.8, 4.0}) { + GammaFixture fixture(gamma); + EXPECT_EQ(fixture.correction.color_correct_red(0), 0) << "gamma=" << gamma; + } +} + +TEST(GammaCorrection, FullBrightnessStaysFull) { + for (double gamma : {1.0, 2.2, 2.8, 4.0}) { + GammaFixture fixture(gamma); + EXPECT_EQ(fixture.correction.color_correct_red(255), 255) << "gamma=" << gamma; + } +} + +// Reproduces the reporter's own numbers from esphome/esphome#18842 at gamma=2.8: codes +// 1-27 previously collapsed to an 8-bit output of 0 and must now be non-zero. +TEST(GammaCorrection, DeadZoneFixedAtGamma28) { + GammaFixture fixture(2.8); + for (int i = 1; i < 28; i++) { + EXPECT_GE(fixture.correction.color_correct_red(i), 1) << "index=" << i << " still collapses to 0"; + } +} + +TEST(GammaCorrection, ReverseSearchFindsLargestIndexLessEqualTarget) { + auto table = build_gamma_table(2.8); + for (uint16_t target : {0, 128, 129, 135, 1000, 32768, 65535}) { + uint8_t lo = gamma_table_reverse_search(table.data(), target); + EXPECT_LE(table[lo], target) << "target=" << target; + if (lo < 255) { + EXPECT_GT(table[lo + 1], target) << "target=" << target; + } + } +} + +// color_uncorrect_* binary-searches the table via gamma_table_reverse_search(). +TEST(GammaCorrection, UncorrectStaysMonotonic) { + GammaFixture fixture(2.8); + uint8_t prev = 0; + for (int i = 1; i < 256; i++) { + uint8_t result = fixture.correction.color_uncorrect_red(i); + EXPECT_GE(result, prev) << "index=" << i; + prev = result; + } +} + +} // namespace esphome::light::testing diff --git a/tests/components/lvgl/lvgl-package.yaml b/tests/components/lvgl/lvgl-package.yaml index 57be4e9043..07c492db35 100644 --- a/tests/components/lvgl/lvgl-package.yaml +++ b/tests/components/lvgl/lvgl-package.yaml @@ -188,6 +188,8 @@ lvgl: dark_mode: true obj: border_width: 1 + user_1: + bg_color: black gradients: - id: color_bar @@ -209,6 +211,63 @@ lvgl: position: 212 - color: 0xFF0000 position: 255 + - id: linear_grad + direction: LINEAR + linear: + from_x: 0% + from_y: 0% + to_x: 100% + to_y: 0% + extend: REFLECT + stops: + - color: 0xFF0000 + position: 0 + - color: 0x0000FF + position: 255 + - id: radial_grad + direction: RADIAL + radial: + center_x: 50% + center_y: 50% + to_x: 100% + to_y: 50% + extend: PAD + stops: + - color: 0xFFFFFF + position: 0 + - color: 0x000000 + position: 255 + - id: radial_focal_grad + direction: RADIAL + radial: + center_x: 50% + center_y: 50% + to_x: 100% + to_y: 50% + focal_x: 40% + focal_y: 40% + focal_radius: 10 + extend: REPEAT + stops: + - color: 0xFF0000 + position: 0 + - color: 0x0000FF + position: 255 + - id: conical_grad + direction: CONICAL + conical: + center_x: 50% + center_y: 50% + start_angle: 0 + end_angle: 360 + extend: PAD + stops: + - color: 0xFF0000 + position: 0 + - color: 0x00FF00 + position: 127 + - color: 0xFF0000 + position: 255 style_definitions: - id: style_test @@ -660,6 +719,30 @@ lvgl: id: button_with_text text: Clicked + # Exercises the LV_STATE_USER_1..USER_4 states: setting them at creation + # (both literal and lambda), styling each of them individually, and + # setting/clearing them at runtime with lvgl.widget.update. + - button: + id: user_flags_button + text: User flags + state: + user_1: true + user_2: !lambda return true; + user_1: + bg_color: 0xFF00FF + user_2: + bg_color: 0x00FFFF + user_3: + bg_color: 0xFFFF00 + user_4: + bg_color: 0x808080 + on_click: + - lvgl.widget.update: + id: user_flags_button + state: + user_3: true + user_4: !lambda return !lv_obj_has_state(id(user_flags_button), LV_STATE_USER_4); + - button: layout: 2x1 id: button_button @@ -1070,6 +1153,14 @@ lvgl: logger.log: format: Slider released at %d/%d with value %.0f args: ['(int) point.x', '(int) point.y', x] + + # Exercises the style-application path for a complex gradient, not just its + # lv_grad_*_init() codegen: the other new gradients are only ever declared. + - obj: + bg_opa: cover + bg_grad: conical_grad + width: 40 + height: 40 - button: styles: spin_button id: spin_up diff --git a/tests/components/mk2pvrouter/common.yaml b/tests/components/mk2pvrouter/common.yaml new file mode 100644 index 0000000000..4421c09854 --- /dev/null +++ b/tests/components/mk2pvrouter/common.yaml @@ -0,0 +1,46 @@ +mk2pvrouter: + id: test_mk2pvrouter + uart_id: uart_bus + +sensor: + - platform: mk2pvrouter + name: Power + tag: P + mk2pvrouter_id: test_mk2pvrouter + unit_of_measurement: W + device_class: power + state_class: measurement + accuracy_decimals: 0 + + - platform: mk2pvrouter + name: Voltage + tag: V + mk2pvrouter_id: test_mk2pvrouter + unit_of_measurement: V + device_class: voltage + state_class: measurement + accuracy_decimals: 2 + filters: + # Device sends voltage * 100 + - multiply: 0.01 + + - platform: mk2pvrouter + name: Energy + tag: E + mk2pvrouter_id: test_mk2pvrouter + unit_of_measurement: Wh + device_class: energy + state_class: total_increasing + accuracy_decimals: 0 + + - platform: mk2pvrouter + name: Temperature + tag: T1 + mk2pvrouter_id: test_mk2pvrouter + unit_of_measurement: "°C" + device_class: temperature + state_class: measurement + accuracy_decimals: 2 + filters: + # Device sends temperature * 100 + - multiply: 0.01 diff --git a/tests/components/mk2pvrouter/test.esp32-idf.yaml b/tests/components/mk2pvrouter/test.esp32-idf.yaml new file mode 100644 index 0000000000..66539a4dd7 --- /dev/null +++ b/tests/components/mk2pvrouter/test.esp32-idf.yaml @@ -0,0 +1,3 @@ +packages: + uart_9600_even_7bits: !include ../../test_build_components/common/uart_9600_even_7bits/esp32-idf.yaml + mk2pvrouter: !include common.yaml diff --git a/tests/components/mk2pvrouter/test.esp8266-ard.yaml b/tests/components/mk2pvrouter/test.esp8266-ard.yaml new file mode 100644 index 0000000000..50a45a6ca5 --- /dev/null +++ b/tests/components/mk2pvrouter/test.esp8266-ard.yaml @@ -0,0 +1,3 @@ +packages: + uart_9600_even_7bits: !include ../../test_build_components/common/uart_9600_even_7bits/esp8266-ard.yaml + mk2pvrouter: !include common.yaml diff --git a/tests/components/mk2pvrouter/test.rp2040-ard.yaml b/tests/components/mk2pvrouter/test.rp2040-ard.yaml new file mode 100644 index 0000000000..f8a5a620b3 --- /dev/null +++ b/tests/components/mk2pvrouter/test.rp2040-ard.yaml @@ -0,0 +1,3 @@ +packages: + uart_9600_even_7bits: !include ../../test_build_components/common/uart_9600_even_7bits/rp2040-ard.yaml + mk2pvrouter: !include common.yaml diff --git a/tests/components/modbus/common.h b/tests/components/modbus/common.h index e6c37b0e6d..83d30b3f6d 100644 --- a/tests/components/modbus/common.h +++ b/tests/components/modbus/common.h @@ -11,7 +11,14 @@ namespace esphome::modbus::testing { // A UART that discards all writes, for tests that never inspect the wire. class NullUART : public uart::UARTComponent { public: - NullUART() { this->set_baud_rate(115200); } + // 8N1, matching what the uart schema emits for a real hub; the framing drives the modbus + // interframe timing, so leaving data/stop bits at their zero defaults would not be representative. + NullUART() { + this->set_baud_rate(115200); + this->set_data_bits(8); + this->set_stop_bits(1); + this->set_parity(uart::UART_CONFIG_PARITY_NONE); + } void write_array(const uint8_t *data, size_t len) override {} bool peek_byte(uint8_t *data) override { return false; } bool read_array(uint8_t *data, size_t len) override { return false; } diff --git a/tests/components/modbus/modbus_client_hub_test.cpp b/tests/components/modbus/modbus_client_hub_test.cpp index 026df34bcc..18c04f32d5 100644 --- a/tests/components/modbus/modbus_client_hub_test.cpp +++ b/tests/components/modbus/modbus_client_hub_test.cpp @@ -775,7 +775,7 @@ TEST(ModbusClientHubBroadcast, DeliversNoTerminalToTypedDevice) { // A broadcast is only meaningful for a command that changes state; a broadcast READ could never be // answered, so the hub refuses it at the door (false return, no entry queued) rather than silently -// retiring it. Writes, 0x17, and custom codes still go through (covered above). +// retiring it. Writes and custom/unknown codes still go through (covered in the neighboring tests). TEST(ModbusClientHubBroadcast, RefusesReadBroadcast) { NullUART uart; NoResponseProbeHub hub; @@ -814,9 +814,8 @@ TEST(ModbusClientHubBroadcast, AcceptsCustomBroadcast) { EXPECT_EQ(hub.entries(), 0u); // the entry is gone } -// An exception-flagged custom code (0x80 bit set) is not a real request: is_function_code_custom() masks -// the bit away and would accept it, but the broadcast guard excludes it, matching classify()'s handling -// of an exception-flagged write. +// An exception-flagged code (0x80 bit set) is never a valid request - that bit is response-only - so +// queue_pdu refuses it up front, before the broadcast guard, whatever its base code. TEST(ModbusClientHubBroadcast, RefusesExceptionFlaggedCustomBroadcast) { NullUART uart; NoResponseProbeHub hub; @@ -833,6 +832,50 @@ TEST(ModbusClientHubBroadcast, RefusesExceptionFlaggedCustomBroadcast) { EXPECT_EQ(device.sent_count_, 0); // never transmitted } +// FC23 (read/write multiple) has a read half that expects a reply, so the Modbus spec does not allow it +// as a broadcast. is_function_code_read() covers it, so the broadcast guard refuses it despite its write +// half. +TEST(ModbusClientHubBroadcast, RefusesReadWriteMultipleBroadcast) { + NullUART uart; + NoResponseProbeHub hub; + hub.set_uart_parent(&uart); + hub.setup(); + BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS); + + // fc, read start+qty, write start+qty, byte count, one data word. + const uint8_t read_write_multiple[] = {0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x01, 0x02, 0xBE, 0xEF}; + EXPECT_FALSE(device.queue_pdu(read_write_multiple)); // its read half could never be answered + EXPECT_EQ(hub.entries(), 0u); +} + +// FC 0x18 (read FIFO queue) is not a "read" by is_function_code_read(), but the hub has an explicit +// response-length rule for it - it demonstrably expects a reply, so it cannot broadcast. +TEST(ModbusClientHubBroadcast, RefusesKnownLengthNonWriteBroadcast) { + NullUART uart; + NoResponseProbeHub hub; + hub.set_uart_parent(&uart); + hub.setup(); + BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS); + + const uint8_t read_fifo[] = {0x18, 0x00, 0x10}; // fc, FIFO pointer address + EXPECT_FALSE(device.queue_pdu(read_fifo)); + EXPECT_EQ(hub.entries(), 0u); +} + +// A code that is neither a read nor exception-flagged (here 0x63, unassigned) is fire-and-forget on a +// broadcast: the hub can't know it isn't a vendor write, so it is accepted and delivered to all devices. +TEST(ModbusClientHubBroadcast, AcceptsNonReadUnknownBroadcast) { + NullUART uart; + NoResponseProbeHub hub; + hub.set_uart_parent(&uart); + hub.setup(); + BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS); + + const uint8_t unknown[] = {0x63, 0x00, 0x01}; + EXPECT_TRUE(device.queue_pdu(unknown)); // not a read, so not refused + EXPECT_EQ(hub.entries(), 1u); +} + namespace { // tx_blocked() clear for send_next_frame_'s gate, then blocked for send_frame_'s post-delay re-check. class RejectPostDelayHub : public NoResponseProbeHub { @@ -1882,30 +1925,20 @@ TEST(ModbusClientHubPriority, ResendFromOnResponseAbsorbsIntoCompletingCommand) EXPECT_FALSE(hub.queued(0).options.continuous); // the one-shot re-send downgraded the poll } -// An exception-flagged function code is never silently re-sendable, even though the read check -// masks the exception bit: its duplicate takes the drop path like any other non-read. -TEST(ModbusClientHubPriority, ExceptionFlaggedDuplicateDroppedNotPromoted) { +// The exception bit marks a response, so a request carrying it is refused outright. +TEST(ModbusClientHubPriority, ExceptionFlaggedPduRefused) { NoResponseProbeHub hub; SentCountingDevice device(&hub, 0x02); - const uint8_t weird[] = {0x83, 0x01, 0x00, 0x00, 0x02}; // read-shaped but exception-flagged - EXPECT_TRUE(device.queue_pdu(weird)); - EXPECT_FALSE(device.queue_pdu(weird)); // non-requeueable: cap of one, so the duplicate is refused + // The 0x80 exception flag is a response-only bit; a request must never set it. queue_pdu refuses an + // exception-flagged PDU up front - nothing is queued - whether its base code reads (0x83 = 0x03 | 0x80) + // or writes (0x86 = 0x06 | 0x80). + const uint8_t read_shaped[] = {0x83, 0x01, 0x00, 0x00, 0x02}; + const uint8_t write_shaped[] = {0x86, 0x00, 0x10, 0xBE, 0xEF}; + EXPECT_FALSE(device.queue_pdu(read_shaped)); + EXPECT_FALSE(device.queue_pdu(write_shaped)); hub.sweep_for_test(); - - ASSERT_EQ(hub.queued_frames(), 1u); - EXPECT_EQ(hub.queued(0).pending, 1u); - EXPECT_EQ(device.not_sent_count_, 0); - - // The write-shaped twin (0x86 masks to WRITE_SINGLE_REGISTER) must not take WRITE-class - // ordering either: exception-flagged codes are excluded from the mutates classification. - const uint8_t weird_write[] = {0x86, 0x00, 0x10, 0xBE, 0xEF}; - device.queue_pdu(weird_write); - ASSERT_EQ(hub.queued_frames(), 2u); - EXPECT_EQ(hub.queued(1).priority(), CommandPriority::READ); // not WRITE - const ModbusDeviceCommand *next = hub.next_ready(); - ASSERT_NE(next, nullptr); - EXPECT_EQ(next->frame.pdu()[0], 0x83); // FIFO by age: it did not jump the older entry + EXPECT_EQ(hub.queued_frames(), 0u); } namespace { diff --git a/tests/components/modbus/modbus_framing_test.cpp b/tests/components/modbus/modbus_framing_test.cpp new file mode 100644 index 0000000000..a102db5a51 --- /dev/null +++ b/tests/components/modbus/modbus_framing_test.cpp @@ -0,0 +1,64 @@ +#include + +#include + +#include "common.h" +#include "esphome/components/modbus/modbus.h" + +namespace esphome::modbus::testing { + +namespace { + +// Exposes the timing values setup() derives from the UART framing. +class FramingProbeHub : public ModbusClientHub { + public: + uint32_t bits_per_char() const { return this->bits_per_char_; } + uint32_t frame_delay_us() const { return this->frame_delay_us_; } +}; + +class FramedUART : public NullUART { + public: + FramedUART(uint32_t baud_rate, uint8_t data_bits, uint8_t stop_bits, uart::UARTParityOptions parity) { + this->set_baud_rate(baud_rate); + this->set_data_bits(data_bits); + this->set_stop_bits(stop_bits); + this->set_parity(parity); + } +}; + +} // namespace + +// 8N1 is 10 bits on the wire, so t3.5 at 9600 baud is 3.5 * 10 / 9600 = 3645.8us. +TEST(ModbusFraming, EightNoneOneDerivesTenBits) { + FramedUART uart(9600, 8, 1, uart::UART_CONFIG_PARITY_NONE); + FramingProbeHub hub; + hub.set_uart_parent(&uart); + hub.setup(); + + EXPECT_EQ(hub.bits_per_char(), 10u); + EXPECT_EQ(hub.frame_delay_us(), 3646u); +} + +// Spec-conformant RTU framing is 11 bits, which lengthens the interframe gap to +// 3.5 * 11 / 9600 = 4010.4us, rounded up. +TEST(ModbusFraming, EightEvenOneDerivesElevenBits) { + FramedUART uart(9600, 8, 1, uart::UART_CONFIG_PARITY_EVEN); + FramingProbeHub hub; + hub.set_uart_parent(&uart); + hub.setup(); + + EXPECT_EQ(hub.bits_per_char(), 11u); + EXPECT_EQ(hub.frame_delay_us(), 4011u); +} + +// Above 19200 baud the spec's fixed 1750us floor governs instead of 3.5 characters. +TEST(ModbusFraming, FastBaudUsesSpecFloor) { + FramedUART uart(115200, 8, 1, uart::UART_CONFIG_PARITY_NONE); + FramingProbeHub hub; + hub.set_uart_parent(&uart); + hub.setup(); + + EXPECT_EQ(hub.frame_delay_us(), 1750u); +} + +} // namespace esphome::modbus::testing diff --git a/tests/components/modbus/modbus_helpers_test.cpp b/tests/components/modbus/modbus_helpers_test.cpp index 53f51b016b..a42625760d 100644 --- a/tests/components/modbus/modbus_helpers_test.cpp +++ b/tests/components/modbus/modbus_helpers_test.cpp @@ -63,6 +63,12 @@ TEST(ModbusClientFrameLength, TooShortReturnsMinimum) { EXPECT_EQ(client_frame_length(frame, 1), MIN_FRAME_SIZE); } +TEST(ModbusClientFrameLength, ExceptionFlaggedIsTheExceptionShape) { + // Sized at 2 so an exception-flagged request fails its CRC at once instead of being scanned for. + const uint8_t exception_request[] = {0x83, 0x02}; + EXPECT_EQ(client_pdu_length(exception_request, sizeof(exception_request)), 2); +} + TEST(ModbusClientFrameLength, ReadAndWriteSingleAreFixed) { // basic_register request fixture is a read-holding request -> 8 bytes const uint8_t read[] = {0x01, 0x03, 0x00, 0x03, 0x00, 0x01, 0x74, 0x0A}; @@ -421,11 +427,132 @@ TEST(ModbusHelpersTest, RegistersToNumberMatchesPayloadToNumber) { } } +TEST(ModbusHelpersTest, RegistersToNumberMatchesPayloadToNumberForQwords) { + // The word shuffle the QWORD_R decode replaces is the least obvious code in the byte path, so pin + // it against that path rather than against registers_to_value(). The top bit is set, which is where + // U_QWORD's unsigned value and this function's int64_t return deliberately diverge. + const uint16_t registers[] = {0xF123, 0x4567, 0x89AB, 0xCDEF}; + const std::vector bytes{0xF1, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; + for (auto value_type : + {SensorValueType::U_QWORD, SensorValueType::S_QWORD, SensorValueType::U_QWORD_R, SensorValueType::S_QWORD_R}) { + EXPECT_EQ(registers_to_number(registers, 4, value_type), + payload_to_number(std::span(bytes), value_type, 0, 0xFFFFFFFF)) + << "value_type=" << static_cast(value_type); + } +} + +TEST(ModbusHelpersTest, RegistersToNumberTreatsRawAndBitAsNothingToDecode) { + // Both have no fixed-width number, so they decode to 0 whatever the span holds - including none. + const uint16_t registers[] = {0x1234}; + EXPECT_EQ(registers_to_number(registers, 1, SensorValueType::RAW), std::optional(0)); + EXPECT_EQ(registers_to_number(registers, 0, SensorValueType::RAW), std::optional(0)); + EXPECT_EQ(registers_to_number(registers, 0, SensorValueType::BIT), std::optional(0)); +} + TEST(ModbusHelpersTest, RegistersToNumberRejectsTruncatedMultiRegisterValue) { const uint16_t registers[] = {0x1234}; EXPECT_FALSE(registers_to_number(registers, 1, SensorValueType::U_DWORD).has_value()); } +// --- registers_to_value ---------------------------------------------------- +// registers_to_number() dispatches to registers_to_value(), so this checks the dispatch table picks +// the right specialisation for each type, not that two implementations agree. The independent check +// against the byte decoder is RegistersToNumberMatchesPayloadToNumber below. + +template void expect_matches_registers_to_number(const uint16_t *registers) { + const auto expected = registers_to_number(registers, register_width_for(VALUE_TYPE), VALUE_TYPE); + // Plain control flow rather than ASSERT_TRUE: the optional analysis does not see through the macro. + if (!expected.has_value()) { + ADD_FAILURE() << "registers_to_number() returned no value for value_type=" << static_cast(VALUE_TYPE); + return; + } + const int64_t number = expected.value(); + if constexpr (VALUE_TYPE == SensorValueType::FP32 || VALUE_TYPE == SensorValueType::FP32_R) { + EXPECT_FLOAT_EQ(registers_to_value(registers), bit_cast(static_cast(number))) + << "value_type=" << static_cast(VALUE_TYPE); + } else { + EXPECT_EQ(static_cast(registers_to_value(registers)), number) + << "value_type=" << static_cast(VALUE_TYPE); + } +} + +TEST(ModbusHelpersTest, RegistersToValueMatchesRegistersToNumber) { + // A high bit in each word exercises sign handling and word order together. + const uint16_t registers[] = {0x8001, 0xFE02}; + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); + expect_matches_registers_to_number(registers); +} + +TEST(ModbusHelpersTest, RegistersToUint32CombinesWordsHighFirst) { + EXPECT_EQ(registers_to_uint32(0x1234, 0x5678), 0x12345678u); +} + +// --- value_at --------------------------------------------------------------- +// Addresses are absolute; anything not wholly inside the response yields nullopt. + +TEST(ModbusHelpersTest, ValueAtDecodesByAbsoluteAddress) { + const uint16_t registers[] = {0x1111, 0x2222, 0x3333}; + const std::span span(registers, 3); + EXPECT_EQ(value_at(span, 100, 100), std::optional(0x1111)); + EXPECT_EQ(value_at(span, 100, 102), std::optional(0x3333)); + EXPECT_EQ(value_at(span, 100, 101), std::optional(0x22223333u)); + // Types whose RegisterValueType<> is not an unsigned integer, and the widest bounds check. + const uint16_t floats[] = {0x4048, 0xF5C3, 0xF5C3, 0x4048}; + const std::span float_span(floats, 4); + EXPECT_FLOAT_EQ(value_at(float_span, 10, 10).value_or(0.0f), 3.14f); + EXPECT_FLOAT_EQ(value_at(float_span, 10, 12).value_or(0.0f), 3.14f); + EXPECT_EQ(value_at(float_span, 10, 10), std::optional(0x4048F5C3F5C34048ULL)); + EXPECT_FALSE(value_at(float_span, 10, 11).has_value()); +} + +TEST(ModbusHelpersTest, ValueAtIsUsableInAConstantExpression) { + static constexpr uint16_t REGISTERS[] = {0x1234, 0x5678}; + static_assert(value_at(REGISTERS, 7, 7).value_or(0) == 0x12345678u); + static_assert(!value_at(REGISTERS, 7, 6).has_value()); +} + +TEST(ModbusHelpersTest, ValueAtRejectsAddressesOutsideTheResponse) { + const uint16_t registers[] = {0x1111, 0x2222, 0x3333}; + const std::span span(registers, 3); + // Below the response: must not wrap when the subtraction would go negative. + EXPECT_FALSE(value_at(span, 100, 99).has_value()); + EXPECT_FALSE(value_at(span, 100, 0).has_value()); + // Past the end, and a multi-register value truncated by the end of the response. + EXPECT_FALSE(value_at(span, 100, 103).has_value()); + EXPECT_FALSE(value_at(span, 100, 102).has_value()); + EXPECT_TRUE(value_at(span, 100, 101).has_value()); +} + +TEST(ModbusHelpersTest, ValueAtHandlesAnEmptyResponse) { + EXPECT_FALSE(value_at(std::span(), 0, 0).has_value()); +} + +// --- QWORD decoding --------------------------------------------------------- + +TEST(ModbusHelpersTest, RegistersToValueDecodesQwordBothWordOrders) { + const uint16_t registers[] = {0x0123, 0x4567, 0x89AB, 0xCDEF}; + EXPECT_EQ(registers_to_value(registers), 0x0123456789ABCDEFULL); + const uint16_t reversed[] = {0xCDEF, 0x89AB, 0x4567, 0x0123}; + EXPECT_EQ(registers_to_value(reversed), 0x0123456789ABCDEFULL); + // Signed reading of the same bits, and the sign-extreme case. + EXPECT_EQ(registers_to_value(registers), 0x0123456789ABCDEFLL); + const uint16_t negative[] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE}; + EXPECT_EQ(registers_to_value(negative), -2); + EXPECT_EQ(registers_to_value(negative), 0xFFFFFFFFFFFFFFFEULL); +} + +TEST(ModbusHelpersTest, RegistersToUint64CombinesWordsHighFirst) { + EXPECT_EQ(registers_to_uint64(0x0123, 0x4567, 0x89AB, 0xCDEF), 0x0123456789ABCDEFULL); +} + // --- packed bit helpers ------------------------------------------------------ TEST(ModbusHelpersTest, PackBitsAppendsToContainer) { @@ -483,6 +610,28 @@ TEST(ModbusTypedBuilders, WriteRegistersPduRejectsOverLimit) { EXPECT_FALSE(create_write_registers_pdu(0x0000, values).empty()); } +TEST(ModbusTypedBuilders, WriteFewRegistersPduMatchesFullSizeBuilder) { + static_assert(sizeof(WriteFewRegistersPdu) < sizeof(PduBuffer) / 4, + "WriteFewRegistersPdu must be meaningfully smaller"); + const uint16_t values[] = {0x000B, 0x0016, 0xABCD, 0xFF00}; + for (size_t count = 1; count <= MAX_FEW_REGISTERS; count++) { + auto small = create_write_few_registers_pdu(0x0102, std::span(values, count)); + auto full = create_write_registers_pdu(0x0102, std::span(values, count)); + EXPECT_EQ(std::vector(small.begin(), small.end()), std::vector(full.begin(), full.end())) + << count << " registers"; + EXPECT_EQ(small.size(), 6u + 2 * count); + EXPECT_TRUE(is_client_pdu_standard(small.data(), small.size())); + } +} + +TEST(ModbusTypedBuilders, WriteFewRegistersPduRejectsInvalidInput) { + const uint16_t values[MAX_FEW_REGISTERS + 1] = {0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA}; + EXPECT_TRUE(create_write_few_registers_pdu(0x0000, values).empty()); + EXPECT_FALSE(create_write_few_registers_pdu(0x0000, std::span(values, MAX_FEW_REGISTERS)).empty()); + EXPECT_TRUE(create_write_few_registers_pdu(0x0000, std::span()).empty()); + EXPECT_TRUE(create_write_few_registers_pdu(0xFFFF, std::span(values, 2)).empty()); +} + TEST(ModbusTypedBuilders, ReadWriteMultipleRegistersPduWireBytes) { const uint16_t write_values[] = {0x000B, 0x0016}; // Read 2 registers at 0x0010, write 2 registers at 0x0020. diff --git a/tests/components/modbus/modbus_unknown_function_test.cpp b/tests/components/modbus/modbus_unknown_function_test.cpp index 8b91d088b8..33f0cd24df 100644 --- a/tests/components/modbus/modbus_unknown_function_test.cpp +++ b/tests/components/modbus/modbus_unknown_function_test.cpp @@ -54,7 +54,8 @@ class TestServerHub : public ModbusServerHub { // The frame-length parsers have explicit cases for exactly these 13 codes; every other value - the // assigned-but-unimplemented management codes, both user-defined ranges, and all unassigned codes - -// must classify as unknown length. The exception flag masks off first. +// must classify as unknown length. Exception replies are always the 2-byte spec shape, so every +// 0x80-set code is known length. TEST(ModbusUnknownFunction, HelperMatchesParserCoverage) { for (uint8_t fc : {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x0F, 0x10, 0x14, 0x15, 0x16, 0x17, 0x18}) { EXPECT_FALSE(helpers::is_function_code_unknown_length(fc)) << "fc 0x" << std::hex << int(fc); @@ -62,11 +63,13 @@ TEST(ModbusUnknownFunction, HelperMatchesParserCoverage) { for (uint8_t fc : {0x07, 0x08, 0x0B, 0x0C, 0x11, 0x2A, 0x41, 0x48, 0x49, 0x64, 0x6E, 0x00, 0x7F}) { EXPECT_TRUE(helpers::is_function_code_unknown_length(fc)) << "fc 0x" << std::hex << int(fc); } - // Exception replies classify by their base code. + // Every exception-flagged code is known length (the 2-byte spec exception shape), whatever its base. EXPECT_FALSE(helpers::is_function_code_unknown_length(0x83)); - EXPECT_TRUE(helpers::is_function_code_unknown_length(0x87)); - // Strictly wider than the user-defined ranges: every custom code is unknown-length, but not vice versa. - for (int fc = 0; fc <= 0xFF; fc++) { + EXPECT_FALSE(helpers::is_function_code_unknown_length(0x87)); + EXPECT_FALSE(helpers::is_function_code_unknown_length(0xC9)); + // Strictly wider than the user-defined ranges below 0x80: every non-exception custom code is + // unknown-length, but not vice versa. + for (int fc = 0; fc <= 0x7F; fc++) { if (helpers::is_function_code_custom(fc)) EXPECT_TRUE(helpers::is_function_code_unknown_length(fc)) << "fc 0x" << std::hex << fc; } @@ -75,10 +78,10 @@ TEST(ModbusUnknownFunction, HelperMatchesParserCoverage) { // Derived contract check: the helper must say "unknown" exactly when both length parsers fall // through to default. With a zero-filled max-size PDU every explicit case returns at least 2 // (file records bottom out at 2, FIFO at 3) and only default returns MIN_PDU_SIZE, so comparing - // against MIN_PDU_SIZE detects a case added to either switch without updating the helper. The - // loop stops at 0x7F: above it the helper masks the exception flag off while client_pdu_length() - // switches on the unmasked byte and server_pdu_length() early-returns the exception length. - for (int fc = 0; fc <= 0x7F; fc++) { + // against MIN_PDU_SIZE detects a case added to either switch without updating the helper. Both + // parsers early-return the 2-byte exception shape above 0x7F, which the helper's own exception + // early-return mirrors, so the whole byte range is covered. + for (int fc = 0; fc <= 0xFF; fc++) { const uint8_t pdu[MAX_PDU_SIZE] = {static_cast(fc)}; // zero header fields EXPECT_EQ(helpers::is_function_code_unknown_length(fc), helpers::client_pdu_length(pdu, sizeof(pdu)) == MIN_PDU_SIZE) @@ -89,6 +92,17 @@ TEST(ModbusUnknownFunction, HelperMatchesParserCoverage) { } } +// Broadcastable = writes plus unknown codes (possible vendor writes); everything known to expect a +// reply is not. Classifies the underlying code: the exception bit masks off first (0x85 as 0x05). +TEST(ModbusUnknownFunction, BroadcastableClassification) { + for (uint8_t fc : {0x05, 0x06, 0x0F, 0x10, 0x16, 0x49, 0x63, 0x6E, 0x85, 0xC9}) { + EXPECT_TRUE(helpers::is_function_code_broadcastable(fc)) << "fc 0x" << std::hex << int(fc); + } + for (uint8_t fc : {0x01, 0x02, 0x03, 0x04, 0x14, 0x15, 0x17, 0x18, 0x83, 0x97}) { + EXPECT_FALSE(helpers::is_function_code_broadcastable(fc)) << "fc 0x" << std::hex << int(fc); + } +} + // A response with a function code outside the user-defined ranges (0x49) has no length case in // server_pdu_length(), so the parser must find the frame end by CRC scan - the same way it already // handles user-defined codes. Frame: address + FC 0x49 + 3 data bytes + CRC = 7 bytes. Without the diff --git a/tests/components/modbus_controller/command_payload_test.cpp b/tests/components/modbus_controller/command_payload_test.cpp index a0a59f5106..b9a1930ed0 100644 --- a/tests/components/modbus_controller/command_payload_test.cpp +++ b/tests/components/modbus_controller/command_payload_test.cpp @@ -5,6 +5,11 @@ #include "esphome/components/modbus_controller/modbus_controller.h" +// These tests pin the behaviour of the deprecated ModbusCommandItem until its removal. +// Remove with ModbusCommandItem before 2027.3.0. +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + namespace esphome::modbus_controller::testing { // The coil write factory packs into an exact-size payload. Pinned at one past the protocol maximum @@ -29,3 +34,5 @@ TEST(ModbusCommandPayload, CoilWritePacksLsbFirstWithZeroPad) { } } // namespace esphome::modbus_controller::testing + +#pragma GCC diagnostic pop diff --git a/tests/components/modbus_controller/common.yaml b/tests/components/modbus_controller/common.yaml index 78bec522cf..b9a7610cb7 100644 --- a/tests/components/modbus_controller/common.yaml +++ b/tests/components/modbus_controller/common.yaml @@ -21,6 +21,7 @@ binary_sensor: name: Test Binary Sensor with Lambda register_type: input address: 0x3201 + reuse_previous_range: false lambda: |- return x; @@ -85,6 +86,7 @@ select: name: Test Select with Lambda address: 1001 value_type: U_WORD + reuse_previous_range: auto optionsmap: "Off": 0 "On": 1 @@ -140,9 +142,10 @@ sensor: register_type: holding address: 0x9002 value_type: U_WORD + reuse_previous_range: true lambda: |- return x / 10.0; - # Non-mergeable sensor sharing the start address of modbus_sensor1 (different register_count): + # Non-mergeable sensor sharing the start address of modbus_sensor1 (different value type width): # must join the same range, never open a second range keyed on the same (address, type). - platform: modbus_controller modbus_controller_id: modbus_controller1 @@ -187,8 +190,8 @@ sensor: value_type: U_WORD lambda: |- return modbus_controller::get_data(data, item->offset) * 0.1f; - # force_new_range sensors sort before plain ones, so this high-address forced sensor is grouped - # first and the lower-address plain sensors above must still get their own ranges. + # The deprecated force_new_range migrates to reuse_previous_range: false, so this sensor never + # joins a range built before it and the lower-address sensors above keep their own ranges. - platform: modbus_controller modbus_controller_id: modbus_controller1 id: modbus_sensor_forced_high @@ -224,7 +227,6 @@ text_sensor: name: Test Text Sensor register_type: holding address: 0x9013 - register_count: 3 raw_encode: HEXBYTES response_size: 6 - platform: modbus_controller @@ -233,12 +235,13 @@ text_sensor: name: Test Text Sensor with Lambda register_type: holding address: 0x9014 - register_count: 2 response_size: 4 lambda: |- return "Modified: " + x; - # A register reporting FEWER bytes than 2*register_count (response_size: 3 for 2 registers), followed - # by a contiguous sensor: the follower's byte position must track the actual 3 bytes, not underflow. + # A register reporting FEWER bytes than two per register (response_size: 3 over 2 registers), followed + # by a contiguous reuse:true sensor (auto never joins past a response_size register): the follower's + # byte position must track the actual 3 bytes, not underflow. + # register_count matches the derived width, so it migrates with a deprecation warning. - platform: modbus_controller modbus_controller_id: modbus_controller1 id: modbus_text_sensor_narrow @@ -255,4 +258,5 @@ text_sensor: register_type: holding address: 0x9032 register_count: 1 + reuse_previous_range: true raw_encode: HEXBYTES diff --git a/tests/components/online_image/common.yaml b/tests/components/online_image/common.yaml index 85901287c7..d8d04850cf 100644 --- a/tests/components/online_image/common.yaml +++ b/tests/components/online_image/common.yaml @@ -62,6 +62,12 @@ image: url: http://www.faqs.org/images/library.jpg format: AUTO type: RGB565 + - platform: online_image + id: online_qoi_image + url: https://www.example.org/image.qoi + format: QOI + type: RGB + transparency: alpha_channel # Check the set_url action esphome: diff --git a/tests/components/ota/encryption.yaml b/tests/components/ota/encryption.yaml new file mode 100644 index 0000000000..550d35caec --- /dev/null +++ b/tests/components/ota/encryption.yaml @@ -0,0 +1,9 @@ +wifi: + ssid: MySSID + password: password1 + +ota: + - platform: esphome + port: 3288 + encryption: + key: "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" diff --git a/tests/components/ota/encryption_inherit.yaml b/tests/components/ota/encryption_inherit.yaml new file mode 100644 index 0000000000..15ada6f810 --- /dev/null +++ b/tests/components/ota/encryption_inherit.yaml @@ -0,0 +1,12 @@ +wifi: + ssid: MySSID + password: password1 + +api: + encryption: + key: "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" + +ota: + - platform: esphome + port: 3289 + encryption: diff --git a/tests/components/ota/test-encryption.esp32-idf.yaml b/tests/components/ota/test-encryption.esp32-idf.yaml new file mode 100644 index 0000000000..000e38168e --- /dev/null +++ b/tests/components/ota/test-encryption.esp32-idf.yaml @@ -0,0 +1,2 @@ +packages: + ota: !include encryption.yaml diff --git a/tests/components/ota/test-encryption.esp8266-ard.yaml b/tests/components/ota/test-encryption.esp8266-ard.yaml new file mode 100644 index 0000000000..000e38168e --- /dev/null +++ b/tests/components/ota/test-encryption.esp8266-ard.yaml @@ -0,0 +1,2 @@ +packages: + ota: !include encryption.yaml diff --git a/tests/components/ota/test-encryption.rp2040-ard.yaml b/tests/components/ota/test-encryption.rp2040-ard.yaml new file mode 100644 index 0000000000..000e38168e --- /dev/null +++ b/tests/components/ota/test-encryption.rp2040-ard.yaml @@ -0,0 +1,2 @@ +packages: + ota: !include encryption.yaml diff --git a/tests/components/ota/test-encryption_inherit.esp8266-ard.yaml b/tests/components/ota/test-encryption_inherit.esp8266-ard.yaml new file mode 100644 index 0000000000..71aa083e7e --- /dev/null +++ b/tests/components/ota/test-encryption_inherit.esp8266-ard.yaml @@ -0,0 +1,2 @@ +packages: + ota: !include encryption_inherit.yaml diff --git a/tests/components/provisioning/test.esp32-idf.yaml b/tests/components/provisioning/test.esp32-idf.yaml index 24168881fc..baa3aa8f68 100644 --- a/tests/components/provisioning/test.esp32-idf.yaml +++ b/tests/components/provisioning/test.esp32-idf.yaml @@ -1,6 +1,7 @@ # Exercises the provisioning window: api registers as a provisioning source -# (encryption enabled, no key), the on_timeout automation, and the wifi + -# esp32_improv cross-component guards. improv_serial is intentionally NOT gated. +# (encryption enabled, no key), the on_timeout automation, and the wifi (AP + +# captive portal) and esp32_improv cross-component guards. improv_serial is +# intentionally NOT gated. provisioning: timeout: 1min on_timeout: @@ -13,6 +14,10 @@ api: wifi: ssid: MySSID password: password1 + ap: + ssid: MyAP + +captive_portal: improv_serial: diff --git a/tests/components/provisioning/test.esp8266-ard.yaml b/tests/components/provisioning/test.esp8266-ard.yaml index 4188c00bef..2666477658 100644 --- a/tests/components/provisioning/test.esp8266-ard.yaml +++ b/tests/components/provisioning/test.esp8266-ard.yaml @@ -1,5 +1,6 @@ # Provisioning window on ESP8266 (no BLE Improv): api as a provisioning source -# and the wifi reboot guard. improv_serial is present and intentionally NOT gated. +# and the wifi (AP + captive portal) guards. improv_serial is present and +# intentionally NOT gated. provisioning: timeout: 1min on_timeout: @@ -12,5 +13,9 @@ api: wifi: ssid: MySSID password: password1 + ap: + ssid: MyAP + +captive_portal: improv_serial: diff --git a/tests/components/runtime_image/__init__.py b/tests/components/runtime_image/__init__.py index a8ff4bb68e..041db39128 100644 --- a/tests/components/runtime_image/__init__.py +++ b/tests/components/runtime_image/__init__.py @@ -9,7 +9,8 @@ def override_manifest(manifest: ComponentManifestOverride) -> None: # tests have two decoder types and every retained decoder is under test. async def to_code_testing(config: ConfigType) -> None: enable_format("BMP") - enable_format("PNG") enable_format("JPEG") + enable_format("PNG") + enable_format("QOI") manifest.to_code = to_code_testing diff --git a/tests/components/runtime_image/test_decoder_reuse.cpp b/tests/components/runtime_image/test_decoder_reuse.cpp index 9c2d00b747..e62e2a98d9 100644 --- a/tests/components/runtime_image/test_decoder_reuse.cpp +++ b/tests/components/runtime_image/test_decoder_reuse.cpp @@ -70,11 +70,36 @@ static const uint8_t PNG_RGB_EXPECTED[4][4][3] = { {{0x12, 0x34, 0x56}, {0x65, 0x43, 0x21}, {0xFE, 0xDC, 0xBA}, {0xAB, 0xCD, 0xEF}}, }; +// 3x3 QOI, exercising all possible chunk types +static const uint8_t QOI_RGBA[] = { + 0x71, 0x6F, 0x69, 0x66, // Header: 'qoif' + 0x00, 0x00, 0x00, 0x03, // Width: 3 + 0x00, 0x00, 0x00, 0x03, // Height: 3 + 0x04, // Channels: 4 (RGBA) + 0x00, // Colorspace: 0 (SRGB) + 0xC1, // 1. QOI_OP_RUN + 0x79, // 2. QOI_OP_DIFF + 0xAA, 0x79, // 3. QOI_OP_LUMA + 0xFE, 0xC8, 0x64, 0x32, // 4. QOI_OP_RGB + 0xFF, 0x78, 0x50, 0x28, + 0x64, // 5. QOI_OP_RGBA + 0x31, // 6. QOI_OP_INDEX + 0xC1, // 7. QOI_OP_RUN + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 // End Marker +}; + +static const uint8_t QOI_EXPECTED_RGBA[3][3][4] = { + {{0x00, 0x00, 0x00, 0xFF}, {0x00, 0x00, 0x00, 0xFF}, {0x01, 0x00, 0xFF, 0xFF}}, + {{0x0A, 0x0A, 0x0A, 0xFF}, {0xC8, 0x64, 0x32, 0xFF}, {0x78, 0x50, 0x28, 0x64}}, + {{0x01, 0x00, 0xFF, 0xFF}, {0x01, 0x00, 0xFF, 0xFF}, {0x01, 0x00, 0xFF, 0xFF}} + +}; + /// Exposes the protected decoder machinery so reuse and eviction can be observed directly. class TestableRuntimeImage : public RuntimeImage { public: - explicit TestableRuntimeImage(ImageFormat format) - : RuntimeImage(format, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE, nullptr, false, 0, 0) {} + explicit TestableRuntimeImage(ImageFormat format, image::Transparency transparency = image::TRANSPARENCY_OPAQUE) + : RuntimeImage(format, image::IMAGE_TYPE_RGB, transparency, nullptr, false, 0, 0) {} ImageDecoder *decoder() { return this->decoder_.get(); } }; @@ -132,6 +157,19 @@ template static void expect_pixels(TestableRuntimeImage &img } } +template +static void expect_pixels_rgba(TestableRuntimeImage &img, const uint8_t (&expected)[H][W][4]) { + ASSERT_EQ(img.get_width(), static_cast(W)); + ASSERT_EQ(img.get_height(), static_cast(H)); + for (size_t y = 0; y < H; y++) { + for (size_t x = 0; x < W; x++) { + SCOPED_TRACE(::testing::Message() << "pixel (" << x << "," << y << ")"); + Color color = img.get_pixel(x, y); + EXPECT_THAT((std::array{color.r, color.g, color.b, color.w}), + ::testing::ElementsAreArray(expected[y][x])); + } + } +} TEST(RuntimeImageDecoder, DecoderStaysWarmAcrossDecodes) { TestableRuntimeImage img(BMP); @@ -337,6 +375,33 @@ TEST(RuntimeImageDecoder, JpegDecoderStaysWarmAcrossDecodes) { } #endif // USE_RUNTIME_IMAGE_JPEG +TEST(RuntimeImageDecoder, QoiDecoderStaysWarmAcrossDecodes) { + TestableRuntimeImage img(QOI, image::TRANSPARENCY_ALPHA_CHANNEL); + + ASSERT_TRUE(decode_all(img, QOI_RGBA, sizeof(QOI_RGBA))); + expect_pixels_rgba(img, QOI_EXPECTED_RGBA); + ImageDecoder *first = img.decoder(); + ASSERT_NE(first, nullptr); + + ASSERT_TRUE(decode_all(img, QOI_RGBA, sizeof(QOI_RGBA))); + expect_pixels_rgba(img, QOI_EXPECTED_RGBA); + EXPECT_EQ(img.decoder(), first) << "decoder must be reused, not reallocated"; +} + +TEST(RuntimeImageDecoder, QoiChunkedFeedDecodesLikeDownloadLoop) { + TestableRuntimeImage img(QOI, image::TRANSPARENCY_ALPHA_CHANNEL); + + ASSERT_TRUE(decode_chunked(img, QOI_RGBA, sizeof(QOI_RGBA), 10)); + expect_pixels_rgba(img, QOI_EXPECTED_RGBA); + ImageDecoder *first = img.decoder(); + + // Chunked again on the warm decoder: the cross-call resume state + // (current_index_ / paint_index_) must have been fully reset. + ASSERT_TRUE(decode_chunked(img, QOI_RGBA, sizeof(QOI_RGBA), 10)); + expect_pixels_rgba(img, QOI_EXPECTED_RGBA); + EXPECT_EQ(img.decoder(), first); +} + TEST(RuntimeImageDecoder, SessionFlagsTrackLifecycle) { TestableRuntimeImage img(BMP); std::vector buffer(BMP_24BPP, BMP_24BPP + sizeof(BMP_24BPP)); diff --git a/tests/components/runtime_image/test_mime_types.cpp b/tests/components/runtime_image/test_mime_types.cpp index de8bbc76be..22b825cff0 100644 --- a/tests/components/runtime_image/test_mime_types.cpp +++ b/tests/components/runtime_image/test_mime_types.cpp @@ -10,12 +10,14 @@ TEST(RuntimeImageMime, FormatForKnownMimeTypes) { EXPECT_EQ(get_format_for_mime_type("image/bmp"), BMP); EXPECT_EQ(get_format_for_mime_type("image/x-ms-bmp"), BMP); EXPECT_EQ(get_format_for_mime_type("image/x-bmp"), BMP); - EXPECT_EQ(get_format_for_mime_type("image/png"), PNG); - EXPECT_EQ(get_format_for_mime_type("image/x-png"), PNG); #ifdef USE_RUNTIME_IMAGE_JPEG EXPECT_EQ(get_format_for_mime_type("image/jpeg"), JPEG); EXPECT_EQ(get_format_for_mime_type("image/jpg"), JPEG); #endif // USE_RUNTIME_IMAGE_JPEG + EXPECT_EQ(get_format_for_mime_type("image/png"), PNG); + EXPECT_EQ(get_format_for_mime_type("image/x-png"), PNG); + EXPECT_EQ(get_format_for_mime_type("image/qoi"), QOI); + EXPECT_EQ(get_format_for_mime_type("image/x-qoi"), QOI); } TEST(RuntimeImageMime, FormatMatchingIsCaseInsensitive) { @@ -39,20 +41,22 @@ TEST(RuntimeImageMime, UnknownMimeTypeHasNoFormat) { TEST(RuntimeImageMime, MimeTypeForFormatRoundTrip) { EXPECT_STREQ(get_mime_type_for_format(BMP), "image/bmp"); - EXPECT_STREQ(get_mime_type_for_format(PNG), "image/png"); #ifdef USE_RUNTIME_IMAGE_JPEG EXPECT_STREQ(get_mime_type_for_format(JPEG), "image/jpeg"); #endif // USE_RUNTIME_IMAGE_JPEG + EXPECT_STREQ(get_mime_type_for_format(PNG), "image/png"); + EXPECT_STREQ(get_mime_type_for_format(QOI), "image/qoi"); // AUTO has no single MIME type and falls back to the wildcard EXPECT_STREQ(get_mime_type_for_format(AUTO), "image/*"); // Every decodable format must resolve back to itself through its MIME type for (ImageFormat format : { BMP, - PNG, #ifdef USE_RUNTIME_IMAGE_JPEG JPEG, #endif // USE_RUNTIME_IMAGE_JPEG + PNG, + QOI, }) { EXPECT_EQ(get_format_for_mime_type(get_mime_type_for_format(format)), format) << format; } diff --git a/tests/components/sen6x/common.yaml b/tests/components/sen6x/common.yaml index 859e012c4a..c9b6f22c0f 100644 --- a/tests/components/sen6x/common.yaml +++ b/tests/components/sen6x/common.yaml @@ -28,8 +28,21 @@ sensor: accuracy_decimals: 1 nox_index: name: NOx Index + algorithm_tuning: + index_offset: 8 + learning_time_offset_hours: 6 + learning_time_gain_hours: 24 + gating_max_duration_minutes: 900 + gain_factor: 180 voc_index: name: VOC Index + algorithm_tuning: + index_offset: 120 + learning_time_offset_hours: 6 + learning_time_gain_hours: 24 + gating_max_duration_minutes: 240 + std_initial: 75 + gain_factor: 180 co2: name: Carbon Dioxide formaldehyde: diff --git a/tests/components/sen6x/validate.esp32-idf.yaml b/tests/components/sen6x/validate.esp32-idf.yaml new file mode 100644 index 0000000000..3ae23af4ac --- /dev/null +++ b/tests/components/sen6x/validate.esp32-idf.yaml @@ -0,0 +1,18 @@ +# Config-only: partial algorithm_tuning blocks, so the schema defaults fill in the +# keys that are left out. +packages: + i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml + +sensor: + - platform: sen6x + id: sen6x_partial_tuning + type: SEN65 + i2c_id: i2c_bus + voc_index: + name: VOC Index + algorithm_tuning: + index_offset: 60 + nox_index: + name: NOx Index + algorithm_tuning: + gain_factor: 45 diff --git a/tests/components/spi_device/test.esp32-s3-idf.yaml b/tests/components/spi_device/test.esp32-s3-idf.yaml new file mode 100644 index 0000000000..41dc178c19 --- /dev/null +++ b/tests/components/spi_device/test.esp32-s3-idf.yaml @@ -0,0 +1,10 @@ +packages: + spi: !include ../../test_build_components/common/spi/esp32-s3-idf.yaml + common: !include common.yaml +psram: + mode: octal +spi_device: + - id: spi_device_psram_dma_test + psram_dma: true + data_rate: 1MHz + spi_mode: 0 diff --git a/tests/components/tuya/common.yaml b/tests/components/tuya/common.yaml index 9986d398f1..f52d47e7a0 100644 --- a/tests/components/tuya/common.yaml +++ b/tests/components/tuya/common.yaml @@ -80,3 +80,24 @@ switch: - platform: tuya id: tuya_switch switch_datapoint: 1 + +water_heater: + - platform: tuya + id: tuya_water_heater + name: Tuya Water Heater + switch_datapoint: 1 + current_temperature_datapoint: 3 + target_temperature_datapoint: 2 + current_temperature_multiplier: 0.5 + target_temperature_multiplier: 0.5 + mode_datapoint: 4 + eco_value: 0 + electric_value: 2 + supported_modes: + - "OFF" + - ECO + - ELECTRIC + visual: + min_temperature: 30 + max_temperature: 75 + target_temperature_step: 1 diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py index 483d5392af..6777e6cabc 100644 --- a/tests/integration/conftest.py +++ b/tests/integration/conftest.py @@ -23,6 +23,7 @@ import pytest_asyncio import esphome.config from esphome.core import CORE +from esphome.helpers import get_usable_cpu_count from esphome.platformio.toolchain import get_idedata from .const import ( @@ -67,6 +68,14 @@ def _get_platformio_env(cache_dir: Path) -> dict[str, str]: env["PLATFORMIO_LIBDEPS_DIR"] = str(cache_dir / "libdeps" / worker) # Prevent cache cleaning during integration tests env["ESPHOME_SKIP_CLEAN_BUILD"] = "1" + # Cap each compile's -j so several xdist workers do not each spawn a + # full-width compiler fan-out on the same machine. An explicit env wins. + if "ESPHOME_DEFAULT_COMPILE_PROCESS_LIMIT" not in os.environ: + workers = int(os.environ.get("PYTEST_XDIST_WORKER_COUNT", "1")) + # Floor of 2 keeps a lone tail compile from running fully serial + env["ESPHOME_DEFAULT_COMPILE_PROCESS_LIMIT"] = str( + max(2, get_usable_cpu_count() // workers) + ) # Compile with THIS tree's esphome sources, not wherever the venv's editable # install points (which may be a different git worktree or checkout). repo_root = str(Path(__file__).resolve().parent.parent.parent) @@ -78,7 +87,8 @@ def _get_platformio_env(cache_dir: Path) -> dict[str, str]: @pytest.fixture(scope="session") def shared_platformio_cache() -> Generator[Path]: """Initialize a shared PlatformIO cache for all integration tests.""" - # Use a dedicated directory for integration tests to avoid conflicts + # Use a dedicated directory for integration tests to avoid conflicts. + # CI caches parts of this path; keep in sync with ci.yml integration-tests. test_cache_dir = Path.home() / ".esphome-integration-tests" cache_dir = test_cache_dir / "platformio" diff --git a/tests/integration/fixtures/api_action_metadata.yaml b/tests/integration/fixtures/api_action_metadata.yaml new file mode 100644 index 0000000000..802b965110 --- /dev/null +++ b/tests/integration/fixtures/api_action_metadata.yaml @@ -0,0 +1,26 @@ +esphome: + name: api-action-metadata-test +host: +api: + batch_delay: 0ms + actions: + - action: play_buzzer + description: Play an RTTTL melody on the buzzer + variables: + song_str: + type: string + description: RTTTL melody string + example: "two_short:d=4,o=5,b=100:16e6,16e6" + volume: + type: int + then: + - logger.log: + format: "Buzzer: %s" + args: [song_str.c_str()] + - action: plain_action + variables: + value: int + then: + - logger.log: "Plain action called" + +logger: diff --git a/tests/integration/fixtures/api_homeassistant_binary_sensor_initial_state.yaml b/tests/integration/fixtures/api_homeassistant_binary_sensor_initial_state.yaml new file mode 100644 index 0000000000..0e47a7f1fa --- /dev/null +++ b/tests/integration/fixtures/api_homeassistant_binary_sensor_initial_state.yaml @@ -0,0 +1,59 @@ +esphome: + name: ha-bs-initial + +host: + +api: + +logger: + level: DEBUG + +binary_sensor: + # trigger_on_initial_state: true must fire on_press for the first state from HA + - platform: homeassistant + name: Initial On + entity_id: binary_sensor.initial_on + trigger_on_initial_state: true + on_press: + - logger.log: "initial_on on_press" + on_release: + - logger.log: "initial_on on_release" + + # Default (false) must not fire on the first state, only on later changes + - platform: homeassistant + name: Default + entity_id: binary_sensor.default + on_press: + - logger.log: "default on_press" + on_release: + - logger.log: "default on_release" + + # Real HA startup shape: 'unavailable' arrives before the first real state + - platform: homeassistant + name: Unavailable First + entity_id: binary_sensor.unavailable_first + trigger_on_initial_state: true + on_press: + - logger.log: "unavailable_first on_press" + on_release: + - logger.log: "unavailable_first on_release" + + # Initial 'off' must fire on_release when trigger_on_initial_state is set + - platform: homeassistant + name: Initial Off + entity_id: binary_sensor.initial_off + trigger_on_initial_state: true + on_press: + - logger.log: "initial_off on_press" + on_release: + - logger.log: "initial_off on_release" + + # Same 'unavailable' first shape without the flag; must stay quiet on the + # first real state and only fire on the later change + - platform: homeassistant + name: Default Unavailable First + entity_id: binary_sensor.default_unavail + on_press: + - logger.log: "default_unavail on_press" + on_release: + - logger.log: "default_unavail on_release" diff --git a/tests/integration/fixtures/external_components/wifi/__init__.py b/tests/integration/fixtures/external_components/wifi/__init__.py new file mode 100644 index 0000000000..109d56b035 --- /dev/null +++ b/tests/integration/fixtures/external_components/wifi/__init__.py @@ -0,0 +1,39 @@ +"""Host-only stub of the wifi component for integration tests. + +HOST-ONLY TEST COMPONENT: this shadows the real wifi component for EVERY +fixture that uses the shared external_components directory. Any host fixture +with a wifi block gets this stub, not the real component: fixed scan results, +is_connected() hardwired true, and save_wifi_sta that only logs. See +wifi_component.h for the full behavior. +""" + +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.const import CONF_ID, CONF_PASSWORD, CONF_SSID, CONF_USE_ADDRESS +from esphome.types import ConfigType + +CODEOWNERS = ["@esphome/tests"] + +wifi_ns = cg.esphome_ns.namespace("wifi") +WiFiComponent = wifi_ns.class_("WiFiComponent", cg.Component) + +CONFIG_SCHEMA = cv.Schema( + { + cv.GenerateID(): cv.declare_id(WiFiComponent), + # Accepted for fixture realism; the stub ignores them + cv.Optional(CONF_SSID): cv.string, + cv.Optional(CONF_PASSWORD): cv.string, + # Read by StorageJSON via CORE.address whenever a wifi block exists + cv.Optional(CONF_USE_ADDRESS, default="localhost"): cv.string, + } +).extend(cv.COMPONENT_SCHEMA) + + +def check_placeholder_credentials(config: ConfigType) -> None: + """Compile-time hook the esphome CLI imports from the wifi module; no-op here.""" + + +async def to_code(config: ConfigType) -> None: + var = cg.new_Pvariable(config[CONF_ID]) + await cg.register_component(var, config) + cg.add_define("USE_WIFI") diff --git a/tests/integration/fixtures/external_components/wifi/scan_list.h b/tests/integration/fixtures/external_components/wifi/scan_list.h new file mode 120000 index 0000000000..fdef6e0be1 --- /dev/null +++ b/tests/integration/fixtures/external_components/wifi/scan_list.h @@ -0,0 +1 @@ +../../../../../esphome/components/wifi/scan_list.h \ No newline at end of file diff --git a/tests/integration/fixtures/external_components/wifi/wifi_component.cpp b/tests/integration/fixtures/external_components/wifi/wifi_component.cpp new file mode 100644 index 0000000000..b29b1a2bd1 --- /dev/null +++ b/tests/integration/fixtures/external_components/wifi/wifi_component.cpp @@ -0,0 +1,42 @@ +#include "wifi_component.h" + +#include "esphome/core/log.h" + +namespace esphome::wifi { + +static const char *const TAG = "wifi_stub"; + +WiFiComponent *global_wifi_component = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) + +WiFiComponent::WiFiComponent() { global_wifi_component = this; } + +void WiFiComponent::setup() { ESP_LOGI(TAG, "Stub wifi ready"); } + +void WiFiComponent::dump_config() { ESP_LOGCONFIG(TAG, "Stub wifi"); } + +void WiFiComponent::start_scanning() { + // Duplicate TestNet entry (weaker) and a hidden entry exercise the + // should_show_scan_entry dedup and filtering logic + this->scan_result_.clear(); + this->scan_result_.emplace_back("TestNet", -50, true, false); + this->scan_result_.emplace_back("TestNet", -60, true, false); + this->scan_result_.emplace_back("OpenNet", -70, false, false); + this->scan_result_.emplace_back("", -40, false, true); + ESP_LOGI(TAG, "Scan complete with %zu results", this->scan_result_.size()); +} + +void WiFiComponent::set_sta(const WiFiAP &ap) { ESP_LOGI(TAG, "set_sta ssid=%s", ap.get_ssid().c_str()); } + +void WiFiComponent::start_connecting(const WiFiAP &ap) { + ESP_LOGI(TAG, "start_connecting ssid=%s", ap.get_ssid().c_str()); + // Connecting succeeds immediately, so the requested network is the connected one + this->connected_ssid_ = ap.get_ssid().c_str(); +} + +void WiFiComponent::clear_sta() { ESP_LOGI(TAG, "clear_sta"); } + +void WiFiComponent::save_wifi_sta(StringRef ssid, StringRef password) { + ESP_LOGI(TAG, "save_wifi_sta ssid=%s password_len=%zu", ssid.c_str(), password.size()); +} + +} // namespace esphome::wifi diff --git a/tests/integration/fixtures/external_components/wifi/wifi_component.h b/tests/integration/fixtures/external_components/wifi/wifi_component.h new file mode 100644 index 0000000000..6fe6e84e9d --- /dev/null +++ b/tests/integration/fixtures/external_components/wifi/wifi_component.h @@ -0,0 +1,88 @@ +#pragma once + +// ============================================================================ +// HOST-ONLY TEST COMPONENT — DO NOT COPY TO PRODUCTION CODE +// +// Stub of the real wifi component with just enough API surface for +// improv_serial to build and run on the host platform. Scan results are +// fixed, "connecting" succeeds immediately, and save_wifi_sta only logs so +// tests can assert on the log output. +// ============================================================================ + +#include "esphome/components/network/ip_address.h" +#include "esphome/core/component.h" +#include "esphome/core/string_ref.h" + +#include +#include +#include +#include + +namespace esphome::wifi { + +static constexpr size_t SSID_BUFFER_SIZE = 33; + +class WiFiAP { + public: + void set_ssid(const char *ssid) { this->ssid_ = ssid; } + void set_password(const char *password) { this->password_ = password; } + StringRef get_ssid() const { return StringRef(this->ssid_); } + StringRef get_password() const { return StringRef(this->password_); } + + protected: + std::string ssid_; + std::string password_; +}; + +class WiFiScanResult { + public: + WiFiScanResult(const char *ssid, int8_t rssi, bool with_auth, bool hidden) + : ssid_(ssid), rssi_(rssi), with_auth_(with_auth), hidden_(hidden) {} + StringRef get_ssid() const { return StringRef(this->ssid_); } + int8_t get_rssi() const { return this->rssi_; } + bool get_with_auth() const { return this->with_auth_; } + bool get_is_hidden() const { return this->hidden_; } + bool ssid_equals(const WiFiScanResult &other) const { return this->ssid_ == other.ssid_; } + + protected: + std::string ssid_; + int8_t rssi_; + bool with_auth_; + bool hidden_; +}; + +class WiFiComponent : public Component { + public: + WiFiComponent(); + void setup() override; + void dump_config() override; + float get_setup_priority() const override { return setup_priority::WIFI; } + + bool has_sta() const { return false; } + bool is_disabled() const { return false; } + // Always connected so network::is_connected() keeps the API server accepting clients + bool is_connected() const { return true; } + // Reports the network start_connecting() was last asked for, so a consumer checking that it + // joined the network it requested (rather than an earlier one) sees the connect succeed + const char *wifi_ssid_to(std::span buffer) { + snprintf(buffer.data(), buffer.size(), "%s", this->connected_ssid_.c_str()); + return buffer.data(); + } + void start_scanning(); + const std::vector &get_scan_result() const { return this->scan_result_; } + void set_sta(const WiFiAP &ap); + void start_connecting(const WiFiAP &ap); + void clear_sta(); + void save_wifi_sta(StringRef ssid, StringRef password); + // Called by network::util on any USE_WIFI build + const char *get_use_address() const { return "localhost"; } + network::IPAddresses get_ip_addresses() { return {}; } + + protected: + std::vector scan_result_; + std::string connected_ssid_; +}; + +extern WiFiComponent *global_wifi_component; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) + +} // namespace esphome::wifi diff --git a/tests/integration/fixtures/host_ota_encrypted.yaml b/tests/integration/fixtures/host_ota_encrypted.yaml new file mode 100644 index 0000000000..0d11c99d3d --- /dev/null +++ b/tests/integration/fixtures/host_ota_encrypted.yaml @@ -0,0 +1,11 @@ +esphome: + name: host-ota-test +host: +api: +ota: + - platform: esphome + port: __OTA_PORT__ + encryption: + key: "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" +logger: + level: DEBUG diff --git a/tests/integration/fixtures/improv_serial_uart.yaml b/tests/integration/fixtures/improv_serial_uart.yaml new file mode 100644 index 0000000000..daa41c6a95 --- /dev/null +++ b/tests/integration/fixtures/improv_serial_uart.yaml @@ -0,0 +1,42 @@ +esphome: + # Short name keeps the device info payload under uart_mock's 64 byte log cap + name: improv-uart + +host: +api: + actions: + - action: uart_inject + variables: + payload: int[] + then: + - uart_mock.inject_rx: + id: mock_uart + data: !lambda return std::vector(payload.begin(), payload.end()); + +logger: + level: DEBUG + +external_components: + - source: + type: local + path: EXTERNAL_COMPONENT_PATH + +# Host-only stub shadowing the real wifi component (see external_components/wifi) +wifi: + ssid: TestNet + password: password1 + +# Dummy uart entry so the uart component sources are part of the build; the +# actual bus used by improv_serial is the uart_mock component below +uart: + baud_rate: 115200 + port: /dev/null + +uart_mock: + id: mock_uart + baud_rate: 115200 + +improv_serial: + uart_id: mock_uart + # Deterministic on host: only the device name placeholder is used + next_url: https://example.com/?device={{device_name}} diff --git a/tests/integration/fixtures/uart_mock_modbus_grouping.yaml b/tests/integration/fixtures/uart_mock_modbus_grouping.yaml index d580f5c2e2..2c4c39e7a5 100644 --- a/tests/integration/fixtures/uart_mock_modbus_grouping.yaml +++ b/tests/integration/fixtures/uart_mock_modbus_grouping.yaml @@ -27,8 +27,8 @@ uart_mock: # so these also pin the grouping: an extra or differently shaped read fails the test. - expect_tx: [0x01, 0x01, 0x00, 0x10, 0x00, 0x02, 0xBC, 0x0E] # coils 0x10 count 2 inject_rx: [0x01, 0x01, 0x01, 0x01, 0x90, 0x48] # bit0 set, bit1 clear - - expect_tx: [0x01, 0x03, 0x01, 0x60, 0x00, 0x01, 0x85, 0xE8] # holding 0x160 count 1 - inject_rx: [0x01, 0x03, 0x02, 0x01, 0x60, 0xB9, 0xFC] # 352 + - expect_tx: [0x01, 0x03, 0x01, 0x60, 0x00, 0x02, 0xC5, 0xE9] # holding 0x160 count 2 + inject_rx: [0x01, 0x03, 0x04, 0x01, 0x60, 0x01, 0x61, 0x3B, 0xA9] # 352, 353 - expect_tx: [0x01, 0x03, 0x01, 0x00, 0x00, 0x01, 0x85, 0xF6] # holding 0x100 count 1 inject_rx: [0x01, 0x03, 0x04, 0x01, 0x11, 0x02, 0x22, 0x2A, 0xB3] # 4 bytes: 273 then 546 - expect_tx: [0x01, 0x03, 0x01, 0x20, 0x00, 0x04, 0x44, 0x3F] # holding 0x120 count 4 @@ -49,8 +49,6 @@ uart_mock: inject_rx: [0x01, 0x03, 0x02, 0x33, 0x33, 0xEC, 0xA1] # 13107 - expect_tx: [0x01, 0x03, 0x01, 0x70, 0x00, 0x03, 0x05, 0xEC] # holding 0x170 count 3 inject_rx: [0x01, 0x03, 0x06, 0x00, 0x2A, 0x1B, 0x2C, 0x03, 0x0D, 0x3E, 0xAB] # 6 bytes - - expect_tx: [0x01, 0x03, 0x01, 0x61, 0x00, 0x01, 0xD4, 0x28] # holding 0x161 count 1 - inject_rx: [0x01, 0x03, 0x02, 0x01, 0x61, 0x78, 0x3C] # 353 modbus: uart_id: virtual_uart_dev @@ -104,8 +102,9 @@ sensor: value_type: U_DWORD modbus_controller_id: modbus_controller_ok - # D - a wide (response_size) register followed by a contiguous one: the follower must start after the - # bytes the wide register actually returned, not after 2 * register_count. + # D - a wide (response_size) register followed by a contiguous reuse:true one (auto never joins past + # a response_size register): the follower must start after the bytes the wide register actually + # returned, not after two per register. - platform: modbus_controller name: "wide_first" address: 0x130 @@ -118,6 +117,7 @@ sensor: address: 0x131 register_type: holding value_type: U_WORD + reuse_previous_range: true modbus_controller_id: modbus_controller_ok # E - a gap: these must never share a range. @@ -195,13 +195,14 @@ sensor: value_type: U_WORD modbus_controller_id: modbus_controller_ok - # H - a sensor pinned to its own range, followed by a contiguous one. + # H - a sensor that never joins the range built before it (reuse_previous_range: false), followed + # by a contiguous plain item that extends the new range it started. - platform: modbus_controller name: "forced_first" address: 0x160 register_type: holding value_type: U_WORD - force_new_range: true + reuse_previous_range: false modbus_controller_id: modbus_controller_ok - platform: modbus_controller name: "forced_next" diff --git a/tests/integration/fixtures/uart_mock_modbus_lambda_invert.yaml b/tests/integration/fixtures/uart_mock_modbus_lambda_invert.yaml new file mode 100644 index 0000000000..41afce70d6 --- /dev/null +++ b/tests/integration/fixtures/uart_mock_modbus_lambda_invert.yaml @@ -0,0 +1,95 @@ +esphome: + name: uart-mock-modbus-lambda-invert + +host: +api: +logger: + level: VERBOSE + +external_components: + - source: + type: local + path: EXTERNAL_COMPONENT_PATH + +# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"] +# The actual UART bus used is the uart_mock component below +uart: + baud_rate: 115200 + port: /dev/null + +uart_mock: + - id: virtual_uart_server + baud_rate: 9600 + auto_start: true + debug: + on_tx: + - then: + - uart_mock.inject_rx: + id: virtual_uart_controller + data: !lambda return data; + - id: virtual_uart_controller + baud_rate: 9600 + auto_start: true + debug: + on_tx: + - then: + - uart_mock.inject_rx: + id: virtual_uart_server + data: !lambda return data; + +globals: + - id: reg40 + type: uint16_t + initial_value: "5" + +modbus: + - uart_id: virtual_uart_server + id: virtual_modbus_server + role: server + - uart_id: virtual_uart_controller + id: virtual_modbus_controller + role: client + turnaround_time: 10ms + +modbus_controller: + - address: 1 + modbus_id: virtual_modbus_controller + id: modbus_controller_1 + update_interval: 1s + +modbus_server: + - address: 1 + modbus_id: virtual_modbus_server + id: modbus_server_1 + registers: + - address: 0x40 + value_type: U_WORD + read_lambda: return id(reg40); + write_lambda: id(reg40) = x; return true; + +# An active-low holding switch: the write_lambda inverts the wire value, but the entity must still +# report the REQUESTED state. assumed_state keeps the register unpolled, so the published state comes +# only from write_state() - turning ON writes 0x0000 yet the switch shows ON. +switch: + - platform: modbus_controller + modbus_controller_id: modbus_controller_1 + name: "invert_switch" + register_type: holding + address: 0x40 + assumed_state: true + write_lambda: |- + return !x; + +sensor: + - platform: modbus_controller + modbus_controller_id: modbus_controller_1 + name: "reg_40" + address: 0x40 + register_type: holding + value_type: U_WORD + +button: + - platform: template + name: "Start Scenario" + id: start_scenario_btn + # This test does not have anything to start (mock is autostart) diff --git a/tests/integration/fixtures/uart_mock_modbus_ranges.yaml b/tests/integration/fixtures/uart_mock_modbus_ranges.yaml new file mode 100644 index 0000000000..09e5a20241 --- /dev/null +++ b/tests/integration/fixtures/uart_mock_modbus_ranges.yaml @@ -0,0 +1,227 @@ +esphome: + name: uart-mock-modbus-ranges-test + +host: +api: +logger: + level: VERBOSE + +external_components: + - source: + type: local + path: EXTERNAL_COMPONENT_PATH + +# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"] +# The actual UART bus used is the uart_mock component below +uart: + baud_rate: 115200 + port: /dev/null + +# Each expect_tx below pins the exact read request the controller's range builder emits, so this +# fixture is a wire-level test of reuse_previous_range (auto/yes/no), gap joins, same-register reuse, +# response_size surplus accounting, and RAW/text block reads. +uart_mock: + - id: virtual_uart_dev + baud_rate: 9600 + rx_full_threshold: 120 + rx_timeout: 2 + # auto_start must be false to avoid races: the test presses the + # "Start Scenario" button only after subscribing to states. + auto_start: false + debug: + responses: + - expect_tx: [0x01, 0x03, 0x00, 0x00, 0x00, 0x03, 0x05, 0xCB] # auto adjacency: one read covers 0x00-0x02 + inject_rx: [0x01, 0x03, 0x06, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0xFD, 0x74] + - expect_tx: [0x01, 0x03, 0x00, 0x10, 0x00, 0x01, 0x85, 0xCF] # auto gap: 0x10 alone + inject_rx: [0x01, 0x03, 0x02, 0x00, 0x04, 0xB9, 0x87] + - expect_tx: [0x01, 0x03, 0x00, 0x13, 0x00, 0x01, 0x75, 0xCF] # auto gap: 0x13 alone + inject_rx: [0x01, 0x03, 0x02, 0x00, 0x05, 0x78, 0x47] + - expect_tx: [0x01, 0x03, 0x00, 0x20, 0x00, 0x04, 0x45, 0xC3] # yes across gap: one read 0x20-0x23, gap registers ignored + inject_rx: [0x01, 0x03, 0x08, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x33, 0xD1] + - expect_tx: [0x01, 0x03, 0x00, 0x30, 0x00, 0x01, 0x84, 0x05] # no isolation: 0x30 alone despite adjacency + inject_rx: [0x01, 0x03, 0x02, 0x00, 0x0A, 0x38, 0x43] + - expect_tx: [0x01, 0x03, 0x00, 0x31, 0x00, 0x01, 0xD5, 0xC5] # no isolation: 0x31 alone + inject_rx: [0x01, 0x03, 0x02, 0x00, 0x0B, 0xF9, 0x83] + - expect_tx: [0x01, 0x03, 0x00, 0x3F, 0x00, 0x01, 0xB4, 0x06] # open NEVER: 0x3F alone (the reuse:false item split off) + inject_rx: [0x01, 0x03, 0x02, 0x00, 0x0C, 0xB8, 0x41] + - expect_tx: [0x01, 0x03, 0x00, 0x40, 0x00, 0x02, 0xC5, 0xDF] # open NEVER: 0x40 (reuse: false) still extended by the auto item at 0x41 + inject_rx: [0x01, 0x03, 0x04, 0x00, 0x0D, 0x00, 0x0E, 0xEA, 0x34] + - expect_tx: [0x01, 0x03, 0x00, 0x50, 0x00, 0x01, 0x84, 0x1B] # same-address reuse: one read, two sensors on 0x50 + inject_rx: [0x01, 0x03, 0x02, 0x12, 0x34, 0xB5, 0x33] + - expect_tx: [0x01, 0x03, 0x00, 0x60, 0x00, 0x04, 0x44, 0x17] # text block + adjacent word: one read 0x60-0x63 + inject_rx: [0x01, 0x03, 0x08, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x00, 0x0F, 0x78, 0x0E] + - expect_tx: [0x01, 0x03, 0x00, 0x70, 0x00, 0x02, 0xC5, 0xD0] # response_size surplus: 0x70 answers 4 bytes, reuse:true word at 0x71 shifted along + inject_rx: [0x01, 0x03, 0x06, 0x00, 0x10, 0xAA, 0xBB, 0x00, 0x11, 0x71, 0x47] + - expect_tx: [0x01, 0x03, 0x00, 0x90, 0x00, 0x01, 0x84, 0x27] # auto after surplus: 0x90 alone (auto never joins past response_size) + inject_rx: [0x01, 0x03, 0x04, 0x00, 0x18, 0xCC, 0xDD, 0xEF, 0x6D] + - expect_tx: [0x01, 0x03, 0x00, 0x91, 0x00, 0x01, 0xD5, 0xE7] # auto after surplus: 0x91 alone + inject_rx: [0x01, 0x03, 0x02, 0x00, 0x19, 0x79, 0x8E] + - expect_tx: [0x01, 0x03, 0x00, 0x80, 0x00, 0x04, 0x45, 0xE1] # RAW block via response_size: 8 bytes = 4 registers in one read + inject_rx: [0x01, 0x03, 0x08, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x6D, 0xDF] + +modbus: + uart_id: virtual_uart_dev + send_wait_time: 200ms + turnaround_time: 10ms + +modbus_controller: + - address: 1 + id: ranges_controller + max_cmd_retries: 0 + # The test triggers a single poll by pressing the "Start Scenario" button + update_interval: never + +sensor: + # Case 1: three adjacent registers merge into one read (auto default) + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "adjacent_a" + register_type: holding + address: 0x00 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "adjacent_b" + register_type: holding + address: 0x01 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "adjacent_c" + register_type: holding + address: 0x02 + + # Case 2: a gap keeps auto items apart + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "gap_a" + register_type: holding + address: 0x10 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "gap_b" + register_type: holding + address: 0x13 + + # Case 3: reuse_previous_range: true bridges the gap into one read + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "bridge_a" + register_type: holding + address: 0x20 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "bridge_b" + register_type: holding + address: 0x23 + reuse_previous_range: true + + # Case 4: reuse_previous_range: false splits adjacent registers + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "split_a" + register_type: holding + address: 0x30 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "split_b" + register_type: holding + address: 0x31 + reuse_previous_range: false + + # Case 5: a reuse:false item starts its own range but stays open for later auto items + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "open_prev" + register_type: holding + address: 0x3F + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "open_never" + register_type: holding + address: 0x40 + reuse_previous_range: false + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "open_tagalong" + register_type: holding + address: 0x41 + + # Case 6: two sensors on the same register share one read + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "shared_lo" + register_type: holding + address: 0x50 + bitmask: 0x00FF + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "shared_hi" + register_type: holding + address: 0x50 + bitmask: 0xFF00 + + # Case 10 (text block, see text_sensor below) shares the range with this word at 0x63 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "after_text" + register_type: holding + address: 0x63 + + # Case 11: response_size surplus — the device answers 4 bytes for this single register, so the + # following sensor's data sits 2 bytes later than its address alone implies. Joining past a + # non-standard response_size takes an explicit reuse_previous_range: true. + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "surplus" + register_type: holding + address: 0x70 + response_size: 4 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "after_surplus" + register_type: holding + address: 0x71 + reuse_previous_range: true + + # Case 13: auto never joins past a response_size register — despite adjacency these poll separately + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "surplus_split" + register_type: holding + address: 0x90 + response_size: 4 + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "after_surplus_split" + register_type: holding + address: 0x91 + + # Case 12: RAW + response_size reads a block of ceil(8/2) = 4 registers + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "raw_block" + register_type: holding + address: 0x80 + value_type: RAW + response_size: 8 + lambda: |- + return (float) data.size(); + +text_sensor: + # Case 10: text sensor reads 3 registers (response_size 6) + - platform: modbus_controller + modbus_controller_id: ranges_controller + name: "text_block" + register_type: holding + address: 0x60 + response_size: 6 + raw_encode: NONE + +button: + - platform: template + name: "Start Scenario" + id: start_scenario_btn + on_press: + - lambda: |- + id(virtual_uart_dev).start_scenario(); + id(ranges_controller).set_update_interval(1000); + id(ranges_controller).start_poller(); diff --git a/tests/integration/fixtures/uart_mock_modbus_register_offset.yaml b/tests/integration/fixtures/uart_mock_modbus_register_offset.yaml index e93e78d5a3..21c451aa99 100644 --- a/tests/integration/fixtures/uart_mock_modbus_register_offset.yaml +++ b/tests/integration/fixtures/uart_mock_modbus_register_offset.yaml @@ -100,7 +100,7 @@ switch: offset: 2 assumed_state: true # A holding-register switch that READS its state. Byte offset 6 -> register 0x10 + 6/2 = 0x13. Post-fix - # the switch itself resolves to 0x13 (whole registers fold into the address, residual byte stays) and + # the switch itself resolves to 0x13 (the even byte offset folds into the address as whole registers) and # joins the 0x10..0x13 range, so no separate 0x13 sensor is needed. Pre-fix the whole byte offset folds # into the address (0x16), where the server answers ILLEGAL_DATA_ADDRESS and the switch never publishes. - platform: modbus_controller diff --git a/tests/integration/fixtures/uart_mock_modbus_shared_address.yaml b/tests/integration/fixtures/uart_mock_modbus_shared_address.yaml index 109603f3b6..7a94082ed8 100644 --- a/tests/integration/fixtures/uart_mock_modbus_shared_address.yaml +++ b/tests/integration/fixtures/uart_mock_modbus_shared_address.yaml @@ -32,9 +32,9 @@ uart_mock: # duplicate or overlapping range would put an extra frame on the bus and fail to match. - expect_tx: [0x01, 0x03, 0x90, 0x01, 0x00, 0x02, 0xB8, 0xCB] # Read holding 0x9001 count 2 on device 1 inject_rx: [0x01, 0x03, 0x04, 0x03, 0x97, 0x02, 0x91, 0x8B, 0x57] # 0x9001=0x0397, 0x9002=0x0291 - # A force_new_range sensor at a HIGH address (0x30) sorts before the plain sensor at a LOW address - # (0x10). The two must poll as separate ranges: the covered branch's lower-bound check prevents the - # 0x10 sensor from being absorbed into the forced 0x30 range with a wrapped byte offset. + # A sensor at 0x30 with the deprecated force_new_range (migrates to reuse_previous_range: false) + # and a plain sensor at 0x10. The two must poll as separate ranges: the 0x10 sensor must not be + # absorbed into the isolated 0x30 range. - expect_tx: [0x01, 0x03, 0x00, 0x30, 0x00, 0x01, 0x84, 0x05] # Read holding 0x30 count 1 (forced range) inject_rx: [0x01, 0x03, 0x02, 0x01, 0x11, 0x79, 0xD8] # 0x30 = 0x0111 = 273 - expect_tx: [0x01, 0x03, 0x00, 0x10, 0x00, 0x01, 0x85, 0xCF] # Read holding 0x10 count 1 (own range) @@ -87,7 +87,7 @@ sensor: register_type: holding value_type: U_WORD modbus_controller_id: modbus_controller_ok - # Forced sensor at a high address: sorts first, opens its own isolated range + # Isolated sensor (deprecated spelling, migrates to reuse_previous_range: false): own range - platform: modbus_controller name: "forced_high" address: 0x30 @@ -95,7 +95,7 @@ sensor: value_type: U_WORD force_new_range: true modbus_controller_id: modbus_controller_ok - # Plain sensor at a lower address: must get its own range, never absorbed into the forced one + # Plain sensor at a lower address: must get its own range, never absorbed into the isolated one - platform: modbus_controller name: "plain_low" address: 0x10 diff --git a/tests/integration/integration_test_durations.json b/tests/integration/integration_test_durations.json new file mode 100644 index 0000000000..5a5aac3b22 --- /dev/null +++ b/tests/integration/integration_test_durations.json @@ -0,0 +1,143 @@ +{ + "tests/integration/test_action_concurrent_reentry.py": 57.91, + "tests/integration/test_addressable_light_transition.py": 21.25, + "tests/integration/test_alarm_control_panel_state_transitions.py": 70.71, + "tests/integration/test_api_action_metadata.py": 66.6, + "tests/integration/test_api_action_responses.py": 36.1, + "tests/integration/test_api_action_timeout.py": 68.86, + "tests/integration/test_api_conditional_memory.py": 15.48, + "tests/integration/test_api_custom_services.py": 18.77, + "tests/integration/test_api_get_time_response_timezone.py": 21.08, + "tests/integration/test_api_homeassistant.py": 65.59, + "tests/integration/test_api_homeassistant_action_no_subscriber.py": 18.44, + "tests/integration/test_api_homeassistant_binary_sensor_initial_state.py": 15.05, + "tests/integration/test_api_list_entities_backpressure.py": 13.88, + "tests/integration/test_api_message_size_batching.py": 29.98, + "tests/integration/test_api_reboot_timeout.py": 16.05, + "tests/integration/test_api_string_lambda.py": 15.31, + "tests/integration/test_api_vv_logging.py": 19.28, + "tests/integration/test_api_zero_psk_provisioning.py": 31.5, + "tests/integration/test_areas_and_devices.py": 24.95, + "tests/integration/test_automation_wait_actions.py": 20.92, + "tests/integration/test_automations.py": 35.19, + "tests/integration/test_batch_delay_zero_rapid_transitions.py": 17.99, + "tests/integration/test_binary_sensor_autorepeat_filter.py": 20.39, + "tests/integration/test_binary_sensor_invalidate_state.py": 18.41, + "tests/integration/test_blocking_warning_log_time_not_charged_to_next_operation.py": 24.69, + "tests/integration/test_build_info.py": 18.7, + "tests/integration/test_camera_mock.py": 16.23, + "tests/integration/test_climate_control_action.py": 21.14, + "tests/integration/test_climate_custom_modes.py": 20.74, + "tests/integration/test_continuation_actions.py": 16.81, + "tests/integration/test_cover_control_action.py": 20.34, + "tests/integration/test_crc8_helper.py": 9.36, + "tests/integration/test_device_id_in_state.py": 44.67, + "tests/integration/test_duplicate_entities.py": 23.58, + "tests/integration/test_entity_icon.py": 34.35, + "tests/integration/test_fan_turn_on_action.py": 24.23, + "tests/integration/test_fnv1_hash_object_id.py": 16.21, + "tests/integration/test_fnv1a_hash.py": 13.38, + "tests/integration/test_gpio_expander_cache.py": 13.06, + "tests/integration/test_host_logger_thread_safety.py": 23.66, + "tests/integration/test_host_mode_basic.py": 8.01, + "tests/integration/test_host_mode_batch_delay.py": 21.0, + "tests/integration/test_host_mode_climate_basic_state.py": 22.14, + "tests/integration/test_host_mode_climate_control.py": 19.39, + "tests/integration/test_host_mode_empty_string_options.py": 21.76, + "tests/integration/test_host_mode_entity_fields.py": 29.61, + "tests/integration/test_host_mode_fan_preset.py": 20.01, + "tests/integration/test_host_mode_many_entities.py": 39.08, + "tests/integration/test_host_mode_many_entities_multiple_connections.py": 23.92, + "tests/integration/test_host_mode_noise_encryption.py": 42.42, + "tests/integration/test_host_mode_reconnect.py": 3.41, + "tests/integration/test_host_mode_sensor.py": 22.96, + "tests/integration/test_host_ota.py": 29.5, + "tests/integration/test_host_preferences.py": 16.06, + "tests/integration/test_host_preferences_suspend_resume.py": 18.71, + "tests/integration/test_improv_serial_uart.py": 20.22, + "tests/integration/test_large_message_batching.py": 26.56, + "tests/integration/test_legacy_area.py": 22.72, + "tests/integration/test_legacy_climate_compat.py": 14.13, + "tests/integration/test_legacy_fan_compat.py": 14.33, + "tests/integration/test_light_automations.py": 18.81, + "tests/integration/test_light_binary_effect_off_phase.py": 8.38, + "tests/integration/test_light_calls.py": 21.88, + "tests/integration/test_light_constant_brightness.py": 59.45, + "tests/integration/test_light_control_action.py": 31.91, + "tests/integration/test_light_dim_relative_action.py": 14.43, + "tests/integration/test_light_effect_zero_brightness.py": 25.05, + "tests/integration/test_light_initial_state.py": 18.97, + "tests/integration/test_light_toggle_action.py": 17.44, + "tests/integration/test_lock_automations.py": 18.9, + "tests/integration/test_logger_buffered_recursion_guard.py": 18.2, + "tests/integration/test_loop_disable_enable.py": 63.35, + "tests/integration/test_loop_interval_decoupling.py": 17.7, + "tests/integration/test_loop_interval_default_not_pulled_forward.py": 21.56, + "tests/integration/test_micros_to_millis.py": 15.89, + "tests/integration/test_multi_click_trigger.py": 17.23, + "tests/integration/test_multi_device_preferences.py": 19.4, + "tests/integration/test_noise_encryption_key_protection.py": 72.59, + "tests/integration/test_object_id_api_verification.py": 19.22, + "tests/integration/test_object_id_friendly_name_no_mac_suffix.py": 16.77, + "tests/integration/test_object_id_no_friendly_name.py": 45.8, + "tests/integration/test_online_image_auto_detects_image_bmp_mime.py": 86.73, + "tests/integration/test_online_image_auto_detects_redirected_image_bmp_mime.py": 40.4, + "tests/integration/test_online_image_bmp.py": 37.24, + "tests/integration/test_oversized_payloads.py": 55.75, + "tests/integration/test_preference_key_stability.py": 25.49, + "tests/integration/test_runtime_stats.py": 29.81, + "tests/integration/test_safe_mode_loop_runs.py": 6.26, + "tests/integration/test_scheduler_blocking_warning.py": 37.98, + "tests/integration/test_scheduler_bulk_cleanup.py": 18.67, + "tests/integration/test_scheduler_defer_cancel.py": 18.46, + "tests/integration/test_scheduler_defer_cancel_regular.py": 16.34, + "tests/integration/test_scheduler_defer_fifo_simple.py": 18.26, + "tests/integration/test_scheduler_defer_stress.py": 17.74, + "tests/integration/test_scheduler_heap_stress.py": 3.89, + "tests/integration/test_scheduler_internal_id_no_collision.py": 20.01, + "tests/integration/test_scheduler_interval_reschedule.py": 16.29, + "tests/integration/test_scheduler_interval_zero_coerced.py": 16.09, + "tests/integration/test_scheduler_null_name.py": 14.69, + "tests/integration/test_scheduler_numeric_id_test.py": 17.08, + "tests/integration/test_scheduler_pool.py": 19.88, + "tests/integration/test_scheduler_rapid_cancellation.py": 4.42, + "tests/integration/test_scheduler_recursive_timeout.py": 4.3, + "tests/integration/test_scheduler_removed_item_race.py": 15.49, + "tests/integration/test_scheduler_self_keyed.py": 25.77, + "tests/integration/test_scheduler_simultaneous_callbacks.py": 14.84, + "tests/integration/test_scheduler_string_test.py": 15.42, + "tests/integration/test_script_array_params.py": 12.73, + "tests/integration/test_script_delay_params.py": 12.69, + "tests/integration/test_script_queued.py": 20.38, + "tests/integration/test_script_queued_idle_loop.py": 25.06, + "tests/integration/test_script_wait_on_boot.py": 15.67, + "tests/integration/test_select_stringref_trigger.py": 19.48, + "tests/integration/test_sensor_filters_delta.py": 27.62, + "tests/integration/test_sensor_filters_ring_buffer.py": 20.27, + "tests/integration/test_sensor_filters_sliding_window.py": 56.28, + "tests/integration/test_sensor_filters_value_list.py": 20.6, + "tests/integration/test_sensor_timeout_filter.py": 22.21, + "tests/integration/test_socket_wake_gate_tcp.py": 16.37, + "tests/integration/test_status_flags.py": 29.68, + "tests/integration/test_strftime_to.py": 17.42, + "tests/integration/test_syslog.py": 18.39, + "tests/integration/test_template_alarm_control_panel_many_sensors.py": 25.61, + "tests/integration/test_template_text_save.py": 19.16, + "tests/integration/test_text_command.py": 16.43, + "tests/integration/test_text_sensor_raw_state.py": 17.19, + "tests/integration/test_uart_mock_ld2410.py": 37.0, + "tests/integration/test_uart_mock_ld2412.py": 40.82, + "tests/integration/test_uart_mock_ld2420.py": 32.7, + "tests/integration/test_uart_mock_ld2450.py": 32.84, + "tests/integration/test_uart_mock_modbus.py": 548.87, + "tests/integration/test_udp.py": 16.67, + "tests/integration/test_use_address_runtime.py": 27.26, + "tests/integration/test_valve_control_action.py": 24.58, + "tests/integration/test_varint_five_byte_device_id.py": 22.5, + "tests/integration/test_wait_until_mid_loop_timing.py": 22.05, + "tests/integration/test_wait_until_on_boot.py": 10.37, + "tests/integration/test_wait_until_ordering.py": 18.23, + "tests/integration/test_wait_until_reentrant_restart.py": 19.35, + "tests/integration/test_wake_loop_forces_phase_b.py": 17.83, + "tests/integration/test_water_heater_template.py": 25.7 +} diff --git a/tests/integration/log_utils.py b/tests/integration/log_utils.py new file mode 100644 index 0000000000..c605351bb8 --- /dev/null +++ b/tests/integration/log_utils.py @@ -0,0 +1,48 @@ +"""Helpers for asserting on log output in integration tests.""" + +from __future__ import annotations + +import asyncio + + +class LineWaiter: + """Collects log lines and lets a test await one containing all needles. + + Pass ``callback`` as ``run_compiled``'s ``line_callback``; the callback runs + on the test's own event loop, so futures are resolved directly. Only one + ``wait_for`` may be outstanding at a time (tests await sequentially). + """ + + def __init__(self) -> None: + self.lines: list[str] = [] + self._needles: tuple[str, ...] = () + self._future: asyncio.Future | None = None + + def callback(self, line: str) -> None: + self.lines.append(line) + if ( + self._future is not None + and not self._future.done() + and all(n in line for n in self._needles) + ): + self._future.set_result(line) + self._future = None + + async def wait_for_each(self, *texts: str, timeout: float = 10.0) -> None: + """Await each text in turn; a text may match a line already received.""" + for text in texts: + await self.wait_for(text, timeout=timeout) + + async def wait_for(self, *needles: str, timeout: float = 10.0) -> str: + """Return the first line, past or future, containing every needle.""" + for line in self.lines: + if all(n in line for n in needles): + return line + assert self._future is None or self._future.done(), "concurrent wait_for" + self._needles = needles + self._future = asyncio.get_running_loop().create_future() + try: + return await asyncio.wait_for(self._future, timeout) + finally: + self._future = None + self._needles = () diff --git a/tests/integration/test_api_action_metadata.py b/tests/integration/test_api_action_metadata.py new file mode 100644 index 0000000000..74d40f141b --- /dev/null +++ b/tests/integration/test_api_action_metadata.py @@ -0,0 +1,65 @@ +"""Integration test for user-defined action field metadata.""" + +from __future__ import annotations + +import asyncio +import re + +import pytest + +from esphome.helpers import fnv1_hash + +from .types import APIClientConnectedFactory, RunCompiledFunction + + +@pytest.mark.asyncio +async def test_api_action_metadata( + yaml_config: str, + run_compiled: RunCompiledFunction, + api_client_connected: APIClientConnectedFactory, +) -> None: + """Action and argument metadata reach the client and the actions still run.""" + loop = asyncio.get_running_loop() + buzzer_called = loop.create_future() + plain_called = loop.create_future() + buzzer_pattern = re.compile(r"Buzzer: two_short") + plain_pattern = re.compile(r"Plain action called") + + def check_output(line: str) -> None: + if not buzzer_called.done() and buzzer_pattern.search(line): + buzzer_called.set_result(True) + elif not plain_called.done() and plain_pattern.search(line): + plain_called.set_result(True) + + async with ( + run_compiled(yaml_config, line_callback=check_output), + api_client_connected() as client, + ): + _, services = await client.list_entities_services() + + by_name = {service.name: service for service in services} + assert set(by_name) == {"play_buzzer", "plain_action"} + # Keys are hashed at codegen time and must match what the client expects + for name, service in by_name.items(): + assert service.key == fnv1_hash(name), name + + buzzer = by_name["play_buzzer"] + assert buzzer.description == "Play an RTTTL melody on the buzzer" + args = {arg.name: arg for arg in buzzer.args} + assert args["song_str"].description == "RTTTL melody string" + assert args["song_str"].example == "two_short:d=4,o=5,b=100:16e6,16e6" + # An arg without metadata sends empty strings + assert args["volume"].description == "" + assert args["volume"].example == "" + + # An action without metadata sends empty strings + plain = by_name["plain_action"] + assert plain.description == "" + assert plain.args[0].description == "" + + await client.execute_service( + buzzer, {"song_str": "two_short:d=4,o=5,b=100:16e6,16e6", "volume": 3} + ) + await client.execute_service(plain, {"value": 1}) + await asyncio.wait_for(buzzer_called, timeout=5.0) + await asyncio.wait_for(plain_called, timeout=5.0) diff --git a/tests/integration/test_api_homeassistant_binary_sensor_initial_state.py b/tests/integration/test_api_homeassistant_binary_sensor_initial_state.py new file mode 100644 index 0000000000..4f7dda6eee --- /dev/null +++ b/tests/integration/test_api_homeassistant_binary_sensor_initial_state.py @@ -0,0 +1,98 @@ +"""Test on_press/on_release for homeassistant binary sensors on the first HA state.""" + +from __future__ import annotations + +import asyncio + +import pytest + +from .log_utils import LineWaiter +from .types import APIClientConnectedFactory, RunCompiledFunction + +ENTITIES = ( + "binary_sensor.initial_on", + "binary_sensor.default", + "binary_sensor.unavailable_first", + "binary_sensor.initial_off", + "binary_sensor.default_unavail", +) + + +@pytest.mark.asyncio +async def test_api_homeassistant_binary_sensor_initial_state( + yaml_config: str, + run_compiled: RunCompiledFunction, + api_client_connected: APIClientConnectedFactory, +) -> None: + """The first state from HA fires on_press only with trigger_on_initial_state.""" + loop = asyncio.get_running_loop() + waiter = LineWaiter() + subscribed: set[str] = set() + all_subscribed = loop.create_future() + + def on_state_sub(entity_id: str, _attribute: str | None) -> None: + subscribed.add(entity_id) + if not all_subscribed.done() and subscribed.issuperset(ENTITIES): + all_subscribed.set_result(None) + + async with ( + run_compiled(yaml_config, line_callback=waiter.callback), + api_client_connected() as client, + ): + client.subscribe_home_assistant_states(on_state_sub) + try: + await asyncio.wait_for(all_subscribed, timeout=5.0) + except TimeoutError: + pytest.fail(f"never subscribed: {set(ENTITIES) - subscribed}") + + # First state from HA + client.send_home_assistant_state("binary_sensor.initial_on", "", "on") + client.send_home_assistant_state("binary_sensor.default", "", "on") + client.send_home_assistant_state( + "binary_sensor.unavailable_first", "", "unavailable" + ) + client.send_home_assistant_state("binary_sensor.unavailable_first", "", "on") + client.send_home_assistant_state( + "binary_sensor.default_unavail", "", "unavailable" + ) + client.send_home_assistant_state("binary_sensor.default_unavail", "", "on") + client.send_home_assistant_state("binary_sensor.initial_off", "", "off") + + await waiter.wait_for("initial_on on_press", timeout=5.0) + await waiter.wait_for("unavailable_first on_press", timeout=5.0) + # Pin that the 'unavailable' message actually arrived and was rejected + await waiter.wait_for("Can't convert 'unavailable'", timeout=5.0) + # initial_off is the last state sent, so this wait also proves the + # earlier 'default' initial state was already processed + await waiter.wait_for("initial_off on_release", timeout=5.0) + # Both 'unavailable' senders must have been seen and rejected + assert sum("Can't convert 'unavailable'" in line for line in waiter.lines) == 2 + # Guard every phase 2 needle against being satisfied by a stale + # phase 1 line, and pin that the initial states fired nothing else + for absent in ( + "initial_on on_release", + "default on_press", + "default on_release", + "default_unavail on_press", + "default_unavail on_release", + "unavailable_first on_release", + "initial_off on_press", + ): + assert not any(absent in line for line in waiter.lines), ( + f"unexpected trigger before the second state change: {absent}" + ) + + # A later change fires for all of them + client.send_home_assistant_state("binary_sensor.initial_on", "", "off") + client.send_home_assistant_state("binary_sensor.default", "", "off") + client.send_home_assistant_state("binary_sensor.unavailable_first", "", "off") + client.send_home_assistant_state("binary_sensor.initial_off", "", "on") + client.send_home_assistant_state("binary_sensor.default_unavail", "", "off") + await waiter.wait_for_each( + "initial_on on_release", + "default on_release", + "default_unavail on_release", + "unavailable_first on_release", + "initial_off on_press", + timeout=5.0, + ) diff --git a/tests/integration/test_host_ota.py b/tests/integration/test_host_ota.py index e1036fdf1c..4e74814534 100644 --- a/tests/integration/test_host_ota.py +++ b/tests/integration/test_host_ota.py @@ -10,6 +10,7 @@ from __future__ import annotations import asyncio from collections.abc import Generator from contextlib import contextmanager +import functools import socket import pytest @@ -111,6 +112,62 @@ async def test_host_ota_self_update( assert proc.pid == pid_before +@pytest.mark.asyncio +async def test_host_ota_encrypted( + yaml_config: str, + write_yaml_config: ConfigWriter, + compile_esphome: CompileFunction, + reserved_tcp_port: tuple[int, socket.socket], +) -> None: + """Encrypted self-OTA succeeds; a plaintext upload to the same device fails.""" + pytest.importorskip("aioesphomeapi.noise") + noise_psk = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" + api_port, api_socket = reserved_tcp_port + with _reserve_port() as (ota_port, ota_socket): + yaml_config = yaml_config.replace("__OTA_PORT__", str(ota_port)) + config_path = await write_yaml_config(yaml_config) + binary_path = await compile_esphome(config_path) + api_socket.close() + ota_socket.close() + + loop = asyncio.get_running_loop() + rebooted = loop.create_future() + + def on_log(line: str) -> None: + if not rebooted.done() and "Rebooting safely" in line: + rebooted.set_result(True) + + async with run_binary(binary_path, line_callback=on_log) as (proc, _lines): + await _wait_for_port(LOCALHOST, api_port, PORT_WAIT_TIMEOUT) + pid_before = proc.pid + + # A plaintext upload must be refused with the device unharmed + rc, _ = await loop.run_in_executor( + None, espota2.run_ota, LOCALHOST, ota_port, None, binary_path + ) + assert rc == 1, "plaintext upload to an encrypted device must fail" + await asyncio.sleep(0.5) + assert proc.returncode is None, "process died on rejected plaintext OTA" + + # The encrypted upload goes through and the device re-execs + rc, _ = await loop.run_in_executor( + None, + functools.partial( + espota2.run_ota, + LOCALHOST, + ota_port, + None, + binary_path, + noise_psk=noise_psk, + ), + ) + assert rc == 0, "encrypted OTA reported failure" + await asyncio.wait_for(rebooted, timeout=10.0) + await _wait_for_port(LOCALHOST, api_port, PORT_WAIT_TIMEOUT) + assert proc.returncode is None, "process exited instead of execing" + assert proc.pid == pid_before + + @pytest.mark.asyncio async def test_host_ota_rejects_garbage( yaml_config: str, diff --git a/tests/integration/test_improv_serial_uart.py b/tests/integration/test_improv_serial_uart.py new file mode 100644 index 0000000000..75fb3263d6 --- /dev/null +++ b/tests/integration/test_improv_serial_uart.py @@ -0,0 +1,147 @@ +"""Integration test for improv_serial over a mocked UART bus. + +Drives the improv serial protocol end to end on the host platform: +the fixture wires improv_serial to a uart_mock bus and shadows the wifi +component with a host stub. The test injects improv frames through an API +action and asserts on the framed responses that uart_mock logs as TX lines. + +Covered: + 1. Get Current State reports AUTHORIZED + 2. Get Device Info returns the firmware/device info RPC response + 3. Get Wi-Fi Networks returns deduplicated scan results and a terminator + 4. Wi-Fi Settings provisions: saves credentials and reports PROVISIONED +""" + +from __future__ import annotations + +import pytest + +from .log_utils import LineWaiter +from .types import APIClientConnectedFactory, RunCompiledFunction + +# Improv serial framing (improv_serial_component.h) +IMPROV_HEADER = b"IMPROV" +IMPROV_VERSION = 1 +TYPE_CURRENT_STATE = 0x01 +TYPE_RPC = 0x03 +TYPE_RPC_RESPONSE = 0x04 + +# improv::Command values +CMD_GET_CURRENT_STATE = 0x02 +CMD_GET_DEVICE_INFO = 0x03 +CMD_GET_WIFI_NETWORKS = 0x04 +CMD_WIFI_SETTINGS = 0x01 + + +def build_rpc_frame(command: int, data: bytes = b"") -> list[int]: + """Build a full improv serial frame carrying one RPC command.""" + payload = bytes([command, len(data)]) + data + frame = IMPROV_HEADER + bytes([IMPROV_VERSION, TYPE_RPC, len(payload)]) + payload + checksum = sum(frame) & 0xFF + return list(frame + bytes([checksum]) + b"\n") + + +def state_frame_hex(state: int) -> str: + """Full 12 byte current-state frame as hex, checksum and newline included.""" + frame = IMPROV_HEADER + bytes([IMPROV_VERSION, TYPE_CURRENT_STATE, 1, state]) + checksum = sum(frame) & 0xFF + return ":".join(f"{b:02X}" for b in frame + bytes([checksum]) + b"\n") + + +def rpc_footer_hex(payload: bytes) -> str: + """Checksum and newline footer written after an RPC response payload.""" + header = IMPROV_HEADER + bytes([IMPROV_VERSION, TYPE_RPC_RESPONSE, len(payload)]) + checksum = (sum(header) + sum(payload)) & 0xFF + return f"{checksum:02X}:0A" + + +def wifi_settings_data(ssid: str, password: str) -> bytes: + ssid_b = ssid.encode() + pass_b = password.encode() + return bytes([len(ssid_b)]) + ssid_b + bytes([len(pass_b)]) + pass_b + + +def hex_of(text: str) -> str: + """Colon separated uppercase hex as logged by format_hex_pretty.""" + return ":".join(f"{b:02X}" for b in text.encode()) + + +@pytest.mark.asyncio +async def test_improv_serial_uart( + yaml_config: str, + run_compiled: RunCompiledFunction, + api_client_connected: APIClientConnectedFactory, +) -> None: + waiter = LineWaiter() + + async with ( + run_compiled(yaml_config, line_callback=waiter.callback), + api_client_connected() as client, + ): + _entities, services = await client.list_entities_services() + inject = next(s for s in services if s.name == "uart_inject") + + # 1. Get Current State: expect the complete current-state frame reporting + # AUTHORIZED (0x02), checksum and newline included + await client.execute_service( + inject, {"payload": build_rpc_frame(CMD_GET_CURRENT_STATE)} + ) + await waiter.wait_for("uart_mock", f"TX 12 bytes: {state_frame_hex(0x02)}") + + # 2. Get Device Info: the always logged 9 byte response header, then the + # payload with the firmware name (must stay under uart_mock's 64 byte + # hex dump cap or the payload line reads "too large to log") + await client.execute_service( + inject, {"payload": build_rpc_frame(CMD_GET_DEVICE_INFO)} + ) + await waiter.wait_for("uart_mock", "TX 9 bytes: 49:4D:50:52:4F:56:01:04") + await waiter.wait_for("uart_mock", "TX ", hex_of("ESPHome")) + + # 3. Get Wi-Fi Networks: stub scan has TestNet twice (dedup keeps the + # stronger), OpenNet, and a hidden entry (filtered). Expect one response + # per visible network plus the empty terminator. + await client.execute_service( + inject, {"payload": build_rpc_frame(CMD_GET_WIFI_NETWORKS)} + ) + await waiter.wait_for("uart_mock", hex_of("TestNet")) + await waiter.wait_for("uart_mock", hex_of("OpenNet")) + # Terminator: all three writes of the response frame; 9 byte header, + # payload [0x04, 0x00, 0x00], then the checksum and newline footer + await waiter.wait_for("uart_mock", "TX 9 bytes: 49:4D:50:52:4F:56:01:04:03") + await waiter.wait_for("uart_mock", "TX 3 bytes: 04:00:00") + await waiter.wait_for( + "uart_mock", f"TX 2 bytes: {rpc_footer_hex(bytes([0x04, 0x00, 0x00]))}" + ) + testnet_count = sum( + 1 + for line in waiter.lines + if "uart_mock" in line and "TX " in line and hex_of("TestNet") in line + ) + assert testnet_count == 1, ( + f"Duplicate scan entry not deduplicated: {testnet_count} TestNet responses" + ) + + # 4. Wi-Fi Settings: stub connects immediately; expect the credentials + # saved, the PROVISIONED state frame (0x04), and the settings response + await client.execute_service( + inject, + { + "payload": build_rpc_frame( + CMD_WIFI_SETTINGS, wifi_settings_data("NewNet", "secret123") + ) + }, + ) + await waiter.wait_for("save_wifi_sta ssid=NewNet") + await waiter.wait_for("uart_mock", f"TX 12 bytes: {state_frame_hex(0x04)}") + # Settings RPC response carries the formatted next_url and its footer + next_url = b"https://example.com/?device=improv-uart" + payload = ( + bytes([CMD_WIFI_SETTINGS, len(next_url) + 1, len(next_url)]) + + next_url + + b"\x00" + ) + await waiter.wait_for( + "uart_mock", + f"TX {len(payload)} bytes: " + ":".join(f"{b:02X}" for b in payload), + ) + await waiter.wait_for("uart_mock", f"TX 2 bytes: {rpc_footer_hex(payload)}") diff --git a/tests/integration/test_uart_mock_modbus.py b/tests/integration/test_uart_mock_modbus.py index 3dfeda9b37..864275f5ed 100644 --- a/tests/integration/test_uart_mock_modbus.py +++ b/tests/integration/test_uart_mock_modbus.py @@ -21,7 +21,7 @@ import asyncio from collections.abc import Callable from dataclasses import dataclass -from aioesphomeapi import ButtonInfo, NumberInfo, SwitchInfo +from aioesphomeapi import ButtonInfo, NumberInfo, SwitchInfo, TextSensorState import pytest from .state_utils import SensorTracker, find_entity, wait_for_state @@ -967,13 +967,6 @@ async def test_uart_mock_modbus_client_read_write( _assert_no_modbus_errors(error_log_lines, warning_log_lines) -@pytest.mark.xfail( - strict=True, - reason="Byte-accurate register-offset writes land in the follow-up offset fix; " - "until then the byte offset is folded into the address (writes 0x12 instead of " - "0x11). The write and read assertions both flip via the same switch-constructor " - "fold. Remove this marker when that change merges.", -) @pytest.mark.asyncio async def test_uart_mock_modbus_register_offset( yaml_config: str, @@ -1065,6 +1058,61 @@ async def test_uart_mock_modbus_lambda_write( await tracker.await_change(wrote_30, "reg_30", timeout=4.0) +@pytest.mark.asyncio +async def test_uart_mock_modbus_lambda_invert( + yaml_config: str, + run_compiled: RunCompiledFunction, + api_client_connected: APIClientConnectedFactory, +) -> None: + """Test that a write_lambda's return value is the wire value only. + + `invert_switch` is an active-low holding switch whose write_lambda returns !x. Turning it ON must + write 0x0000 to the register (observed through the independent reg_40 sensor) while the entity + reports ON - the requested state, not the inverted wire value. Turning it OFF writes 0xFFFF and + reports OFF. The switch is assumed_state, so the published state comes only from write_state(). + """ + + tracker = SensorTracker(["reg_40"]) + initial = tracker.expect("reg_40", 5) + wrote_on = tracker.expect("reg_40", 0) + wrote_off = tracker.expect("reg_40", 65535) + + async with ( + run_compiled(yaml_config), + api_client_connected() as client, + ): + entities = await tracker.setup_and_start_scenario(client) + await tracker.await_change(initial, "reg_40", timeout=4.0) + + switch = find_entity(entities, "invert_switch", SwitchInfo) + assert switch is not None, "invert_switch not found" + + client.switch_command(switch.key, True) + # The wire byte carries the inverted value... + await tracker.await_change(wrote_on, "reg_40", timeout=4.0) + # ...while the entity reports the requested state. Switch states are deduped, so this relies on + # wait_for_state's fresh subscribe_states re-dumping every entity's current state. + await wait_for_state( + client, + lambda s: ( + getattr(s, "key", None) == switch.key + and getattr(s, "state", None) is True + ), + timeout=6.0, + ) + + client.switch_command(switch.key, False) + await tracker.await_change(wrote_off, "reg_40", timeout=4.0) + await wait_for_state( + client, + lambda s: ( + getattr(s, "key", None) == switch.key + and getattr(s, "state", None) is False + ), + timeout=6.0, + ) + + @pytest.mark.asyncio async def test_uart_mock_modbus_deprecated_write_buffer( yaml_config: str, @@ -1110,3 +1158,78 @@ async def test_uart_mock_modbus_deprecated_write_buffer( assert warn_count == 1, ( f"deprecation warning should fire exactly once per entity, got {warn_count}" ) + + +@pytest.mark.asyncio +async def test_uart_mock_modbus_ranges( + yaml_config: str, + run_compiled: RunCompiledFunction, + api_client_connected: APIClientConnectedFactory, +) -> None: + """Wire-level test of the range builder's reuse_previous_range semantics. + + Every expect_tx in the fixture pins the exact read request the controller emits, so a + wrongly merged or split range fails on the mock before any value arrives. Covers: auto + adjacency merging, auto gap splitting, reuse:true bridging a gap (with correct data + offsets past the gap), reuse:false splitting adjacent registers while staying open for + later auto items, two sensors sharing one register, a text block read sized by + response_size with a following word, response_size surplus shifting a later reuse:true + sensor's bytes while an auto sensor refuses to join past the surplus, and a RAW block + read of ceil(response_size / 2) registers. + """ + + line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback() + + expected_values = { + "adjacent_a": 1, + "adjacent_b": 2, + "adjacent_c": 3, + "gap_a": 4, + "gap_b": 5, + "bridge_a": 6, + "bridge_b": 9, + "split_a": 10, + "split_b": 11, + "open_prev": 12, + "open_never": 13, + "open_tagalong": 14, + "shared_lo": 0x34, + "shared_hi": 0x12, + "after_text": 15, + "surplus": 16, + "after_surplus": 17, + "surplus_split": 24, + "after_surplus_split": 25, + "raw_block": 8, # the RAW lambda publishes data.size(): 4 registers = 8 bytes + } + tracker = SensorTracker(list(expected_values.keys())) + futures = tracker.expect_all(expected_values) + + # The tracker only handles numeric sensors; capture the text block separately. + text_future: asyncio.Future = asyncio.get_running_loop().create_future() + tracker_on_state = tracker.on_state + + def on_state(state) -> None: + if ( + isinstance(state, TextSensorState) + and not state.missing_state + and state.state == "ABCDEF" + and not text_future.done() + ): + text_future.set_result(True) + tracker_on_state(state) + + tracker.on_state = on_state + + async with ( + run_compiled(yaml_config, line_callback=line_callback), + api_client_connected() as client, + ): + await tracker.setup_and_start_scenario(client) + await tracker.await_all(futures) + # text_block is not tracker-registered (non-numeric), so time out explicitly. + try: + await asyncio.wait_for(text_future, timeout=5.0) + except TimeoutError: + pytest.fail("text_block never published 'ABCDEF'") + _assert_no_modbus_errors(error_log_lines, warning_log_lines) diff --git a/tests/script/test_ci_custom.py b/tests/script/test_ci_custom.py new file mode 100644 index 0000000000..d340a816c6 --- /dev/null +++ b/tests/script/test_ci_custom.py @@ -0,0 +1,147 @@ +"""Unit tests for the ESP_LOG-needs-braces lint rule in script/ci-custom.py. + +The rule flags an if/else/for/while whose only body is an unbraced ESP_LOG*() call (which becomes an +empty statement -- and a -Wempty-body warning -- once the log level compiles the macro out). These +tests pin the comment/string/raw-string masker, the accepted control-statement shapes, and the +NOLINT escape hatch at both placements a contributor would try. +""" + +import importlib.util +from pathlib import Path +import sys + +SCRIPT_DIR = (Path(__file__).parent / ".." / ".." / "script").resolve() +sys.path.insert(0, str(SCRIPT_DIR)) +_spec = importlib.util.spec_from_file_location("ci_custom", SCRIPT_DIR / "ci-custom.py") +ci_custom = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(ci_custom) + +mask = ci_custom._mask_cpp_comments_strings + + +def _lint(content: str) -> list: + return ci_custom.lint_esp_log_needs_braces("test.cpp", content) + + +# --- masker --- + + +def test_mask_preserves_length_newlines_and_real_parens() -> None: + src = 'foo("bar") + baz();\nqux();\n' + masked = mask(src) + assert len(masked) == len(src) + assert masked.count("\n") == src.count("\n") + assert masked.count("(") == src.count("(") # real parens survive for balancing + + +def test_mask_blanks_line_and_block_comments() -> None: + assert "ESP_LOGD" not in mask("a; // if (x) ESP_LOGD(t);\n") + assert "ESP_LOGD" not in mask("a; /* if (x) ESP_LOGD(t); */ b;\n") + + +def test_mask_blanks_string_literals() -> None: + assert "if" not in mask('x = "if (y) ESP_LOGD";\n') + + +def test_mask_handles_raw_string_without_desync() -> None: + # A raw string full of quotes/parens must be consumed as one unit; code after it stays intact. + src = 's.print(R"()");\nreturn;\n' + masked = mask(src) + assert "href" not in masked + assert "return;" in masked # not swallowed by a desynced string scan + + +# --- rule: flags real violations --- + + +def test_flags_unbraced_if_next_line() -> None: + assert _lint("if (x)\n ESP_LOGD(t);\n") + + +def test_flags_unbraced_same_line() -> None: + assert _lint("if (x) ESP_LOGW(t);\n") + + +def test_flags_c_style_for() -> None: + assert _lint("for (int i = 0; i < n; i++)\n ESP_LOGD(t, i);\n") + + +def test_flags_range_for_and_else() -> None: + assert _lint("for (auto &x : v)\n ESP_LOGCONFIG(t);\n") + assert _lint("else\n ESP_LOGE(t);\n") + + +def test_flags_for_header_with_nested_call() -> None: + assert _lint("for (auto it = v.begin(); it != v.end(); ++it)\n ESP_LOGD(t);\n") + + +def test_for_header_does_not_reach_into_a_later_statement() -> None: + # The 'for' header is bounded to its own statement, so it cannot swallow the loop body and latch + # onto a later ')'. Without that, the '#if' line below is reported as an unbraced body even though + # the '#' preprocessor check should skip it. + assert not _lint( + "for (int i = 0; i < n; i++)\n arr[i] = 0;\n#if defined(USE_X)\n ESP_LOGD(t);\n#endif\n" + ) + + +def test_violation_after_a_for_loop_is_reported_at_its_own_line() -> None: + errors = _lint( + "for (int i = 0; i < n; i++)\n sum += a[i];\nif (verbose)\n ESP_LOGD(t, sum);\n" + ) + lines = [line for line, _col, _msg in errors] + assert lines == [3] # the 'if', not the 'for' on line 1 + + +def test_flags_lowercase_esph_log_family() -> None: + # core/log.h defines esph_log_*() alongside ESP_LOG*(); both expand to nothing below their level. + assert _lint('if (x)\n esph_log_config(t, "m");\n') + assert _lint('if (err != ESP_OK)\n esph_log_e(t, "m");\n') + + +def test_digit_separator_does_not_disable_the_rest_of_the_file() -> None: + # A "'" digit separator must not be read as a char-literal opener, which blanked everything after. + assert _lint("uint32_t x = 1'000;\nif (y)\n ESP_LOGD(t);\n") + + +def test_mask_still_blanks_real_char_literals() -> None: + assert "ESP_LOGD" not in mask("char c = '\"'; // if (x) ESP_LOGD(t);\n") + assert not _lint("char sep = ';';\nif (x) {\n ESP_LOGD(t);\n}\n") + + +def test_flags_multiline_log_body() -> None: + assert _lint('if (x)\n ESP_LOGD(t, "%d %d",\n a, b);\n') + + +def test_raw_string_before_violation_still_caught() -> None: + # Regression for the masker desyncing on a raw string and disabling the check for the rest. + assert _lint('s.print(R"()");\nif (y)\n ESP_LOGD(t);\n') + + +# --- rule: ignores non-violations --- + + +def test_ignores_braced_body() -> None: + assert not _lint("if (x) {\n ESP_LOGD(t);\n}\n") + + +def test_ignores_commented_out_code() -> None: + assert not _lint("// if (x) ESP_LOGD(t);\n") + + +def test_ignores_preprocessor_else() -> None: + assert not _lint("#else\n ESP_LOGCONFIG(t);\n#endif\n") + + +def test_ignores_non_log_body() -> None: + assert not _lint("if (x)\n return false;\n") + + +# --- NOLINT escape hatch, both placements --- + + +def test_nolint_at_end_of_log_line_suppresses() -> None: + assert not _lint("if (x)\n ESP_LOGD(t); // NOLINT\n") + + +def test_nolint_on_control_line_suppresses() -> None: + assert not _lint("if (x) // NOLINT\n ESP_LOGD(t);\n") diff --git a/tests/script/test_clang_tidy_hash.py b/tests/script/test_clang_tidy_hash.py index b5a9d8ebe9..decae4fd13 100644 --- a/tests/script/test_clang_tidy_hash.py +++ b/tests/script/test_clang_tidy_hash.py @@ -81,3 +81,40 @@ def test_read_file_bytes(tmp_path: Path) -> None: result = clang_tidy_hash.read_file_bytes(test_file) assert result == test_content + + +def test_calculate_idedata_cache_hash_changes_with_infra_code(tmp_path: Path) -> None: + _populate(tmp_path) + infra = tmp_path / "esphome" / "espidf" / "clang_tidy.py" + infra.parent.mkdir(parents=True) + infra.write_text("a") + before = clang_tidy_hash.calculate_idedata_cache_hash(repo_root=tmp_path) + assert before == clang_tidy_hash.calculate_idedata_cache_hash(repo_root=tmp_path) + infra.write_text("b") + assert clang_tidy_hash.calculate_idedata_cache_hash(repo_root=tmp_path) != before + + +def test_calculate_idedata_cache_hash_includes_listed_files(tmp_path: Path) -> None: + _populate(tmp_path) + before = clang_tidy_hash.calculate_idedata_cache_hash(repo_root=tmp_path) + listed = tmp_path / "esphome" / "platformio" / "library.py" + listed.parent.mkdir(parents=True) + listed.write_text("x") + assert clang_tidy_hash.calculate_idedata_cache_hash(repo_root=tmp_path) != before + + +def test_idedata_cache_hash_only_widens_for_esp32(tmp_path: Path) -> None: + _populate(tmp_path) + infra = tmp_path / "esphome" / "espidf" / "clang_tidy.py" + infra.parent.mkdir(parents=True) + infra.write_text("a") + esp32_before = clang_tidy_hash.idedata_cache_hash("esp32-idf-tidy", tmp_path) + other_before = clang_tidy_hash.idedata_cache_hash("esp8266-arduino-tidy", tmp_path) + infra.write_text("b") + assert ( + clang_tidy_hash.idedata_cache_hash("esp32-idf-tidy", tmp_path) != esp32_before + ) + assert ( + clang_tidy_hash.idedata_cache_hash("esp8266-arduino-tidy", tmp_path) + == other_before + ) diff --git a/tests/script/test_determine_jobs.py b/tests/script/test_determine_jobs.py index 565f8c563f..4971821969 100644 --- a/tests/script/test_determine_jobs.py +++ b/tests/script/test_determine_jobs.py @@ -151,9 +151,14 @@ def test_main_all_tests_should_run( patch.object(determine_jobs, "_is_clang_tidy_full_scan", return_value=False), patch.object( determine_jobs, - "_all_integration_test_files", + "all_integration_test_files", return_value=fake_test_files, ), + patch.object( + determine_jobs, + "load_integration_durations", + return_value=dict.fromkeys(fake_test_files, 200.0), + ), patch.object( determine_jobs, "get_changed_components", @@ -189,24 +194,12 @@ def test_main_all_tests_should_run( output = json.loads(captured.out) assert output["integration_tests"] is True - # run_all=True expands to the full glob and pre-buckets into 3 parts. - # Each bucket's `tests` is a JSON list of file paths. + assert output["integration_run_all"] is True + # run_all=True expands to the full glob; balance and naming are pinned + # by the unit tests, main() only needs to round-trip the structure assert isinstance(output["integration_test_buckets"], list) - assert len(output["integration_test_buckets"]) == 3 - assert [b["name"] for b in output["integration_test_buckets"]] == [ - "1/3", - "2/3", - "3/3", - ] - for bucket in output["integration_test_buckets"]: - assert isinstance(bucket["tests"], list) - for path in bucket["tests"]: - assert isinstance(path, str) bucket_files = [f for b in output["integration_test_buckets"] for f in b["tests"]] - assert bucket_files == fake_test_files - # Bucket sizes are balanced (max-min difference at most 1). - sizes = [len(b["tests"]) for b in output["integration_test_buckets"]] - assert max(sizes) - min(sizes) <= 1 + assert sorted(bucket_files) == fake_test_files assert output["clang_tidy"] is True assert output["clang_tidy_mode"] in ["nosplit", "split"] assert output["clang_format"] is True @@ -509,14 +502,24 @@ def test_compute_integration_test_buckets_at_threshold_stays_single() -> None: def test_compute_integration_test_buckets_just_over_threshold_splits() -> None: - """One file over the threshold triggers the 3-bucket fan-out, balanced.""" + """One file over the threshold fans out fully when the weights demand it.""" n = determine_jobs.INTEGRATION_TESTS_SPLIT_THRESHOLD + 1 files = [f"tests/integration/test_{i:02d}.py" for i in range(n)] - run, buckets = determine_jobs._compute_integration_test_buckets(False, files) + with patch.object( + determine_jobs, + "load_integration_durations", + return_value=dict.fromkeys(files, 200.0), + ): + run, buckets = determine_jobs._compute_integration_test_buckets(False, files) assert run is True - assert [b["name"] for b in buckets] == ["1/3", "2/3", "3/3"] - union = [path for b in buckets for path in b["tests"]] + # threshold+1 files x 200s caps at the maximum bucket count. + n_buckets = determine_jobs.INTEGRATION_TESTS_SPLIT_BUCKETS + assert [b["name"] for b in buckets] == [ + f"{i + 1}/{n_buckets}" for i in range(n_buckets) + ] + union = sorted(path for b in buckets for path in b["tests"]) assert union == sorted(files) + # Equal weights => bucket sizes are balanced (difference at most 1). sizes = [len(b["tests"]) for b in buckets] assert max(sizes) - min(sizes) <= 1 @@ -526,7 +529,7 @@ def test_compute_integration_test_buckets_run_all_with_empty_glob_disables_run() ): """run_all=True but glob returns no files => run suppressed (otherwise pytest would collect tests outside tests/integration/).""" - with patch.object(determine_jobs, "_all_integration_test_files", return_value=[]): + with patch.object(determine_jobs, "all_integration_test_files", return_value=[]): run, buckets = determine_jobs._compute_integration_test_buckets(True, []) assert run is False assert buckets == [] @@ -552,6 +555,13 @@ def test_determine_integration_tests( assert run_all is True assert test_files == [] + # Dependency pins and the session init fixture trigger run_all + for trigger in sorted(determine_jobs.INTEGRATION_TESTS_TRIGGER_FILES): + with patch.object(determine_jobs, "changed_files", return_value=[trigger]): + run_all, test_files = determine_jobs.determine_integration_tests() + assert run_all is True + assert test_files == [] + # Python files directly in esphome/ do NOT trigger tests with patch.object( determine_jobs, "changed_files", return_value=["esphome/config.py"] @@ -3139,3 +3149,86 @@ def test_memory_impact_elf_layouts_are_found(tmp_path: Path) -> None: elf.write_text("") assert find_elf_path(build_path) == elf, f"{platform} ELF not found" + + +def test_compute_integration_test_buckets_no_durations_full_fanout() -> None: + """Without recorded durations the fan-out stays at the maximum.""" + files = [f"tests/integration/test_{i:03d}.py" for i in range(15)] + with patch.object(determine_jobs, "load_integration_durations", return_value={}): + run, buckets = determine_jobs._compute_integration_test_buckets(False, files) + assert run is True + assert len(buckets) == determine_jobs.INTEGRATION_TESTS_SPLIT_BUCKETS + assert sorted(f for b in buckets for f in b["tests"]) == files + + +def test_compute_integration_test_buckets_adaptive_count() -> None: + """A small recorded total weight collapses to one bucket above the threshold.""" + files = [f"tests/integration/test_{i:03d}.py" for i in range(15)] + with patch.object( + determine_jobs, + "load_integration_durations", + return_value=dict.fromkeys(files, 10.0), + ): + run, buckets = determine_jobs._compute_integration_test_buckets(False, files) + assert run is True + # 15 files x 10s recorded = 150s, under the per-bucket weight target. + assert [b["name"] for b in buckets] == ["1/1"] + assert buckets[0]["tests"] == files + + +def test_compute_integration_test_buckets_duration_weighted() -> None: + """Heavy files spread across buckets instead of clustering by sorted name.""" + files = [f"tests/integration/test_{i:03d}.py" for i in range(12)] + durations = dict.fromkeys(files, 10.0) + durations[files[0]] = 600.0 + durations[files[1]] = 600.0 + with patch.object( + determine_jobs, "load_integration_durations", return_value=durations + ): + run, buckets = determine_jobs._compute_integration_test_buckets(False, files) + assert run is True + assert len(buckets) >= 2 + heavy_buckets = [b for b in buckets if set(files[:2]) & set(b["tests"])] + assert len(heavy_buckets) == 2, "heavy files should land in different buckets" + assert sorted(f for b in buckets for f in b["tests"]) == files + + +def test_load_integration_durations_missing_or_corrupt(tmp_path: Path) -> None: + """Missing or unparsable durations data degrades to an empty mapping.""" + with patch.object(helpers, "root_path", str(tmp_path)): + assert determine_jobs.load_integration_durations() == {} + durations_file = tmp_path / helpers.INTEGRATION_TEST_DURATIONS_FILE + durations_file.parent.mkdir(parents=True) + durations_file.write_text("not json") + assert determine_jobs.load_integration_durations() == {} + durations_file.write_text('{"tests/integration/test_a.py": 12.5}') + assert determine_jobs.load_integration_durations() == { + "tests/integration/test_a.py": 12.5 + } + # Non-positive entries are dropped, valid ones survive + durations_file.write_text( + '{"tests/integration/test_a.py": 12.5, "tests/integration/test_b.py": -1}' + ) + assert determine_jobs.load_integration_durations() == { + "tests/integration/test_a.py": 12.5 + } + # One non-numeric entry cannot discard the whole recording + durations_file.write_text( + '{"tests/integration/test_a.py": 12.5, "tests/integration/test_b.py": null}' + ) + assert determine_jobs.load_integration_durations() == { + "tests/integration/test_a.py": 12.5 + } + # A non-dict top level degrades to empty + durations_file.write_text("[12.5]") + assert determine_jobs.load_integration_durations() == {} + + +def test_committed_integration_durations_are_sane() -> None: + """The committed recording itself holds positive bounded floats.""" + raw = json.loads( + (Path(helpers.root_path) / helpers.INTEGRATION_TEST_DURATIONS_FILE).read_text() + ) + assert raw, "committed durations file missing or empty" + assert all(isinstance(v, (int, float)) and 0 < v < 86400 for v in raw.values()) + assert all(k.startswith("tests/integration/test_") for k in raw) diff --git a/tests/script/test_helpers.py b/tests/script/test_helpers.py index 38b8c57368..7d4059da2f 100644 --- a/tests/script/test_helpers.py +++ b/tests/script/test_helpers.py @@ -2120,3 +2120,30 @@ def test_get_cpp_changed_components_independent_of_cwd( assert helpers.get_cpp_changed_components( ["tests/components/time/__init__.py"] ) == ["time"] + + +def test_lpt_partition_balances_skewed_weights() -> None: + """Heavy items spread across groups instead of clustering.""" + items = [f"i{n}" for n in range(6)] + weights = {"i0": 100.0, "i1": 90.0, "i2": 10.0, "i3": 10.0, "i4": 5.0, "i5": 5.0} + groups = helpers.lpt_partition(items, weights, 2) + group_weights = sorted(sum(weights[i] for i in g) for g in groups) + # Contiguous split would give 200 vs 20; LPT lands at 110 vs 110 + assert group_weights == [110.0, 110.0] + assert sorted(i for g in groups for i in g) == items + + +def test_lpt_partition_more_groups_than_items() -> None: + """Surplus groups come back empty; every item still lands somewhere.""" + items = ["a", "b"] + groups = helpers.lpt_partition(items, {"a": 1.0, "b": 1.0}, 4) + assert len(groups) == 4 + assert sorted(i for g in groups for i in g) == items + assert sum(not g for g in groups) == 2 + + +def test_lpt_partition_tie_determinism() -> None: + """Equal weights assign in input order, so output is reproducible.""" + items = [f"i{n}" for n in range(4)] + weights = dict.fromkeys(items, 1.0) + assert helpers.lpt_partition(items, weights, 2) == [["i0", "i2"], ["i1", "i3"]] diff --git a/tests/script/test_platformio_install_deps.py b/tests/script/test_platformio_install_deps.py new file mode 100644 index 0000000000..a263d7937f --- /dev/null +++ b/tests/script/test_platformio_install_deps.py @@ -0,0 +1,649 @@ +"""Tests for script/platformio_install_deps.py.""" + +from argparse import Namespace +import importlib.util +import inspect +from pathlib import Path +import shutil +import sys +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +from platformio import fs +from platformio.cache import ContentCache +from platformio.exception import InvalidJSONFile +from platformio.package.manager._install import PackageManagerInstallMixin +from platformio.package.manager.base import BasePackageManager +from platformio.package.manager.library import LibraryPackageManager +from platformio.package.manager.tool import ToolPackageManager +from platformio.package.meta import PackageCompatibility, PackageItem, PackageSpec +import pytest +from semantic_version import Version + +_SCRIPT = Path(__file__).parents[2] / "script" / "platformio_install_deps.py" + + +def _load_script(): + spec = importlib.util.spec_from_file_location("platformio_install_deps", _SCRIPT) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + # The real ContentCache would create dirs under the user's core dir + module.ContentCache = lambda *_: None + return module + + +def test_spec_key_collapses_destinations() -> None: + """Two specs delivering one package share a directory and one key.""" + mod = _load_script() + assert mod.spec_key("esphome/noise-c @ 0.1.21") == "noise-c" + assert mod.spec_key("esphome/noise-c@0.1.21") == "noise-c" + assert mod.spec_key("ESP32Async/AsyncTCP @ ^3.4.10") == mod.spec_key( + "esp32async/asynctcp @ 3.5.0" + ) + url = "https://github.com/pioarduino/platform-espressif32/releases/download/{v}/platform-espressif32.zip" + assert mod.spec_key(url.format(v="55.03.311")) == mod.spec_key( + url.format(v="54.03.20") + ) + + +def test_parse_specs_and_cli_args(tmp_path: Path) -> None: + """Parsing skips unpinned and interpolated entries; the CLI rebuild + keeps the original flag pairing.""" + ini = tmp_path / "platformio.ini" + ini.write_text( + "[env:a]\n" + "platform = fake/platform@1\n" + "lib_deps =\n" + " esphome/noise-c @ 0.1.21\n" + " ${common.lib_deps}\n" + " internal_lib\n" + "[env:b]\n" + "lib_deps =\n" + " esphome/noise-c @ 0.1.21\n" + ) + mod = _load_script() + args = Namespace(libraries=True, platforms=True, tools=False) + libs, platforms, tools = mod.parse_specs(str(ini), args) + # exact-string duplicates collapse; distinct version pins survive + assert libs == ["esphome/noise-c @ 0.1.21"] + assert platforms == ["fake/platform@1"] + assert tools == [] + assert mod.build_cli_args(libs, platforms, tools) == [ + "-l", + "esphome/noise-c @ 0.1.21", + "-p", + "fake/platform@1", + ] + + +class _FakeManager: + """Scripted manager_cls: records installs, raises on demand.""" + + installed: set = set() + fail: set = set() + calls: list = [] + lock_events: list = [] + base_dir: str = "" # per-test tmp base; set by _reset_fake + + def __init__(self, package_dir) -> None: + assert package_dir is None + + @staticmethod + def _key(spec) -> str: + return spec if isinstance(spec, str) else str(spec) + + def get_package(self, spec): + if self._key(spec) in self.installed: + return SimpleNamespace(path="/tmp/fake-pkg", spec=self._key(spec)) + return None + + def memcache_reset(self) -> None: + type(self).resets = getattr(type(self), "resets", 0) + 1 + + @property + def package_dir(self) -> str: + return str(Path(type(self).base_dir) / "packages") + + def get_download_dir(self) -> str: + return str(Path(type(self).base_dir) / "downloads") + + def get_tmp_dir(self) -> str: + return str(Path(type(self).base_dir) / "tmp") + + def lock(self) -> None: + type(self).lock_events.append("lock") + + def unlock(self) -> None: + type(self).lock_events.append("unlock") + + def _install(self, spec, skip_dependencies, compatibility=None): + assert skip_dependencies is True + if self._key(spec) in self.fail: + raise RuntimeError("boom") + type(self).calls.append(spec) + type(self).compat_calls.append((self._key(spec), compatibility)) + type(self).installed.add(self._key(spec)) # atomic under the GIL + + def get_pkg_dependencies(self, pkg): + return getattr(type(self), "deps", {}).get(pkg.spec) + + dependency_to_spec = staticmethod(BasePackageManager.dependency_to_spec) + + +def _reset_fake(base_dir: str = "", **kwargs) -> type: + # A fresh subclass per test: nothing leaks between tests through the + # class-level scripted state + return type( + "_ScriptedManager", + (_FakeManager,), + { + "base_dir": base_dir, + "installed": kwargs.get("installed", set()), + "fail": kwargs.get("fail", set()), + "calls": [], + "compat_calls": [], + "lock_events": [], + }, + ) + + +def test_parallel_install_empty_specs_is_a_no_op(tmp_path: Path) -> None: + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + mod.parallel_install(cls, []) + assert cls.calls == [] and cls.lock_events == [] + + +def test_parallel_install_behavior(tmp_path: Path) -> None: + """Duplicates collapse to one install, installed specs are filtered, + URL specs stay out of the wave, and the lock wraps the pool.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), installed={"esphome/already @ 1.0"}) + mod.parallel_install( + cls, + [ + "esphome/noise-c @ 0.1.21", + "esphome/noise-c @ 0.1.21", + "esphome/already @ 1.0", + "https://x/framework.tar.xz", + ], + ) + assert cls.calls == ["esphome/noise-c @ 0.1.21"] + assert cls.lock_events == ["lock", "unlock"] + + +def test_parallel_install_failure_cleans_torn_destination( + tmp_path: Path, capsys +) -> None: + """A failed install resets the memcache, removes what get_package can + see, and reports; the others still install.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + + removed = [] + + torn = str(tmp_path / "packages" / "torn-pkg") # never created; only rmtree'd + + def get_package(self, spec): + if spec == "esphome/bad @ 1.0" and getattr(cls, "resets", 0): + return SimpleNamespace(path=torn, spec=spec) + return _FakeManager.get_package(self, spec) + + cls.get_package = get_package # throwaway subclass; nothing to restore + with patch.object(mod.fs, "rmtree", side_effect=removed.append): + mod.parallel_install(cls, ["esphome/bad @ 1.0", "esphome/good @ 1.0"]) + assert "esphome/good @ 1.0" in cls.calls + assert removed == [torn] + out = capsys.readouterr().out + assert "Pre-install of esphome/bad @ 1.0 failed" in out + assert "Pre-install failed for 1 of 2 package(s)" in out + + +def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None: + """Dependencies of wave-installed packages install in a second wave, + deduped by name; name-only platform libs stay with the serial pass.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + cls.deps = { + "esphome/noise-c @ 0.1.21": [ + {"owner": "esphome", "name": "libsodium", "version": "^1.0"}, + {"name": "SPI"}, + ], + "esphome/wg @ 1.0": [ + {"owner": "esphome", "name": "libsodium", "version": "^1.0"}, + ], + } + mod.parallel_install(cls, ["esphome/noise-c @ 0.1.21", "esphome/wg @ 1.0"]) + assert len(cls.calls) == 3 # the shared dep installs exactly once + assert {mod.spec_key(c) for c in cls.calls} == {"noise-c", "wg", "libsodium"} + # Wave-1 strings carry no compatibility; the dependency wave does + compats = dict(cls.compat_calls) + assert compats["esphome/noise-c @ 0.1.21"] is None + dep_compat = next(v for k, v in cls.compat_calls if "libsodium" in k) + assert dep_compat is not None # mirrors pio's install_dependency + + +def test_dependency_wave_excludes_url_specs(tmp_path: Path) -> None: + """A dependency pinned to a URL surfaces as spec.uri; it must stay out + of the wave like string URL specs do.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + cls.deps = { + "esphome/noise-c @ 0.1.21": [ + {"name": "vendored", "version": "https://github.com/x/y.git"}, + ], + } + mod.parallel_install(cls, ["esphome/noise-c @ 0.1.21"]) + assert {mod.spec_key(c) for c in cls.calls} == {"noise-c"} + + +def test_failed_cleanup_fails_the_build(tmp_path: Path) -> None: + """A torn destination still on disk after rmtree must fail the build: + fs.rmtree never raises (its onexc handler prints), so only the + destination's absence proves the cleanup worked.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + torn = tmp_path / "packages" / "torn-pkg" + torn.mkdir(parents=True) + + def get_package(self, spec): + if getattr(cls, "resets", 0): + return SimpleNamespace(path=str(torn), spec=spec) + return None + + cls.get_package = get_package # throwaway subclass; nothing to restore + with ( + patch.object(mod.fs, "rmtree", lambda path: None), # onexc swallowed + pytest.raises(mod.CleanupError, match="could not remove"), + ): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert cls.lock_events == ["lock", "unlock"] # still released + + +def test_unverifiable_torn_destination_fails_the_build(tmp_path: Path) -> None: + """When the scan fails, the spec's own .piopm decides: an unremovable + leftover fails the build.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + dest = Path(cls.base_dir) / "packages" / "bad" + dest.mkdir(parents=True) + (dest / ".piopm").write_text('{"spec": {"owner": "esphome", "name": "bad"}}') + + def bad_reset(self): + raise OSError("scan broken") + + cls.memcache_reset = bad_reset + with ( + patch.object(mod.fs, "rmtree", lambda path: None), # onexc swallowed + pytest.raises(mod.CleanupError, match="could not remove"), + ): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + + +def test_unverifiable_scan_without_leftover_degrades(tmp_path: Path, capsys) -> None: + """A failing scan with no destination on disk is never a build + failure blaming this spec.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + resets = {"n": 0} + + def bad_reset(self): + # Fail clean_torn's reset; the coordinator's later reset works + resets["n"] += 1 + if resets["n"] <= 1: + raise OSError("scan broken") + + cls.memcache_reset = bad_reset + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert "No resolvable destination to clean" in capsys.readouterr().out + + +def test_unresolvable_torn_destination_is_printed(tmp_path: Path, capsys) -> None: + """A failed install with no resolvable package prints, so an invisible + torn directory is at least traceable.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert "No resolvable destination to clean" in capsys.readouterr().out + + +def test_unparsable_torn_destination_is_removed(tmp_path: Path, capsys) -> None: + """A torn dir get_package cannot resolve but whose .piopm names the + spec is removed instead of surviving into the serial pass.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + dest = Path(cls.base_dir) / "packages" / "bad" + dest.mkdir(parents=True) + (dest / ".piopm").write_text('{"spec": {"owner": "esphome", "name": "bad"}}') + + with patch.object(mod.fs, "rmtree", shutil.rmtree): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert not dest.exists() + assert "Removed torn destination" in capsys.readouterr().out + + +def test_parse_specs_tools_branch(tmp_path: Path) -> None: + """platform_packages parsing keeps owner'd tools and rewrites github + URL pins to bare URLs the wave then skips via parsed.uri.""" + mod = _load_script() + ini = tmp_path / "platformio.ini" + ini.write_text( + "[env:t]\n" + "platform_packages =\n" + " ${common.platform_packages}\n" + " platformio/tool-scons@~4.40801.0\n" + " framework-arduinopico@https://github.com/earlephilhower/arduino-pico/releases/download/6.0.0/rp2040-6.0.0.zip\n" + ) + args = Namespace(libraries=False, platforms=False, tools=True) + libs, platforms, tools = mod.parse_specs(str(ini), args) + assert libs == [] and platforms == [] + assert tools == [ + "platformio/tool-scons@~4.40801.0", + "https://github.com/earlephilhower/arduino-pico/releases/download/6.0.0/rp2040-6.0.0.zip", + ] + assert mod.build_cli_args([], [], tools)[:2] == ["-t", tools[0]] + + +def test_warm_store_still_walks_dependencies(tmp_path: Path) -> None: + """Already-installed top-level packages still feed the dependency + wave; a warm store can be missing a transitive dep.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.21"}) + cls.deps = { + "esphome/noise-c @ 0.1.21": [ + {"owner": "esphome", "name": "libsodium", "version": "^1.0"}, + ], + } + mod.parallel_install(cls, ["esphome/noise-c @ 0.1.21"]) + assert [mod.spec_key(c) for c in cls.calls] == ["libsodium"] + + +def test_worker_system_exit_still_cleans(tmp_path: Path, capsys) -> None: + """A worker SystemExit runs the torn cleanup before propagating; the + serial pass must never trust its leftovers.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + torn = tmp_path / "packages" / "torn-pkg" + torn.mkdir(parents=True) + + def exiting_install(self, spec, skip_dependencies, compatibility=None): + raise SystemExit(0) + + def get_package(self, spec): + if getattr(cls, "resets", 0): + return SimpleNamespace(path=str(torn), spec=spec) + return None + + cls._install = exiting_install + cls.get_package = get_package + + def real_rmtree(path): + Path(path).rmdir() + + with ( + patch.object(mod.fs, "rmtree", real_rmtree), + pytest.raises(SystemExit), + ): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert not torn.exists() + + +def test_unlock_failure_is_fatal(tmp_path: Path) -> None: + """A failed unlock must fail the build: the serial pass in another + process would block on the held flock.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + + def bad_unlock(self): + raise OSError("flock broke") + + cls.unlock = bad_unlock + with pytest.raises(mod.LockReleaseError, match="manager lock"): + mod.parallel_install(cls, ["esphome/good @ 1.0"]) + + +def test_unlock_failure_keeps_inflight_error_as_context(tmp_path: Path) -> None: + """An in-flight CleanupError stays attached when the unlock fault + takes over the raise.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + torn = tmp_path / "packages" / "bad" + torn.mkdir(parents=True) + + def get_package(self, spec): + if getattr(cls, "resets", 0): + return SimpleNamespace(path=str(torn), spec=spec) + return None + + def bad_unlock(self): + raise OSError("flock broke") + + cls.get_package = get_package + cls.unlock = bad_unlock + with ( + patch.object(mod.fs, "rmtree", lambda path: None), # leaves torn + pytest.raises(mod.LockReleaseError) as err, + ): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert isinstance(err.value.__cause__.__context__, mod.CleanupError) + + +def test_chdir_failure_does_not_fail_the_wave(tmp_path: Path, monkeypatch) -> None: + """A lost cwd is suppressed: further waves may misbehave and fall to + the serial pass, whose cwd is pinned.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + monkeypatch.setattr(mod.os, "chdir", MagicMock(side_effect=OSError("gone"))) + mod.parallel_install(cls, ["esphome/good @ 1.0"]) + assert cls.calls == ["esphome/good @ 1.0"] + + +def test_piopm_match_removes_manifest_named_torn_dir(tmp_path: Path, capsys) -> None: + """A torn dir named by its manifest (not the registry spec) is found + through its .piopm and removed.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + torn = tmp_path / "packages" / "ManifestName" + torn.mkdir(parents=True) + (torn / ".piopm").write_text('{"spec": {"owner": "esphome", "name": "bad"}}') + innocent = tmp_path / "packages" / "innocent" + innocent.mkdir() + (innocent / ".piopm").write_text('{"spec": {"owner": "o", "name": "other"}}') + with patch.object(mod.fs, "rmtree", shutil.rmtree): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert not torn.exists() + assert innocent.exists() # another package's valid metadata survives + assert "Removed torn destination" in capsys.readouterr().out + + +def test_unscannable_package_dir_fails_the_build(tmp_path: Path) -> None: + """A storage dir the cleanup cannot scan is not proof of cleanliness.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + real_iterdir = Path.iterdir + + def broken_iterdir(self): + if self.name == "packages": + raise PermissionError("denied") + return real_iterdir(self) + + with ( + patch.object(Path, "iterdir", broken_iterdir), + pytest.raises(mod.CleanupError, match="cleanup failed"), + ): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + + +def test_stray_file_in_package_dir_is_ignored(tmp_path: Path) -> None: + """A plain file (or a pio-link) beside the packages is skipped by + pio's own scan and must never hard-fail the build.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + (tmp_path / "packages").mkdir(parents=True) + (tmp_path / "packages" / "stray.pio-link").write_text("x") + (tmp_path / "packages" / "no-metadata").mkdir() # pio overwrites these + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert (tmp_path / "packages" / "stray.pio-link").exists() + assert (tmp_path / "packages" / "no-metadata").exists() + + +def test_unreadable_piopm_dir_is_removed(tmp_path: Path) -> None: + """A persistently corrupt .piopm under this spec's own name would + crash pio's storage scan; the dir is removed rather than left to + break the serial pass.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + torn = tmp_path / "packages" / "bad" + torn.mkdir(parents=True) + (torn / ".piopm").write_text("{not json") + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert not torn.exists() + + +def test_unreadable_piopm_under_other_name_survives(tmp_path: Path) -> None: + """A corrupt .piopm in another package's dir may be a worker mid-copy; + a failing spec must not remove a directory it does not own.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + other = tmp_path / "packages" / "innocent" + other.mkdir(parents=True) + (other / ".piopm").write_text("{not json") + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + assert other.exists() + + +def test_unexpected_cleanup_class_becomes_cleanup_error(tmp_path: Path) -> None: + """Cleanup failures of any class fail the build; nothing may be + downgraded to the serial fallback over a torn directory.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path), fail={"esphome/bad @ 1.0"}) + + with ( + patch.object( + mod, "piopm_matches", MagicMock(side_effect=ValueError("bad spec")) + ), + pytest.raises(mod.CleanupError, match="cleanup failed"), + ): + mod.parallel_install(cls, ["esphome/bad @ 1.0"]) + + +def test_main_cleanup_error_fails_before_generic_fallback(tmp_path: Path) -> None: + """A CleanupError must escape main's serial fallback: the clause order + decides whether a stuck torn package fails the image build.""" + mod = _load_script() + ini = tmp_path / "platformio.ini" + ini.write_text("[env:t]\nlib_deps =\n esphome/x @ 1.0\n") + with ( + patch.object( + mod, "parallel_install", side_effect=mod.CleanupError("stuck torn pkg") + ), + patch.object(mod.subprocess, "check_call"), + patch.object(sys, "argv", ["platformio_install_deps.py", str(ini), "-l"]), + pytest.raises(mod.CleanupError), + ): + mod.main() + + +def test_main_generic_failure_still_runs_serial_pass(tmp_path: Path) -> None: + """A non-CleanupError wave failure prints, dumps the traceback, and + still reaches the authoritative serial pass with the pinned cwd.""" + mod = _load_script() + ini = tmp_path / "platformio.ini" + ini.write_text("[env:t]\nlib_deps =\n esphome/x @ 1.0\n") + with ( + patch.object(mod, "parallel_install", side_effect=RuntimeError("boom")), + patch.object(mod.subprocess, "check_call") as mock_call, + patch.object(sys, "argv", ["platformio_install_deps.py", str(ini), "-l"]), + ): + mod.main() + mock_call.assert_called_once() + args, kwargs = mock_call.call_args + assert args[0][:4] == ["platformio", "pkg", "install", "-g"] + assert "esphome/x @ 1.0" in args[0] + assert kwargs["cwd"] == Path.cwd() + + +def test_content_cache_creates_its_dir(tmp_path: Path, monkeypatch) -> None: + """The cold-cache hardening relies on ContentCache.__init__ creating + the namespace dir; pin the side effect, not mere callability.""" + monkeypatch.setenv("PLATFORMIO_CACHE_DIR", str(tmp_path / "cache")) + ContentCache("http") + assert (tmp_path / "cache" / "http").is_dir() + + +def test_piopm_matches_without_name_matches_nothing(tmp_path: Path) -> None: + """A spec with no derivable name can never match a directory.""" + mod = _load_script() + assert mod.piopm_matches(str(tmp_path), "") == [] + + +def test_unresolvable_spec_stays_out_of_the_wave(tmp_path: Path, capsys) -> None: + """A spec with no derivable name is left to the serial pass; a raw + string key would break the one-per-destination dedupe.""" + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + nameless = PackageSpec(requirements="^1.0") + mod.parallel_install(cls, [nameless]) + assert cls.calls == [] + assert "Skipping unresolvable spec" in capsys.readouterr().out + + +def test_parallel_install_unlocks_when_pool_fails(tmp_path: Path) -> None: + mod = _load_script() + cls = _reset_fake(str(tmp_path)) + with ( + patch.object(mod, "ThreadPoolExecutor", side_effect=RuntimeError("no")), + pytest.raises(RuntimeError), + ): + mod.parallel_install(cls, ["esphome/a @ 1.0"]) + assert cls.lock_events == ["lock", "unlock"] + + +def test_parse_specs_unreadable_ini_fails_loudly(tmp_path: Path) -> None: + """A bad path must not silently build an image with no dependencies.""" + mod = _load_script() + args = Namespace(libraries=True, platforms=False, tools=False) + with pytest.raises(SystemExit): + mod.parse_specs(str(tmp_path / "missing.ini"), args) + + +def test_platformio_surface_for_install_deps_script() -> None: + """A PlatformIO bump that changes these members must fail here, not + silently turn the docker image's parallel preinstall into a no-op.""" + # The script calls these positionally; pin the positions, not just + # membership, so a parameter reorder trips the wire too + params = inspect.signature(PackageManagerInstallMixin._install).parameters + assert list(params)[1] == "spec" + assert "skip_dependencies" in params + assert "compatibility" in params + for cls in (ToolPackageManager, LibraryPackageManager): + assert list(inspect.signature(cls.__init__).parameters)[1] == "package_dir" + for name in ( + "lock", + "unlock", + "get_package", + "memcache_reset", + "get_pkg_dependencies", + "dependency_to_spec", + "get_download_dir", + "get_tmp_dir", + ): + assert callable(getattr(BasePackageManager, name)) + # Losing any of these turns the wave into main()'s silent serial + # fallback: ensure_spec runs in the coordinator, the spec attributes + # feed the dedupe, cleanup, and dependency filters + assert callable(BasePackageManager.ensure_spec) + spec = PackageSpec("owner/name @ ^1.0") + assert spec.name == "name" + assert spec.owner == "owner" + assert spec.uri is None + assert spec.external is False + assert Version("1.5.0") in spec.requirements + # The failure-cleanup path degrades to a single line if these vanish + assert callable(fs.rmtree) + assert callable(fs.load_json) + # piopm_matches only tolerates a corrupt .piopm through this base; + # losing it would flip a wave failure from degrade to build failure + assert issubclass(InvalidJSONFile, ValueError) + assert PackageItem("pkg-dir").path == "pkg-dir" + assert callable(PackageCompatibility.from_dependency) diff --git a/tests/script/test_update_integration_test_durations.py b/tests/script/test_update_integration_test_durations.py new file mode 100644 index 0000000000..f2f373d4bb --- /dev/null +++ b/tests/script/test_update_integration_test_durations.py @@ -0,0 +1,130 @@ +"""Unit tests for script/update_integration_test_durations.py.""" + +import json +from pathlib import Path +import sys +from unittest.mock import patch + +import pytest + +# Add the script directory to Python path so we can import the module +script_dir = str((Path(__file__).parent / ".." / ".." / "script").resolve()) +sys.path.insert(0, script_dir) + +import helpers # noqa: E402 +import update_integration_test_durations as uitd # noqa: E402 + +JUNIT_TEMPLATE = """ +{testcases} +""" + +KNOWN = { + "tests/integration/test_a.py", + "tests/integration/test_b.py", +} + + +def _write_junit(path: Path, testcases: str) -> None: + path.write_text(JUNIT_TEMPLATE.format(testcases=testcases), encoding="utf-8") + + +def test_collect_durations_sums_per_file(tmp_path: Path) -> None: + """Testcases from the same module sum.""" + _write_junit( + tmp_path / "a.xml", + '' + '' + '', + ) + assert uitd.collect_durations(tmp_path, KNOWN) == { + "tests/integration/test_a.py": 3.5, + "tests/integration/test_b.py": 4.0, + } + + +def test_collect_durations_class_based_testcase(tmp_path: Path) -> None: + """A class-based classname still maps to its module file.""" + _write_junit( + tmp_path / "a.xml", + '', + ) + assert uitd.collect_durations(tmp_path, KNOWN) == { + "tests/integration/test_a.py": 2.5 + } + + +def test_collect_durations_unknown_module_skipped( + tmp_path: Path, capsys: pytest.CaptureFixture[str] +) -> None: + """A classname that maps to no known file is skipped with a warning.""" + _write_junit( + tmp_path / "a.xml", + '', + ) + assert uitd.collect_durations(tmp_path, KNOWN) == {} + assert "test_gone" in capsys.readouterr().err + + +def test_collect_durations_skips_skipped_testcases(tmp_path: Path) -> None: + """Skipped testcases do not record a bogus zero duration.""" + _write_junit( + tmp_path / "a.xml", + '' + "", + ) + assert uitd.collect_durations(tmp_path, KNOWN) == {} + + +def test_collect_durations_unexpected_classname_aborts(tmp_path: Path) -> None: + """A classname outside tests.integration means the junit layout changed.""" + _write_junit( + tmp_path / "a.xml", + '', + ) + with pytest.raises(SystemExit): + uitd.collect_durations(tmp_path, KNOWN) + + +def test_collect_durations_empty_dir_aborts(tmp_path: Path) -> None: + """No junit XML at all is a hard error, not an empty recording.""" + with pytest.raises(SystemExit): + uitd.collect_durations(tmp_path, KNOWN) + + +def test_main_merges_partial_run(tmp_path: Path) -> None: + """A partial run merges over the previous data instead of truncating it.""" + tests_dir = tmp_path / "tests" / "integration" + tests_dir.mkdir(parents=True) + for name in ("test_a", "test_b", "test_c"): + (tests_dir / f"{name}.py").write_text("", encoding="utf-8") + durations_file = tmp_path / helpers.INTEGRATION_TEST_DURATIONS_FILE + durations_file.write_text( + json.dumps( + { + "tests/integration/test_a.py": 5.0, + "tests/integration/test_b.py": 7.0, + "tests/integration/test_gone.py": 9.0, + } + ), + encoding="utf-8", + ) + junit_dir = tmp_path / "junit" + junit_dir.mkdir() + _write_junit( + junit_dir / "a.xml", + '', + ) + with ( + patch.object(helpers, "root_path", str(tmp_path)), + patch.object(uitd, "DURATIONS_FILE", durations_file), + ): + # 1 of 3 files covered: refused without --allow-partial + with patch.object(sys, "argv", ["uitd", str(junit_dir)]): + assert uitd.main() == uitd.EXIT_LOW_COVERAGE + with patch.object(sys, "argv", ["uitd", str(junit_dir), "--allow-partial"]): + assert uitd.main() == 0 + # test_a updated, test_b kept, deleted test_gone dropped + assert json.loads(durations_file.read_text()) == { + "tests/integration/test_a.py": 6.0, + "tests/integration/test_b.py": 7.0, + } diff --git a/tests/test_build_components/common/uart_9600_even_7bits/esp32-ard.yaml b/tests/test_build_components/common/uart_9600_even_7bits/esp32-ard.yaml new file mode 100644 index 0000000000..f0d24b9a18 --- /dev/null +++ b/tests/test_build_components/common/uart_9600_even_7bits/esp32-ard.yaml @@ -0,0 +1,14 @@ +# Common UART configuration for ESP32 Arduino tests - 9600 baud, EVEN parity, 7 data bits + +substitutions: + tx_pin: GPIO17 + rx_pin: GPIO16 + +uart: + - id: uart_bus + tx_pin: ${tx_pin} + rx_pin: ${rx_pin} + baud_rate: 9600 + parity: EVEN + data_bits: 7 + stop_bits: 1 diff --git a/tests/test_build_components/common/uart_9600_even_7bits/esp32-idf.yaml b/tests/test_build_components/common/uart_9600_even_7bits/esp32-idf.yaml new file mode 100644 index 0000000000..e85fa7fc71 --- /dev/null +++ b/tests/test_build_components/common/uart_9600_even_7bits/esp32-idf.yaml @@ -0,0 +1,14 @@ +# Common UART configuration for ESP32 IDF tests - 9600 baud, EVEN parity, 7 data bits + +substitutions: + tx_pin: GPIO17 + rx_pin: GPIO16 + +uart: + - id: uart_bus + tx_pin: ${tx_pin} + rx_pin: ${rx_pin} + baud_rate: 9600 + parity: EVEN + data_bits: 7 + stop_bits: 1 diff --git a/tests/test_build_components/common/uart_9600_even_7bits/esp8266-ard.yaml b/tests/test_build_components/common/uart_9600_even_7bits/esp8266-ard.yaml new file mode 100644 index 0000000000..488bfdbeab --- /dev/null +++ b/tests/test_build_components/common/uart_9600_even_7bits/esp8266-ard.yaml @@ -0,0 +1,14 @@ +# Common UART configuration for ESP8266 Arduino tests - 9600 baud even parity, 7 data bits + +substitutions: + tx_pin: GPIO4 + rx_pin: GPIO5 + +uart: + - id: uart_bus + tx_pin: ${tx_pin} + rx_pin: ${rx_pin} + baud_rate: 9600 + parity: EVEN + data_bits: 7 + stop_bits: 1 diff --git a/tests/test_build_components/common/uart_9600_even_7bits/rp2040-ard.yaml b/tests/test_build_components/common/uart_9600_even_7bits/rp2040-ard.yaml new file mode 100644 index 0000000000..08bec00820 --- /dev/null +++ b/tests/test_build_components/common/uart_9600_even_7bits/rp2040-ard.yaml @@ -0,0 +1,14 @@ +# Common UART configuration for RP2040 Arduino tests - 9600 baud even parity, 7 data bits + +substitutions: + tx_pin: GPIO0 + rx_pin: GPIO1 + +uart: + - id: uart_bus + tx_pin: ${tx_pin} + rx_pin: ${rx_pin} + baud_rate: 9600 + parity: EVEN + data_bits: 7 + stop_bits: 1 diff --git a/tests/unit_tests/build_gen/test_build_tool.py b/tests/unit_tests/build_gen/test_build_tool.py new file mode 100644 index 0000000000..b029c647ab --- /dev/null +++ b/tests/unit_tests/build_gen/test_build_tool.py @@ -0,0 +1,246 @@ +"""Tests for the ninja build-tool helper script.""" + +from __future__ import annotations + +from pathlib import Path +import subprocess +import sys +from unittest.mock import MagicMock, patch + +import pytest + +from esphome.build_gen import build_tool + + +def test_ar_removes_stale_archive(tmp_path: Path) -> None: + archive = tmp_path / "lib.a" + archive.write_text("stale") + rsp = tmp_path / "lib.a.rsp" + rsp.write_text("a.o\n") + with ( + patch.object( + build_tool.sys, + "argv", + ["build_tool", "ar", "ar-bin", str(archive), str(rsp)], + ), + patch.object( + build_tool.subprocess, "run", return_value=MagicMock(returncode=0) + ) as mock_run, + ): + assert build_tool.main() == 0 + assert not archive.exists() + # The rspfile is expanded by the shim (GNU ar would escape backslashes) + assert mock_run.call_args[0][0] == ["ar-bin", "rcs", str(archive), "a.o"] + + +def test_copy(tmp_path: Path) -> None: + src = tmp_path / "firmware.bin" + src.write_text("data") + dst = tmp_path / "firmware.factory.bin" + with patch.object( + build_tool.sys, "argv", ["build_tool", "copy", str(src), str(dst)] + ): + assert build_tool.main() == 0 + assert dst.read_text() == "data" + + +def test_unknown_mode(capsys: pytest.CaptureFixture[str]) -> None: + with patch.object(build_tool.sys, "argv", ["build_tool", "bogus"]): + assert build_tool.main() == 1 + assert "unknown build_tool mode" in capsys.readouterr().err + + +def test_runs_as_script(tmp_path: Path) -> None: + """The ninja rules invoke the file as a plain script.""" + + src = tmp_path / "a.bin" + src.write_text("x") + dst = tmp_path / "b.bin" + result = subprocess.run( + [sys.executable, build_tool.__file__, "copy", str(src), str(dst)], + check=False, + ) + assert result.returncode == 0 + assert dst.read_text() == "x" + + +def test_ar_expands_rspfile_without_escaping(tmp_path) -> None: + """Backslash paths survive: the shim expands the rspfile itself instead + of letting GNU ar treat backslashes as escapes.""" + rsp = tmp_path / "objs.rsp" + rsp.write_text("obj/a.o\nsub\\b.o\n") + with ( + patch.object( + build_tool.sys, + "argv", + ["build_tool", "ar", "ar-bin", str(tmp_path / "lib.a"), str(rsp)], + ), + patch.object( + build_tool.subprocess, "run", return_value=MagicMock(returncode=0) + ) as mock_run, + ): + assert build_tool.main() == 0 + assert mock_run.call_args[0][0] == [ + "ar-bin", + "rcs", + str(tmp_path / "lib.a"), + "obj/a.o", + "sub\\b.o", + ] + + +def test_ar_unquotes_ninja_escaped_paths(tmp_path: Path) -> None: + """The shim strips a simple surrounding quote, since ninja shell- + quotes special rsp paths, so ar sees the real filename.""" + rsp = tmp_path / "t.rsp" + rsp.write_text("'obj/a b.o'\nobj/c.o\n") + with ( + patch.object( + build_tool.sys, "argv", ["bt", "ar", "/usr/bin/ar", "lib.a", str(rsp)] + ), + patch.object(build_tool.subprocess, "run") as mock_run, + ): + mock_run.return_value.returncode = 0 + rc = build_tool.main() + assert rc == 0 + assert mock_run.call_args.args[0] == [ + "/usr/bin/ar", + "rcs", + "lib.a", + "obj/a b.o", + "obj/c.o", + ] + + +def test_ar_empty_object_list_fails( + tmp_path: Path, capsys: pytest.CaptureFixture[str] +) -> None: + """A lost object list is an error here, not undefined symbols at link.""" + rsp = tmp_path / "t.rsp" + rsp.write_text("\n\n") + with patch.object( + build_tool.sys, "argv", ["bt", "ar", "/usr/bin/ar", "lib.a", str(rsp)] + ): + rc = build_tool.main() + assert rc == 1 + assert "no objects listed" in capsys.readouterr().err + + +def test_ar_batches_long_object_lists(tmp_path: Path) -> None: + """The expanded argv must stay under the Windows 32767-char limit: a + long object list creates with rcs, then appends with qs.""" + archive = tmp_path / "lib.a" + rsp = tmp_path / "lib.a.rsp" + objects = [f"dir/{'x' * 120}_{i}.o" for i in range(400)] + rsp.write_text("\n".join(objects) + "\n") + with ( + patch.object( + build_tool.sys, + "argv", + ["build_tool", "ar", "ar-bin", str(archive), str(rsp)], + ), + patch.object( + build_tool.subprocess, "run", return_value=MagicMock(returncode=0) + ) as mock_run, + ): + assert build_tool.main() == 0 + calls = [c[0][0] for c in mock_run.call_args_list] + assert len(calls) > 1 + assert calls[0][1] == "rcs" + assert all(c[1] == "qs" for c in calls[1:]) + assert [o for c in calls for o in c[3:]] == objects + assert all(sum(len(a) + 1 for a in c) < 32000 for c in calls) + + +def test_ar_batch_failure_stops(tmp_path: Path) -> None: + """A failing batch propagates its exit code without running the rest.""" + archive = tmp_path / "lib.a" + rsp = tmp_path / "lib.a.rsp" + rsp.write_text("\n".join(f"{'y' * 200}_{i}.o" for i in range(300)) + "\n") + with ( + patch.object( + build_tool.sys, + "argv", + ["build_tool", "ar", "ar-bin", str(archive), str(rsp)], + ), + patch.object( + build_tool.subprocess, + "run", + side_effect=lambda cmd, **kw: ( + archive.write_text("partial"), + MagicMock(returncode=3), + )[1], + ) as mock_run, + ): + assert build_tool.main() == 3 + assert mock_run.call_count == 1 + # The failed batch must not leave a truncated archive behind + assert not archive.exists() + + +def test_ar_exception_leaves_no_partial_archive(tmp_path: Path) -> None: + """A missing ar binary mid-loop must not leave a truncated archive from + earlier successful batches.""" + archive = tmp_path / "lib.a" + rsp = tmp_path / "lib.a.rsp" + rsp.write_text("a.o\n") + with ( + patch.object( + build_tool.sys, + "argv", + ["build_tool", "ar", "ar-bin", str(archive), str(rsp)], + ), + patch.object( + build_tool.subprocess, + "run", + side_effect=lambda cmd, **kw: ( + archive.write_text("partial"), + (_ for _ in ()).throw(FileNotFoundError("no ar")), + ), + ), + pytest.raises(FileNotFoundError), + ): + build_tool.main() + assert not archive.exists() + + +def test_surplus_arguments_error(capsys: pytest.CaptureFixture[str]) -> None: + """A mis-specified ninja rule passing extra operands errors instead of + silently dropping them.""" + with patch.object( + build_tool.sys, "argv", ["build_tool", "copy", "a", "b", "extra"] + ): + assert build_tool.main() == 1 + assert "expected 2 arguments, got 3" in capsys.readouterr().err + + +def test_copy_same_file_keeps_the_input( + tmp_path: Path, capsys: pytest.CaptureFixture[str] +) -> None: + """A same-file copy (dst IS src) must not unlink the input, and fails + with a message and exit code like the other shim paths.""" + src = tmp_path / "firmware.bin" + src.write_bytes(b"image") + with patch.object( + build_tool.sys, "argv", ["build_tool", "copy", str(src), str(src)] + ): + assert build_tool.main() == 1 + assert src.read_bytes() == b"image" + assert "failed" in capsys.readouterr().err + + +def test_copy_failure_leaves_no_partial_output(tmp_path: Path) -> None: + """A failed copy unlinks the destination; a partial firmware image must + never be left on disk.""" + dst = tmp_path / "firmware.factory.bin" + dst.write_text("stale") + with ( + patch.object(build_tool.shutil, "copyfile", side_effect=OSError("disk full")), + patch.object( + build_tool.sys, + "argv", + ["build_tool", "copy", str(tmp_path / "src.bin"), str(dst)], + ), + ): + assert build_tool.main() == 1 + assert not dst.exists() diff --git a/tests/unit_tests/components/esp32/test_sdkconfig.py b/tests/unit_tests/components/esp32/test_sdkconfig.py new file mode 100644 index 0000000000..b5a562f4d1 --- /dev/null +++ b/tests/unit_tests/components/esp32/test_sdkconfig.py @@ -0,0 +1,72 @@ +"""Tests for the esp32 sdkconfig write and its toolchain-gated clean.""" + +from __future__ import annotations + +import os +from pathlib import Path +import time +from unittest.mock import patch + +import pytest + +from esphome.components.esp32 import _write_sdkconfig +from esphome.components.esp32.const import KEY_SDKCONFIG_OPTIONS +from esphome.const import KEY_CORE, KEY_ESP32, KEY_FRAMEWORK_VERSION, Toolchain +from esphome.core import CORE +from esphome.espidf.toolchain import has_outdated_files + + +def _setup_core(tmp_path: Path, toolchain: Toolchain | None) -> None: + CORE.config_path = tmp_path / "test.yaml" + CORE.build_path = tmp_path + CORE.toolchain = toolchain + CORE.data[KEY_ESP32] = {KEY_SDKCONFIG_OPTIONS: {"CONFIG_X": "y"}} + CORE.data[KEY_CORE] = {KEY_FRAMEWORK_VERSION: "5.5.5"} + + +def _seed_configured_build(tmp_path: Path) -> None: + """A settled native build: configure outputs predate what comes next.""" + build = tmp_path / "build" + (build / "config").mkdir(parents=True) + (build / "config" / "sdkconfig.h").write_text("") + (build / "CMakeCache.txt").write_text("") + (build / "build.ninja").write_text("") + # Explicitly older than what the test writes next: has_outdated_files() + # compares st_mtime with a strict >, so same-tick writes would pass + past = time.time() - 60 + for f in build.rglob("*"): + os.utime(f, (past, past)) + + +@pytest.mark.parametrize( + ("toolchain", "clean_expected"), + [(Toolchain.ESP_IDF, False), (Toolchain.PLATFORMIO, True), (None, True)], +) +def test_write_sdkconfig_cleans_only_on_platformio( + tmp_path: Path, toolchain: Toolchain | None, clean_expected: bool +) -> None: + """A changed sdkconfig forces a full clean only under PlatformIO; the + esp-idf toolchain reconfigures via has_outdated_files() instead; an + unresolved toolchain fails safe onto the clean.""" + _setup_core(tmp_path, toolchain) + _seed_configured_build(tmp_path) + with ( + patch.object(CORE, "name", "test"), + patch("esphome.components.esp32.clean_build") as clean, + ): + _write_sdkconfig() + assert "CONFIG_X" in CORE.relative_build_path("sdkconfig.test").read_text() + assert clean.called is clean_expected + if clean_expected: + clean.assert_called_once_with(clear_pio_cache=False) + # The change must still trigger a reconfigure: the internal + # sdkconfig snapshot is now newer than build/CMakeCache.txt + assert has_outdated_files() is True + clean.reset_mock() + # A settled configure restamps the cache; an unchanged rewrite + # must then neither clean nor mark the build stale + future = time.time() + 60 + os.utime(CORE.relative_build_path("build/CMakeCache.txt"), (future, future)) + _write_sdkconfig() + clean.assert_not_called() + assert has_outdated_files() is False diff --git a/tests/unit_tests/components/light/test_gamma_table.py b/tests/unit_tests/components/light/test_gamma_table.py index a302a355dc..75c3f18e42 100644 --- a/tests/unit_tests/components/light/test_gamma_table.py +++ b/tests/unit_tests/components/light/test_gamma_table.py @@ -53,9 +53,12 @@ def test_nonzero_indices_are_nonzero(gamma: float) -> None: assert table[i] >= 1, f"gamma={gamma}, index {i}: got {table[i]}" -@pytest.mark.parametrize("gamma", [1.0, 2.0, 2.2, 2.8, 3.0]) +@pytest.mark.parametrize("gamma", [1.0, 1.8, 2.0, 2.2, 2.8, 3.0, 4.0]) def test_table_monotonically_nondecreasing(gamma: float) -> None: - """The gamma table must be monotonically non-decreasing.""" + """The gamma table must be monotonically non-decreasing. + + gamma_table_reverse_search()'s binary search depends on this. + """ table = generate_gamma_table(gamma) for i in range(1, 256): assert table[i] >= table[i - 1], ( @@ -115,3 +118,13 @@ def test_lut_output_monotonically_nondecreasing() -> None: result = _simulate_gamma_correct_lut(table, value) assert result >= prev, f"value={value}: result {result} < previous {prev}" prev = result + + +def test_table_matches_raw_power_curve() -> None: + """Check the gamma table against known good values for gamma=2.8.""" + table = generate_gamma_table(2.8) + golden = {1: 1, 5: 1, 15: 24, 27: 122, 28: 135, 100: 4766, 200: 33193, 254: 64818} + for i, expected in golden.items(): + assert table[i] == expected, ( + f"index {i}: table[{i}]={table[i]} expected {expected}" + ) diff --git a/tests/unit_tests/core/test_config.py b/tests/unit_tests/core/test_config.py index e620f8ec7f..8ab3ad5d15 100644 --- a/tests/unit_tests/core/test_config.py +++ b/tests/unit_tests/core/test_config.py @@ -3,7 +3,6 @@ from collections.abc import Callable import os from pathlib import Path -import types from typing import Any from unittest.mock import MagicMock, Mock, patch @@ -705,33 +704,6 @@ def test_include_file_with_c_header( assert '#include "c_library.h"' in mock_raw_statement.text -def test_get_usable_cpu_count() -> None: - """Test get_usable_cpu_count returns CPU count.""" - count = config.get_usable_cpu_count() - assert isinstance(count, int) - assert count > 0 - - -def test_get_usable_cpu_count_with_process_cpu_count() -> None: - """Test get_usable_cpu_count uses process_cpu_count when available.""" - # Test with process_cpu_count (Python 3.13+) - # Create a mock os module with process_cpu_count - - mock_os = types.SimpleNamespace(process_cpu_count=lambda: 8, cpu_count=lambda: 4) - - with patch("esphome.core.config.os", mock_os): - # When process_cpu_count exists, it should be used - count = config.get_usable_cpu_count() - assert count == 8 - - # Test fallback to cpu_count when process_cpu_count not available - mock_os_no_process = types.SimpleNamespace(cpu_count=lambda: 4) - - with patch("esphome.core.config.os", mock_os_no_process): - count = config.get_usable_cpu_count() - assert count == 4 - - def test_list_target_platforms(tmp_path: Path) -> None: """Test _list_target_platforms returns available platforms.""" # Create mock components directory structure @@ -1155,6 +1127,34 @@ def test_config_hash_same_for_different_config_dirs(tmp_path: Path) -> None: assert hash1 == hash2 +def test_config_hash_same_for_different_data_dirs( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """Test that downloaded file paths hash the same wherever data_dir lives.""" + config_dir = tmp_path / "config" + config_dir.mkdir() + + CORE.reset() + CORE.config_path = config_dir / "device.yaml" + CORE.config = { + "esphome": {"name": "test"}, + "file": config_dir / ".esphome" / "image" / "c44630d6", + } + hash1 = CORE.config_hash + + other_data_dir = tmp_path / "data" + CORE.reset() + monkeypatch.setenv("ESPHOME_DATA_DIR", str(other_data_dir)) + CORE.config_path = config_dir / "device.yaml" + CORE.config = { + "esphome": {"name": "test"}, + "file": other_data_dir / "image" / "c44630d6", + } + hash2 = CORE.config_hash + + assert hash1 == hash2 + + def test_make_app_name_cpp_no_mac_simple() -> None: """Test simple name without MAC suffix returns string literal.""" cpp_expr, global_decl, byte_len = make_app_name_cpp( diff --git a/tests/unit_tests/test_arduino_library.py b/tests/unit_tests/test_arduino_library.py new file mode 100644 index 0000000000..87de28cf32 --- /dev/null +++ b/tests/unit_tests/test_arduino_library.py @@ -0,0 +1,1162 @@ +"""Tests for esphome.arduino.library (Arduino-core library resolution).""" + +from __future__ import annotations + +from contextlib import contextmanager +import json +import logging +from pathlib import Path +from unittest.mock import patch + +import pytest + +from esphome.arduino import library as component +from esphome.const import KEY_CORE, KEY_TARGET_PLATFORM, PLATFORM_ESP8266 +from esphome.core import CORE, EsphomeError, Library +import esphome.platformio.library as pio_library +from esphome.platformio.library import ( + ConvertedLibrary, + IncompatiblePlatform, + InvalidLibrary, + LibraryBackend, +) + + +@pytest.fixture(autouse=True) +def _reset_libraries() -> None: + # conftest's reset_core fixture clears platformio_libraries after each test + CORE.data[KEY_CORE] = {KEY_TARGET_PLATFORM: PLATFORM_ESP8266} + + +def _add_library(name: str, version: str | None, repository: str | None = None) -> None: + CORE.add_library(Library(name=name, version=version, repository=repository)) + + +def _make_framework(tmp_path: Path) -> Path: + framework = tmp_path / "framework" + lib = framework / "libraries" / "ESP8266WiFi" / "src" + lib.mkdir(parents=True) + (lib / "ESP8266WiFi.cpp").write_text("") + (lib / "ESP8266WiFi.h").write_text("") + (lib.parent / "library.properties").write_text("name=ESP8266WiFi\nversion=1.0\n") + root_lib = framework / "libraries" / "Wire" + root_lib.mkdir(parents=True) + (root_lib / "Wire.cpp").write_text("") + (root_lib / "examples").mkdir() + (root_lib / "examples" / "scan.ino").write_text("") + return framework + + +@contextmanager +def _emitting_converter(*converted): + """Patch convert_libraries to emit the given components via the backend.""" + + def fake_convert(libraries: list, backend: LibraryBackend) -> list: + assert backend.platform == "espressif8266" + assert backend.framework == "arduino" + assert backend.cache_key == "arduino8266" + for c in converted: + backend.emit(c) + return list(converted) + + with ( + patch.object(component, "convert_libraries", side_effect=fake_convert), + patch.object(component, "apply_extra_script") as mock_extra, + ): + yield mock_extra + + +def _converted(name: str, source_dir: Path, data: dict) -> ConvertedLibrary: + converted = ConvertedLibrary(name, "1.0.0", source=None) + converted.path = source_dir + converted.data = data + return converted + + +def _resolve(framework: Path) -> list[component.ArduinoLibrary]: + return component.resolve_libraries( + framework, + pio_platform="espressif8266", + board_mcu="esp8266", + cache_key="arduino8266", + ) + + +def _webserver(tmp_path: Path, data: dict) -> ConvertedLibrary: + """Register ESPAsyncWebServer and return its converted stand-in.""" + _add_library("ESP32Async/ESPAsyncWebServer", "3.9.6") + lib_dir = tmp_path / "converted" / "webserver" + (lib_dir / "src").mkdir(parents=True) + (lib_dir / "src" / "server.cpp").write_text("") + return _converted("esp32async__ESPAsyncWebServer", lib_dir, data) + + +def _local_lib(tmp_path: Path, dependencies: dict | list) -> None: + """Register a local file:// library declaring the given dependencies.""" + local_lib = tmp_path / "locallib" + (local_lib / "src").mkdir(parents=True) + (local_lib / "src" / "local.cpp").write_text("") + (local_lib / "library.json").write_text( + json.dumps( + {"name": "LocalLib", "version": "1.0.0", "dependencies": dependencies} + ) + ) + # as_uri() forms a valid file:// URL on every platform (file:///C:/... + # on Windows; a bare f-string would embed backslashes) + _add_library(local_lib.as_uri(), None) + + +def _ws_tcp_pair(tmp_path: Path) -> tuple[ConvertedLibrary, ConvertedLibrary]: + """Build ESPAsyncWebServer (depending on ESPAsyncTCP) plus resolved TCP.""" + ws_dir = tmp_path / "converted" / "webserver" + (ws_dir / "src").mkdir(parents=True) + (ws_dir / "src" / "server.cpp").write_text("") + tcp_dir = tmp_path / "converted" / "tcp" + (tcp_dir / "src").mkdir(parents=True) + (tcp_dir / "src" / "tcp.cpp").write_text("") + ws = _converted( + "esp32async__ESPAsyncWebServer", + ws_dir, + {"build": {}, "dependencies": [{"name": "ESPAsyncTCP"}]}, + ) + tcp = _converted("esp32async__ESPAsyncTCP", tcp_dir, {"build": {}}) + return ws, tcp + + +def test_library_info_src_layout(tmp_path: Path) -> None: + framework = _make_framework(tmp_path) + lib = component._bundled_library(framework, "ESP8266WiFi") + assert lib.name == "ESP8266WiFi" + assert [p.name for p in lib.sources] == ["ESP8266WiFi.cpp"] + assert lib.include_dirs == [(framework / "libraries/ESP8266WiFi/src").resolve()] + + +def test_library_info_root_layout_excludes_examples(tmp_path: Path) -> None: + framework = _make_framework(tmp_path) + lib = component._bundled_library(framework, "Wire") + assert [p.name for p in lib.sources] == ["Wire.cpp"] + assert lib.include_dirs == [(framework / "libraries/Wire").resolve()] + + +def test_library_info_flags_parsing(tmp_path: Path) -> None: + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "a.cpp").write_text("") + (read_path / "inc").mkdir() + (read_path / "blobs").mkdir() + data = { + "build": { + "flags": [ + "-DFOO=1 -I inc", + "-lalgobsec", + "-fno-lto", + "-Wl,--wrap=malloc", + # Bare flags join their argument within one entry only, as + # ParseFlags lexes each entry independently + "-l m", + "-L blobs", + ], + } + } + lib = component._library_info("x", read_path, data) + assert lib.flags == ["-DFOO=1", "-fno-lto"] + assert lib.include_dirs == [ + (read_path / "src").resolve(), + (read_path / "inc").resolve(), + ] + assert lib.link_dirs == [(read_path / "blobs").resolve()] + assert lib.link_libs == ["algobsec", "m"] + assert lib.link_flags == ["-Wl,--wrap=malloc"] + + +def test_library_info_missing_link_dir_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + read_path = tmp_path / "lib" + read_path.mkdir() + data = {"build": {"flags": ["-Lmissing_blobs"]}} + lib = component._library_info("x", read_path, data) + assert "declares library dir missing_blobs which does not exist" in caplog.text + # Kept anyway: the linker ignores missing -L dirs + assert lib.link_dirs == [(read_path / "missing_blobs").resolve()] + + +def test_library_info_declared_filter_matches_nothing_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + data = {"build": {"srcFilter": ["+"]}} + lib = component._library_info("x", read_path, data) + assert not lib.sources + assert "no source files matched" in caplog.text + + +def test_empty_converted_tree_raises_at_emit(tmp_path: Path) -> None: + """A converted tree with no sources and no headers is a broken download; + fail by name like the bundled case.""" + framework = _make_framework(tmp_path) + _add_library("Some/Empty", "1.0.0") + lib_dir = tmp_path / "converted" / "empty" + (lib_dir / "src").mkdir(parents=True) + converted = _converted("some__Empty", lib_dir, {"build": {}}) + with ( + _emitting_converter(converted), + pytest.raises(EsphomeError, match="no sources or headers; the download"), + ): + _resolve(framework) + + +def test_library_info_no_src_dir(tmp_path: Path) -> None: + read_path = tmp_path / "empty" + read_path.mkdir() + lib = component._library_info("x", read_path, {}) + # With no manifest hints the source dir falls back to the library root + assert lib.sources == [] + assert lib.include_dirs == [read_path.resolve()] + + +def test_resolve_libraries_bundled(tmp_path: Path) -> None: + framework = _make_framework(tmp_path) + _add_library("ESP8266WiFi", None) + libs = _resolve(framework) + assert [lib.name for lib in libs] == ["ESP8266WiFi"] + + +@pytest.mark.parametrize("version", [None, "1.1.0"]) +def test_resolve_libraries_registry_name_is_external( + tmp_path: Path, version: str | None +) -> None: + """A name that is not bundled reaches the converter, bare or pinned.""" + framework = _make_framework(tmp_path) + _add_library("pngle", version) + with patch.object(component, "convert_libraries", return_value=[]) as mock_convert: + _resolve(framework) + (libraries, _backend), _ = mock_convert.call_args + assert [lib.name for lib in libraries] == ["pngle"] + + +def test_resolve_libraries_external_and_bundled_deps(tmp_path: Path) -> None: + framework = _make_framework(tmp_path) + _add_library("ESP32Async/ESPAsyncWebServer", "3.9.6") + + lib_dir = tmp_path / "converted" / "webserver" + (lib_dir / "src").mkdir(parents=True) + (lib_dir / "src" / "server.cpp").write_text("") + converted = _converted( + "esp32async__ESPAsyncWebServer", + lib_dir, + { + "build": {}, + "dependencies": [ + # Version-less bundled dependency: resolved from the framework + {"name": "Wire", "platforms": "espressif8266"}, + # Wrong platform: skipped + {"name": "ESP8266WiFi", "platforms": "espressif32"}, + # Registry dependency with a version: handled by the converter + {"name": "ESPAsyncTCP", "owner": "ESP32Async", "version": "^2.0.0"}, + # Not bundled: skipped + {"name": "NotBundled"}, + ], + }, + ) + + with _emitting_converter(converted) as mock_extra: + libs = _resolve(framework) + + mock_extra.assert_called_once() + assert mock_extra.call_args.args == (converted,) + assert mock_extra.call_args.kwargs["pio_platform"] == "espressif8266" + # board_mcu is passed lazily, as the shared helper requires + assert mock_extra.call_args.kwargs["board_mcu"]() == "esp8266" + assert [lib.name for lib in libs] == [ + "Wire", + "esp32async__ESPAsyncWebServer", + ] + + +def test_resolve_libraries_bundled_dep_already_present(tmp_path: Path) -> None: + framework = _make_framework(tmp_path) + _add_library("Wire", None) + _add_library("Some/External", "1.0.0") + + lib_dir = tmp_path / "converted" / "external" + lib_dir.mkdir(parents=True) + (lib_dir / "main.cpp").write_text("") + converted = _converted( + "some__External", lib_dir, {"dependencies": [{"name": "Wire"}]} + ) + + with _emitting_converter(converted): + libs = _resolve(framework) + + # Wire appears once (from the explicit registration), not twice + assert [lib.name for lib in libs] == ["Wire", "some__External"] + + +def test_library_info_trailing_bare_flag_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + lib = component._library_info("x", read_path, {"build": {"flags": ["-DA=1 -l"]}}) + assert lib.flags == ["-DA=1"] + assert lib.link_libs == [] + assert "Ignoring trailing '-l'" in caplog.text + + +def test_library_info_missing_explicit_include_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + lib = component._library_info("x", read_path, {"build": {"flags": ["-Inope"]}}) + assert lib.include_dirs == [(read_path / "src").resolve()] + assert "include dir nope which does not exist" in caplog.text + + +def test_library_info_missing_declared_src_dir_raises(tmp_path: Path) -> None: + """An explicitly declared srcDir that does not exist is a manifest error.""" + read_path = tmp_path / "lib" + read_path.mkdir() + with pytest.raises(EsphomeError, match="srcDir 'nosrc' which does not exist"): + component._library_info("x", read_path, {"build": {"srcDir": "nosrc"}}) + + +def test_library_info_missing_declared_include_dir_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + read_path = tmp_path / "lib" + read_path.mkdir() + component._library_info("x", read_path, {"build": {"includeDir": "noinc"}}) + assert "include dir noinc which does not exist" in caplog.text + + +def test_resolve_libraries_lib_ignore_covers_bundled(tmp_path: Path) -> None: + """lib_ignore applies to framework-bundled libraries, as under PlatformIO.""" + framework = _make_framework(tmp_path) + _add_library("ESP8266WiFi", None) + _add_library("Wire", None) + CORE.platformio_options = {"lib_ignore": ["Wire"]} + libs = _resolve(framework) + assert [lib.name for lib in libs] == ["ESP8266WiFi"] + + +def test_resolve_libraries_lib_ignore_covers_bundled_dependencies( + tmp_path: Path, +) -> None: + framework = _make_framework(tmp_path) + _add_library("Some/External", "1.0.0") + CORE.platformio_options = {"lib_ignore": ["Wire"]} + + lib_dir = tmp_path / "converted" / "external" + lib_dir.mkdir(parents=True) + (lib_dir / "main.cpp").write_text("") + converted = _converted( + "some__External", lib_dir, {"dependencies": [{"name": "Wire"}]} + ) + + with _emitting_converter(converted): + libs = _resolve(framework) + + assert [lib.name for lib in libs] == ["some__External"] + + +def test_bundled_library_prefers_library_json(tmp_path: Path) -> None: + """A bundled library.json wins over library.properties (PIO semantics); + its build section is honored.""" + framework = _make_framework(tmp_path) + lib_dir = framework / "libraries" / "GDBStub" + (lib_dir / "custom").mkdir(parents=True) + (lib_dir / "custom" / "gdb.cpp").write_text("") + (lib_dir / "library.properties").write_text("name=GDBStub\n") + (lib_dir / "library.json").write_text( + '{"name": "GDBStub", "build": {"srcDir": "custom"}}' + ) + lib = component._bundled_library(framework, "GDBStub") + assert [s.name for s in lib.sources] == ["gdb.cpp"] + + +def test_library_info_lib_archive_flag(tmp_path: Path) -> None: + """Both libArchive (library.json) and dot_a_linkage (properties) reach + the generator's contract; default is archive.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + assert component._library_info("x", read_path, {}).lib_archive is True + assert ( + component._library_info( + "x", read_path, {"build": {"libArchive": False}} + ).lib_archive + is False + ) + assert ( + component._library_info("x", read_path, {"dot_a_linkage": "false"}).lib_archive + is False + ) + assert ( + component._library_info("x", read_path, {"dot_a_linkage": "true"}).lib_archive + is True + ) + + +def test_resolve_libraries_dep_warnings( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A nameless dependency entry warns in the shared normalizer; an + owner-without-version entry is left to the walk's reconciliation.""" + framework = _make_framework(tmp_path) + converted = _webserver( + tmp_path, + { + "build": {}, + "dependencies": [ + {"owner": "someone"}, + {"name": "Orphan", "owner": "someone"}, + ], + }, + ) + with _emitting_converter(converted): + _resolve(framework) + assert "Ignoring unrecognized dependency entry" in caplog.text + assert "Orphan" not in caplog.text + + +def test_bundled_dependency_nonplatform_rejection_is_silent_here( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """The shared walk owns the rejection warning; the backend-side filter + stays at debug so one manifest fault never warns twice.""" + framework = _make_framework(tmp_path) + converted = _webserver(tmp_path, {"build": {}, "dependencies": [{"name": "Wire"}]}) + with ( + _emitting_converter(converted), + patch.object( + component, + "check_library_data", + side_effect=InvalidLibrary("manifest is corrupt"), + ), + ): + libs = _resolve(framework) + assert "Wire" not in [lib.name for lib in libs] + assert "manifest is corrupt" not in caplog.text + + +def test_nonplatform_rejection_warns_once_through_real_converter( + tmp_path: Path, + caplog: pytest.LogCaptureFixture, + monkeypatch: pytest.MonkeyPatch, +) -> None: + """One manifest fault produces exactly one warning across the walk and + the backend-side bundled filter.""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, [{"name": "Wire"}]) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + real = pio_library.check_library_data + + def flaky(data, platform, framework_name): + if data.get("name") == "Wire": + raise InvalidLibrary("manifest is corrupt") + return real(data, platform, framework_name) + + monkeypatch.setattr(pio_library, "check_library_data", flaky) + monkeypatch.setattr(component, "check_library_data", flaky) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + _resolve(framework) + assert caplog.text.count("manifest is corrupt") == 1 + + +def test_url_pinned_bundled_name_not_doubled(tmp_path: Path) -> None: + """A URL-pinned dependency names one specific source; the bundled copy + of the same short name must never be added on top of the fork.""" + framework = _make_framework(tmp_path) + converted = _webserver( + tmp_path, + { + "build": {}, + "dependencies": [ + {"name": "Wire", "version": "https://github.com/x/wire-fork.git"} + ], + }, + ) + with _emitting_converter(converted): + libs = _resolve(framework) + assert "Wire" not in [lib.name for lib in libs] + + +def test_versioned_bundled_candidate_fault_warns_once( + tmp_path: Path, + caplog: pytest.LogCaptureFixture, + monkeypatch: pytest.MonkeyPatch, +) -> None: + """A versioned bundled-name dependency with a manifest fault warns once, + from the walk's usability filter; the backend-side re-check stays quiet.""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, [{"name": "Wire", "version": "*"}]) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + real = pio_library.check_library_data + + def flaky(data, platform, framework_name): + if data.get("name") == "Wire": + raise InvalidLibrary("manifest is corrupt") + return real(data, platform, framework_name) + + monkeypatch.setattr(pio_library, "check_library_data", flaky) + monkeypatch.setattr(component, "check_library_data", flaky) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + libs = _resolve(framework) + assert "Wire" not in [lib.name for lib in libs] + assert caplog.text.count("manifest is corrupt") == 1 + + +def test_short_name_collision_with_bundled_name_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """Suppressing a genuinely bundled name on a short-name match warns; + an accidental collision would otherwise surface at link.""" + framework = _make_framework(tmp_path) + _add_library("Someone/Wire", "1.0.0") + converted = _converted( + "someone__Wire", + tmp_path / "conv", + {"build": {}, "dependencies": [{"name": "Wire"}]}, + ) + (tmp_path / "conv" / "src").mkdir(parents=True) + (tmp_path / "conv" / "src" / "a.cpp").write_text("") + with _emitting_converter(converted): + libs = _resolve(framework) + assert "Wire" not in [lib.name for lib in libs] + assert "assumed satisfied by a requested external library" in caplog.text + assert any(r.levelname == "WARNING" for r in caplog.records) + + +def test_missing_libraries_dir_is_a_broken_install(tmp_path: Path) -> None: + """A framework tree without libraries/ must fail by name, not silently + reroute every bundled name to the registry.""" + framework = tmp_path / "framework" + framework.mkdir() + _add_library("Wire", None) + with pytest.raises(EsphomeError, match="framework install may be incomplete"): + _resolve(framework) + + +def test_provided_is_case_sensitive(tmp_path: Path) -> None: + """Membership uses the exact on-disk names, so a case-insensitive + filesystem cannot add the same bundled library twice.""" + framework = _make_framework(tmp_path) + converted = _webserver(tmp_path, {"build": {}, "dependencies": [{"name": "wire"}]}) + with _emitting_converter(converted): + libs = _resolve(framework) + assert "wire" not in [lib.name for lib in libs] + assert "Wire" not in [lib.name for lib in libs] + + +@pytest.mark.parametrize("declared", ["", None]) +def test_library_info_falsy_declared_src_dir_raises( + tmp_path: Path, declared: str | None +) -> None: + """A declared-but-falsy srcDir must not silently fall back to the probe.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + with pytest.raises(EsphomeError, match="does not exist"): + component._library_info("x", read_path, {"build": {"srcDir": declared}}) + + +@pytest.mark.parametrize( + ("value", "expected"), + [ + (False, False), + ("false", False), + ("False", False), + ("true", True), + ], +) +def test_library_info_lib_archive_parse( + tmp_path: Path, + value: object, + expected: bool, +) -> None: + """bool("false") is True; the string forms must parse, not coerce.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + lib = component._library_info("x", read_path, {"build": {"libArchive": value}}) + assert lib.lib_archive is expected + + +def test_library_info_unsupported_link_fields_raise(tmp_path: Path) -> None: + """precompiled/ldflags properties are not supported; refuse by name.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + with pytest.raises(EsphomeError, match="declares precompiled"): + component._library_info("x", read_path, {"precompiled": "true", "build": {}}) + with pytest.raises(EsphomeError, match="declares ldflags"): + component._library_info("x", read_path, {"ldflags": "-lfoo", "build": {}}) + + +@pytest.mark.parametrize("value", ["false", "False", " false ", "", False, None]) +def test_library_info_precompiled_opt_out_accepted( + tmp_path: Path, value: object +) -> None: + """Manifest values are strings; precompiled=false is the spec's + explicit opt-out, not a declaration.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + data = {"build": {}} + if value is not None: + data["precompiled"] = value + component._library_info("x", read_path, data) + + +@pytest.mark.parametrize("value", ["full", True, "weird"]) +def test_library_info_precompiled_set_raises(tmp_path: Path, value: object) -> None: + """Both full (Arduino's other legal value) and unknown spellings fail safe.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + with pytest.raises(EsphomeError, match="declares precompiled"): + component._library_info("x", read_path, {"precompiled": value, "build": {}}) + + +def test_library_info_default_filter_matching_nothing_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """The empty-match warning is not gated on a declared srcFilter/srcDir; + a default-filter src/ holding only inert files warns too.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "keywords.txt").write_text("") + lib = component._library_info("x", read_path, {"build": {}}) + assert not lib.sources + assert "no source files matched" in caplog.text + + +def test_library_info_unmapped_sources_warn( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """Source-like files the case-sensitive suffix map rejects are named, + even when other sources compiled (a partial drop links with undefined + symbols far from the cause).""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "impl.CPP").write_text("") + (read_path / "src" / "sketch.ino").write_text("") + (read_path / "src" / "ok.cpp").write_text("") + lib = component._library_info("x", read_path, {"build": {}}) + assert [s.name for s in lib.sources] == ["ok.cpp"] + assert "not compiled: impl.CPP, sketch.ino" in caplog.text + + +def test_library_info_inert_only_filter_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A declared srcFilter matching only inert files (no sources, no + headers) warns like one matching nothing at all.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "keywords.txt").write_text("") + component._library_info("x", read_path, {"build": {"srcFilter": ["+<*>"]}}) + assert "no source files matched" in caplog.text + + +def test_library_info_declared_filter_matching_headers_stays_quiet( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A declared filter matching real headers is a header-only library.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "api.h").write_text("") + component._library_info("x", read_path, {"build": {"srcFilter": ["+<*>"]}}) + assert "no source files matched" not in caplog.text + + +def test_library_info_header_only_src_stays_quiet( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A header-only library (real headers in src/) is routine, not a + warning (the default +<*> filter matches the headers too).""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "ArduinoJson.h").write_text("") + (read_path / "keywords.txt").write_text("") + lib = component._library_info("x", read_path, {"build": {}}) + assert lib.sources == [] + assert "not compiled" not in caplog.text + assert "srcFilter" not in caplog.text + + +def test_library_info_lib_archive_malformed_raises(tmp_path: Path) -> None: + """A typo'd libArchive fails by name like the other build fields.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + with pytest.raises(EsphomeError, match="malformed libArchive value 'archive-me'"): + component._library_info("x", read_path, {"build": {"libArchive": "archive-me"}}) + + +def test_bundled_dependency_dict_shorthand_prefers_bundled(tmp_path: Path) -> None: + """The {"Wire": "*"} dict shorthand resolves to the bundled library.""" + framework = _make_framework(tmp_path) + converted = _webserver(tmp_path, {"build": {}, "dependencies": {"Wire": "*"}}) + with _emitting_converter(converted): + libs = _resolve(framework) + assert "Wire" in [lib.name for lib in libs] + + +def test_unfulfilled_provides_promise_raises(tmp_path: Path) -> None: + """A provides()-skipped dependency nothing added can only surface as + undefined symbols at link, so it fails here by name; satisfied ones + pass silently.""" + with pytest.raises(EsphomeError, match="Wire") as err: + component._check_unfulfilled_provides( + {"Wire", "Hash"}, {"Hash"}, {"Wire", "Hash"} + ) + assert str(err.value).count("Wire") == 1 + assert "Hash" not in str(err.value) + component._check_unfulfilled_provides({"Hash"}, {"Hash"}, {"Hash"}) + # A recording for a since-re-resolved manifest is stale walk state, + # never a failure: no final manifest still requests Wire + component._check_unfulfilled_provides({"Wire"}, set(), set()) + + +def test_extra_script_link_flags_reach_the_library(tmp_path: Path) -> None: + """LINKFLAGS captured by an extra script travel outside build.flags and + must reach the library's link flags, matching the ESP-IDF backend.""" + framework = _make_framework(tmp_path) + converted = _webserver( + tmp_path, + { + "build": {}, + component.ESPHOME_DATA_KEY: { + component.ESPHOME_DATA_LINK_FLAGS_KEY: ["-Wl,--wrap=foo"] + }, + }, + ) + with _emitting_converter(converted): + libs = _resolve(framework) + (webserver,) = (lib for lib in libs if "ESPAsyncWebServer" in lib.name) + assert "-Wl,--wrap=foo" in webserver.link_flags + + +def test_bundled_dependency_platform_rejection_is_debug( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """The typed IncompatiblePlatform (the routine cross-platform skip) + stays at debug regardless of message wording.""" + framework = _make_framework(tmp_path) + converted = _webserver(tmp_path, {"build": {}, "dependencies": [{"name": "Wire"}]}) + with ( + _emitting_converter(converted), + patch.object( + component, + "check_library_data", + side_effect=IncompatiblePlatform("nothing about the p-word here"), + ), + ): + libs = _resolve(framework) + assert "Wire" not in [lib.name for lib in libs] + assert "Skipping dependency Wire" not in caplog.text + + +@pytest.mark.parametrize("data", [{"build": "src"}, [], "nope"]) +def test_library_info_malformed_manifest_is_named(tmp_path: Path, data: object) -> None: + """A malformed manifest names the library, never an AttributeError.""" + read_path = tmp_path / "lib" + read_path.mkdir() + with pytest.raises(EsphomeError, match="Library x has a malformed manifest"): + component._library_info("x", read_path, data) + + +def test_bundled_library_with_declared_dependencies_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A bundled manifest that declares dependencies is visible, not + silently skipped (a no-op for the ESP8266 core, not for every core).""" + framework = _make_framework(tmp_path) + wire = framework / "libraries" / "Wire" + (wire / "library.json").write_text( + '{"name": "Wire", "dependencies": [{"name": "SPI"}]}' + ) + _add_library("Wire", None) + _resolve(framework) + assert "Bundled library Wire declares dependencies" in caplog.text + + +@pytest.mark.parametrize( + ("build", "match"), + [ + ({"includeDir": ["a", "b"]}, "malformed includeDir"), + ({"srcFilter": [123]}, "malformed srcFilter"), + ], +) +def test_library_info_malformed_build_fields_are_named( + tmp_path: Path, build: dict, match: str +) -> None: + """Malformed includeDir/srcFilter fail naming the library like srcDir.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + with pytest.raises(EsphomeError, match=match): + component._library_info("x", read_path, {"build": build}) + + +@pytest.mark.parametrize( + ("value", "expected"), + [ + ("true", True), + ("False", False), + ], +) +def test_library_info_dot_a_linkage_parses_strictly( + tmp_path: Path, + value: str, + expected: bool, +) -> None: + """The dot_a_linkage property uses the same strict table as libArchive.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + lib = component._library_info("x", read_path, {"dot_a_linkage": value, "build": {}}) + assert lib.lib_archive is expected + + +def test_library_info_dot_a_linkage_malformed_raises(tmp_path: Path) -> None: + """A typo'd dot_a_linkage must not silently flip link semantics.""" + read_path = tmp_path / "lib" + (read_path / "src").mkdir(parents=True) + (read_path / "src" / "stub.cpp").write_text("") + with pytest.raises(EsphomeError, match="malformed dot_a_linkage value 'yes'"): + component._library_info("x", read_path, {"dot_a_linkage": "yes", "build": {}}) + + +def test_bundled_library_properties_depends_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """The library.properties depends= spelling reaches the visibility + warning too; the shared parser returns it raw.""" + framework = _make_framework(tmp_path) + wire = framework / "libraries" / "Wire" + (wire / "library.properties").write_text("name=Wire\nversion=1.0\ndepends=SPI\n") + _add_library("Wire", None) + caplog.set_level("INFO") + _resolve(framework) + assert "Library Wire declares dependencies via library.properties" in caplog.text + + +def test_bundled_library_extra_script_raises(tmp_path: Path) -> None: + """A bundled manifest relying on an extraScript would miscompile; + refuse by name.""" + framework = _make_framework(tmp_path) + wire = framework / "libraries" / "Wire" + (wire / "library.json").write_text( + '{"name": "Wire", "build": {"extraScript": "extra.py"}}' + ) + _add_library("Wire", None) + with pytest.raises(EsphomeError, match="Wire declares an extraScript"): + _resolve(framework) + + +def test_dependency_requested_top_level_is_not_a_drop( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A version-less manifest dependency the config separately requests is + already in the build; it is not probed as a bundled library.""" + framework = _make_framework(tmp_path) + _add_library("ESP32Async/ESPAsyncWebServer", "3.9.6") + _add_library("ESP32Async/ESPAsyncTCP", "2.0.0") + ws, tcp = _ws_tcp_pair(tmp_path) + with _emitting_converter(ws, tcp): + libs = _resolve(framework) + # Exactly the two converted libraries; no bundled stand-in was added + assert [lib.name for lib in libs] == [ + "esp32async__ESPAsyncWebServer", + "esp32async__ESPAsyncTCP", + ] + assert "Skipping" not in caplog.text + + +def test_bundled_library_non_dict_manifest_skips_probes_and_raises( + tmp_path: Path, +) -> None: + """A bundled library.json that is a JSON array skips the dependency and + extraScript probes and fails in _library_info naming the library.""" + framework = _make_framework(tmp_path) + wire = framework / "libraries" / "Wire" + (wire / "library.json").write_text('["not", "a", "manifest"]') + with pytest.raises(EsphomeError, match="Library Wire has a malformed manifest"): + component._bundled_library(framework, "Wire") + + +def test_bundled_missing_manifest_is_debug_only( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """The legacy manifest-less layout is legal (the core ships FSTools + without one), so the diagnostic must stay below warning level.""" + framework = _make_framework(tmp_path) + with caplog.at_level(logging.DEBUG): + component._bundled_library(framework, "Wire") + record = next(r for r in caplog.records if "has no manifest" in r.message) + assert record.levelno == logging.DEBUG + + +def test_bundled_corrupt_library_json_fails_by_name(tmp_path: Path) -> None: + """A truncated bundled library.json fails with the library name and the + clean-all hint, not a raw JSONDecodeError.""" + framework = _make_framework(tmp_path) + (framework / "libraries" / "Wire" / "library.json").write_text("{truncated") + with pytest.raises(EsphomeError, match="Wire has a corrupt library.json"): + component._bundled_library(framework, "Wire") + + +def test_dict_shorthand_dependency_skips_registry_through_real_converter( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """{"Wire": "*"} resolves to the bundled copy without touching the + registry (real converter).""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, {"Wire": "*"}) + # Pin the component cache to tmp_path (data_dir honors an ambient + # ESPHOME_DATA_DIR otherwise) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + libs = _resolve(framework) + names = [lib.name for lib in libs] + assert "Wire" in names + assert any("locallib" in n.lower() for n in names) + # The walk populated provided_requests for the skip; the backend added + # the bundled copy, so the reconciliation passed without raising + + +def test_versionless_provides_skip_is_reconciled_through_real_converter( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """A truly version-less bare-name dependency the walk skips on the + backend's promise is recorded and fulfilled by the bundled copy.""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, ["Wire"]) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + libs = _resolve(framework) + assert "Wire" in [lib.name for lib in libs] + + +def test_platform_filtered_bundled_candidate_does_not_break_reconciliation( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """A bundled candidate the backend knowingly skips (platform filter) + counts as satisfied; the promise reconciliation must not raise.""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, [{"name": "Wire", "platforms": ["espressif32"]}]) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + libs = _resolve(framework) + assert "Wire" not in [lib.name for lib in libs] + + +@pytest.mark.parametrize( + ("bad_name", "message"), + [ + # A non-string name never leaves the shared normalizer + (1, "Ignoring unrecognized dependency entry"), + ("../escape", "Ignoring malformed dependency entry"), + ("..", "Ignoring malformed dependency entry"), + ], +) +def test_bundled_dependency_bad_name_is_malformed( + tmp_path: Path, bad_name: object, message: str, caplog: pytest.LogCaptureFixture +) -> None: + """A dependency name becomes a path component; a traversal or a + non-string is a malformed entry, never joined.""" + framework = _make_framework(tmp_path) + converted = _webserver( + tmp_path, {"build": {}, "dependencies": [{"name": bad_name}]} + ) + with _emitting_converter(converted): + _resolve(framework) + assert message in caplog.text + + +def test_owner_qualified_dependency_is_silent( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """The owner-qualified dependency spelling (PIO's Owner/Pkg) resolves via + the converter; it must not draw the malformed-entry warning.""" + framework = _make_framework(tmp_path) + converted = _webserver( + tmp_path, + { + "build": {}, + "dependencies": [{"name": "ESP32Async/AsyncTCP", "version": "^3.0"}], + }, + ) + with _emitting_converter(converted): + _resolve(framework) + assert "malformed" not in caplog.text + + +def test_bundled_dependency_string_list_form(tmp_path: Path) -> None: + """The bare string-list dependency form (PIO-legal) resolves to the + bundled library instead of vanishing in normalization.""" + framework = _make_framework(tmp_path) + converted = _webserver(tmp_path, {"build": {}, "dependencies": ["Wire"]}) + with _emitting_converter(converted): + libs = _resolve(framework) + assert "Wire" in [lib.name for lib in libs] + + +def test_pinned_bundled_dependency_substitution_warns( + tmp_path: Path, + caplog: pytest.LogCaptureFixture, + monkeypatch: pytest.MonkeyPatch, +) -> None: + """A non-* version pin on a backend-provided dependency is discarded + for the bundled copy; the substitution must be visible.""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, {"Wire": "^2.0.0"}) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + libs = _resolve(framework) + assert "Wire" in [lib.name for lib in libs] + assert "pins version ^2.0.0; using the library bundled" in caplog.text + + +def test_transitively_resolved_dependency_does_not_warn( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A dependency the walk already resolved does not warn.""" + framework = _make_framework(tmp_path) + _add_library("ESP32Async/ESPAsyncWebServer", "3.9.6") + ws, tcp = _ws_tcp_pair(tmp_path) + with _emitting_converter(ws, tcp): + libs = _resolve(framework) + assert [lib.name for lib in libs] == [ + "esp32async__ESPAsyncWebServer", + "esp32async__ESPAsyncTCP", + ] + assert "Skipping" not in caplog.text + + +@pytest.mark.parametrize( + ("spec", "expected"), + [ + ("owner/Name", "Name"), + ("Name", "Name"), + ("Foo=file:///srv/Wire", "Foo"), + ("Foo=https://github.com/x/Wire", "Foo"), + # An "=" without a URL is a registry name, not the custom-name form + ("FOO=BAR", "FOO=BAR"), + ("https://github.com/x/Wire", "Wire"), + # Git tails are stripped like the walk's URL normalization + ("https://github.com/x/Wire.git", "Wire"), + ("git+https://github.com/x/Wire.git#v1", "Wire"), + ], +) +def test_external_short_name(spec: str, expected: str) -> None: + assert component._external_short_name(spec) == expected + + +def test_converted_manifest_name_suppresses_bundled_dependency( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A name a converted library's manifest provides is not also added + from the framework tree, even when the provider emits later; the + suppression warns like its external_short_names twin.""" + framework = _make_framework(tmp_path) + _add_library("ESP32Async/ESPAsyncWebServer", "3.9.6") + # Requested under a different short name; only the manifest says "Wire" + _add_library("Someone/WireLib", "9.9.9") + ws_dir = tmp_path / "converted" / "webserver" + (ws_dir / "src").mkdir(parents=True) + (ws_dir / "src" / "stub.cpp").write_text("") + wire_dir = tmp_path / "converted" / "wire" + (wire_dir / "src").mkdir(parents=True) + (wire_dir / "src" / "wire.cpp").write_text("") + ws = _converted( + "esp32async__ESPAsyncWebServer", + ws_dir, + {"build": {}, "dependencies": [{"name": "Wire"}]}, + ) + registry_wire = _converted( + "someone__WireLib", wire_dir, {"name": "Wire", "build": {}} + ) + with _emitting_converter(ws, registry_wire): + libs = _resolve(framework) + # The bundled Wire is not added alongside the registry-resolved one + assert [lib.name for lib in libs] == [ + "esp32async__ESPAsyncWebServer", + "someone__WireLib", + ] + assert "Dependency Wire is assumed satisfied by a converted" in caplog.text + + +def test_bundled_library_root_headers_pass_the_probe(tmp_path: Path) -> None: + """Headers anywhere in the bundled tree (uncommon suffixes and case + included) prove the install is intact, even with an empty src dir.""" + framework = _make_framework(tmp_path) + lib_dir = framework / "libraries" / "HeaderOnly" + (lib_dir / "src").mkdir(parents=True) + (lib_dir / "impl.HXX").write_text("") + lib = component._bundled_library(framework, "HeaderOnly") + assert lib.sources == [] + + +def test_empty_bundled_library_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A bundled directory with no sources or headers is a broken install + that can never link; fail by name instead of warning into it.""" + framework = _make_framework(tmp_path) + (framework / "libraries" / "Empty").mkdir() + _add_library("Empty", None) + with pytest.raises(EsphomeError, match="Library Empty has no sources or headers"): + _resolve(framework) + + +def test_versionless_dependency_with_provider_stays_quiet( + tmp_path: Path, + caplog: pytest.LogCaptureFixture, + monkeypatch: pytest.MonkeyPatch, +) -> None: + """With a provides backend the version-less skip is routine (debug) and + the bundled copy is picked up after emit.""" + framework = _make_framework(tmp_path) + _local_lib(tmp_path, [{"name": "Wire"}]) + monkeypatch.setenv("ESPHOME_DATA_DIR", str(tmp_path / ".esphome")) + with patch.object( + pio_library, + "_resolve_registry_version", + side_effect=AssertionError("registry touched"), + ): + libs = _resolve(framework) + assert "Wire" in [lib.name for lib in libs] + assert "has no version to resolve" not in caplog.text diff --git a/tests/unit_tests/test_espidf_framework.py b/tests/unit_tests/test_espidf_framework.py index 45a971ca01..3eeace9914 100644 --- a/tests/unit_tests/test_espidf_framework.py +++ b/tests/unit_tests/test_espidf_framework.py @@ -520,6 +520,33 @@ def test_check_esp_idf_install_feature_failure(espidf_mocks: SimpleNamespace) -> check_esp_idf_install(_IDF_VERSION, force=True, features=["fb"]) +def test_python_deps_use_uv_when_available( + espidf_mocks: SimpleNamespace, monkeypatch: pytest.MonkeyPatch +) -> None: + """The python env installs go through uv when on the PATH, pip otherwise.""" + monkeypatch.delenv("UV_HTTP_RETRIES", raising=False) + with patch( + "esphome.espidf.framework.shutil.which", + # Keyed on the name: the same which() also probes the default tools + side_effect=lambda name: "/usr/bin/uv" if name == "uv" else None, + ): + check_esp_idf_install(_IDF_VERSION, force=True, features=["fb"]) + upgrade_call, feature_call = espidf_mocks.run_ok.call_args_list[1:3] + upgrade_cmd, feature_cmd = upgrade_call.args[0], feature_call.args[0] + assert upgrade_cmd[:3] == ["/usr/bin/uv", "pip", "install"] + assert "--python" in upgrade_cmd + assert feature_cmd[:3] == ["/usr/bin/uv", "pip", "install"] + assert upgrade_call.kwargs["env"]["UV_HTTP_RETRIES"] == "10" + + espidf_mocks.run_ok.reset_mock() + monkeypatch.setenv("UV_HTTP_RETRIES", "3") # an explicit user value wins + with patch("esphome.espidf.framework.shutil.which", return_value=None): + check_esp_idf_install(_IDF_VERSION, force=True, features=["fb"]) + upgrade_call = espidf_mocks.run_ok.call_args_list[1] + assert upgrade_call.args[0][1:4] == ["-m", "pip", "install"] + assert upgrade_call.kwargs["env"]["UV_HTTP_RETRIES"] == "3" + + def _mark_installed() -> None: """Create the extracted marker and python-env interpreter so the install check takes the already-installed path rather than force-installing.""" @@ -911,7 +938,7 @@ def test_prefetch_leaves_unverifiable_entries_to_the_installer( "esphome.espidf.framework.run_command", return_value=(True, json.dumps(entries), ""), ), - patch("esphome.espidf.framework.download_with_resume") as download, + patch("esphome.framework_helpers.download_with_resume") as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), patch("esphome.framework_helpers._BatchDownloadProgress") as progress_cls, ): @@ -934,7 +961,7 @@ def test_prefetch_all_entries_unverifiable_is_a_noop(tmp_path: Path) -> None: "esphome.espidf.framework.run_command", return_value=(True, json.dumps(entries), ""), ), - patch("esphome.espidf.framework.download_with_resume") as download, + patch("esphome.framework_helpers.download_with_resume") as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), ): _prefetch_idf_tool_archives(tmp_path, "esp32", ["required"], None) @@ -952,7 +979,7 @@ def test_prefetch_dedupes_entries_by_dest(tmp_path: Path) -> None: "esphome.espidf.framework.run_command", return_value=(True, json.dumps(entries), ""), ), - patch("esphome.espidf.framework.download_with_resume") as download, + patch("esphome.framework_helpers.download_with_resume") as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), patch("esphome.framework_helpers._BatchDownloadProgress"), ): @@ -967,7 +994,7 @@ def test_prefetch_downloads_each_archive_with_resume(tmp_path: Path) -> None: "esphome.espidf.framework.run_command", return_value=(True, _PREFETCH_JSON, ""), ), - patch("esphome.espidf.framework.download_with_resume") as download, + patch("esphome.framework_helpers.download_with_resume") as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), patch("esphome.framework_helpers._BatchDownloadProgress") as progress_cls, ): @@ -1011,7 +1038,7 @@ def test_prefetch_downloads_archives_concurrently(tmp_path: Path) -> None: "esphome.espidf.framework.run_command", return_value=(True, json.dumps(entries), ""), ), - patch("esphome.espidf.framework.download_with_resume") as download, + patch("esphome.framework_helpers.download_with_resume") as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), patch( "esphome.framework_helpers.ThreadPoolExecutor", wraps=ThreadPoolExecutor @@ -1032,7 +1059,7 @@ def test_prefetch_skips_already_downloaded_archives(tmp_path: Path) -> None: "esphome.espidf.framework.run_command", return_value=(True, _PREFETCH_JSON, ""), ), - patch("esphome.espidf.framework.download_with_resume") as download, + patch("esphome.framework_helpers.download_with_resume") as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), ): _prefetch_idf_tool_archives(tmp_path, "esp32", ["required"], None) @@ -1065,7 +1092,7 @@ def test_prefetch_failures_never_raise( with ( patch("esphome.espidf.framework.run_command", return_value=run_result), patch( - "esphome.espidf.framework.download_with_resume", + "esphome.framework_helpers.download_with_resume", side_effect=download_error, ), patch("esphome.espidf.framework.get_system_python_path", return_value="python"), @@ -1087,7 +1114,7 @@ def test_prefetch_total_failure_logs_error( return_value=(True, _PREFETCH_JSON, ""), ), patch( - "esphome.espidf.framework.download_with_resume", + "esphome.framework_helpers.download_with_resume", side_effect=OSError("proxy refuses everything"), ), patch("esphome.espidf.framework.get_system_python_path", return_value="python"), @@ -1112,7 +1139,7 @@ def test_prefetch_one_failed_archive_does_not_stop_the_rest( return_value=(True, _PREFETCH_JSON, ""), ), patch( - "esphome.espidf.framework.download_with_resume", + "esphome.framework_helpers.download_with_resume", side_effect=_fail_cmake_download, ) as download, patch("esphome.espidf.framework.get_system_python_path", return_value="python"), @@ -1133,7 +1160,7 @@ def test_prefetch_finishes_progress_bar_and_cancels_queue(tmp_path: Path) -> Non "esphome.espidf.framework.run_command", return_value=(True, _PREFETCH_JSON, ""), ), - patch("esphome.espidf.framework.download_with_resume"), + patch("esphome.framework_helpers.download_with_resume"), patch("esphome.espidf.framework.get_system_python_path", return_value="python"), patch("esphome.framework_helpers._BatchDownloadProgress") as progress_cls, patch("esphome.framework_helpers.ThreadPoolExecutor") as pool_cls, diff --git a/tests/unit_tests/test_espota2_noise.py b/tests/unit_tests/test_espota2_noise.py new file mode 100644 index 0000000000..5b43d05530 --- /dev/null +++ b/tests/unit_tests/test_espota2_noise.py @@ -0,0 +1,407 @@ +"""Unit tests for encrypted OTA uploads in esphome.espota2. + +A fake device implementing the responder side of the wire protocol (via +noiseprotocol, which esphome already has through aioesphomeapi) serves a real +TCP loopback connection, so these exercise the actual handshake, framing, and +cipher interop of the client code. Tests that need the client-side crypto skip +when the installed aioesphomeapi predates the noise module. +""" + +from __future__ import annotations + +import base64 +import hashlib +import io +from pathlib import Path +import socket +import sys +import threading +from unittest.mock import Mock, patch + +import pytest + +from esphome import espota2 + +PSK = base64.b64encode(bytes(range(32))).decode() +OTHER_PSK = base64.b64encode(bytes(range(1, 33))).decode() + +MAGIC = bytes(espota2.MAGIC_BYTES) + + +def _recv_exact(sock: socket.socket, amount: int) -> bytes: + data = b"" + while len(data) < amount: + chunk = sock.recv(amount - len(data)) + if not chunk: + raise ConnectionError("client closed") + data += chunk + return data + + +def _frame(payload: bytes) -> bytes: + return ( + bytes([espota2.NOISE_FRAME_INDICATOR, len(payload) >> 8, len(payload) & 0xFF]) + + payload + ) + + +def _send_frame(sock: socket.socket, payload: bytes) -> None: + sock.sendall(_frame(payload)) + + +def _recv_frame(sock: socket.socket) -> bytes: + header = _recv_exact(sock, 3) + assert header[0] == 0x01 + return _recv_exact(sock, (header[1] << 8) | header[2]) + + +class FakeEncryptedDevice(threading.Thread): + """Responder side of the encrypted OTA wire protocol.""" + + def __init__( + self, + psk: str = PSK, + version: int = 2, + offer_noise: bool = True, + require_noise: bool = True, + prologue_features_override: int | None = None, + ) -> None: + super().__init__(daemon=True) + self.psk = psk + self.version = version + self.offer_noise = offer_noise + self.require_noise = require_noise + self.prologue_features_override = prologue_features_override + self.received: bytes | None = None + self.error: Exception | None = None + self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self.listener.bind(("127.0.0.1", 0)) + self.listener.listen(1) + self.port = self.listener.getsockname()[1] + + def run(self) -> None: + try: + sock, _ = self.listener.accept() + sock.settimeout(10) + with sock: + self._serve(sock) + except Exception as err: # noqa: BLE001 - surfaced via join_and_check + self.error = err + finally: + self.listener.close() + + def join_and_check(self) -> None: + self.join(timeout=10) + assert not self.is_alive(), "fake device did not finish" + if self.error is not None: + raise self.error + + def _serve(self, sock: socket.socket) -> None: + assert _recv_exact(sock, 5) == MAGIC + sock.sendall(bytes([espota2.RESPONSE_OK, self.version])) + features = _recv_exact(sock, 1)[0] + noise_negotiated = bool( + features & espota2.CLIENT_FEATURE_SUPPORTS_NOISE + and features & espota2.CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL + ) + if self.require_noise and not noise_negotiated: + sock.sendall(bytes([espota2.RESPONSE_ERROR_ENCRYPTION_REQUIRED])) + return + server_flags = espota2.SERVER_FEATURE_SUPPORTS_NOISE if self.offer_noise else 0 + sock.sendall(bytes([espota2.RESPONSE_FEATURE_FLAGS, server_flags])) + if not (self.offer_noise and noise_negotiated): + return # the client fails closed; nothing further arrives + + from cryptography.exceptions import InvalidTag + from noise.connection import NoiseConnection + + prologue_features = ( + features + if self.prologue_features_override is None + else self.prologue_features_override + ) + prologue = ( + espota2.NOISE_PROLOGUE_INIT + + MAGIC + + bytes([espota2.RESPONSE_OK, self.version, prologue_features]) + + bytes([espota2.RESPONSE_FEATURE_FLAGS, server_flags]) + ) + proto = NoiseConnection.from_name(b"Noise_NNpsk0_25519_ChaChaPoly_SHA256") + proto.set_as_responder() + proto.set_psks(base64.b64decode(self.psk)) + proto.set_prologue(prologue) + proto.start_handshake() + + msg1 = _recv_frame(sock) + assert msg1[0] == 0x00 + try: + proto.read_message(msg1[1:]) + except InvalidTag: + _send_frame(sock, b"\x01" + espota2.NOISE_MAC_FAILURE_REASON.encode()) + return + _send_frame(sock, b"\x00" + bytes(proto.write_message())) + + def send_byte(byte: int) -> None: + _send_frame(sock, proto.encrypt(bytes([byte]))) + + def recv_unit(length: int) -> bytes: + plaintext = proto.decrypt(_recv_frame(sock)) + assert len(plaintext) == length, "control units must be one per frame" + return plaintext + + send_byte(espota2.RESPONSE_AUTH_OK) + recv_unit(1) # ota type + size = int.from_bytes(recv_unit(4), "big") + send_byte(espota2.RESPONSE_UPDATE_PREPARE_OK) + md5_hex = recv_unit(32) + send_byte(espota2.RESPONSE_BIN_MD5_OK) + + received = b"" + acked = 0 + while len(received) < size: + plaintext = proto.decrypt(_recv_frame(sock)) + assert 0 < len(plaintext) <= espota2.NOISE_MAX_PLAINTEXT + received += plaintext + if self.version >= espota2.OTA_VERSION_2_0: + while acked + espota2.UPLOAD_BLOCK_SIZE <= len(received) or ( + len(received) == size and acked < size + ): + send_byte(espota2.RESPONSE_CHUNK_OK) + acked += espota2.UPLOAD_BLOCK_SIZE + assert hashlib.md5(received).hexdigest().encode() == md5_hex + send_byte(espota2.RESPONSE_RECEIVE_OK) + send_byte(espota2.RESPONSE_UPDATE_END_OK) + assert recv_unit(1) == bytes([espota2.RESPONSE_OK]) + self.received = received + + +def _upload( + device: FakeEncryptedDevice, firmware: bytes, noise_psk: str | None +) -> None: + device.start() + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(10) + sock.connect(("127.0.0.1", device.port)) + try: + espota2.perform_ota( + sock, None, io.BytesIO(firmware), Path("firmware.bin"), noise_psk=noise_psk + ) + finally: + sock.close() + + +def test_encrypted_upload_success() -> None: + """A full encrypted v2 upload spanning several 8192-byte blocks.""" + pytest.importorskip("aioesphomeapi.noise") + firmware = bytes(range(256)) * 80 # 20480 bytes, crosses chunk-ack boundaries + device = FakeEncryptedDevice() + with patch("time.sleep"): + _upload(device, firmware, PSK) + device.join_and_check() + assert device.received == firmware + + +def test_encrypted_upload_version_1() -> None: + """Version 1 protocol (no chunk acks) works through the noise transport.""" + pytest.importorskip("aioesphomeapi.noise") + firmware = b"v1 firmware image" * 100 + device = FakeEncryptedDevice(version=1) + with patch("time.sleep"): + _upload(device, firmware, PSK) + device.join_and_check() + assert device.received == firmware + + +def test_wrong_key_fails_with_clear_error() -> None: + """A key mismatch surfaces the device's handshake reject readably.""" + pytest.importorskip("aioesphomeapi.noise") + device = FakeEncryptedDevice(psk=OTHER_PSK) + with pytest.raises(espota2.OTAError, match="encryption key correct"): + _upload(device, b"firmware", PSK) + device.join_and_check() + + +def test_tampered_negotiation_breaks_handshake() -> None: + """A negotiation byte differing between the sides breaks the prologue MAC.""" + pytest.importorskip("aioesphomeapi.noise") + device = FakeEncryptedDevice( + prologue_features_override=espota2.CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL + ) + with pytest.raises(espota2.OTAError, match="encryption key correct"): + _upload(device, b"firmware", PSK) + device.join_and_check() + + +def test_client_fails_closed_when_device_lacks_encryption() -> None: + """With a key configured, a device not offering noise aborts the upload.""" + device = FakeEncryptedDevice(offer_noise=False, require_noise=False) + with pytest.raises(espota2.OTAError, match="refusing to send the image"): + _upload(device, b"firmware", PSK) + device.join_and_check() + + +def test_plaintext_client_gets_encryption_required_error() -> None: + """A client without a key gets the device's 0x94 error message.""" + device = FakeEncryptedDevice() + with pytest.raises(espota2.OTAError, match="requires an encrypted OTA"): + _upload(device, b"firmware", None) + device.join_and_check() + + +def test_missing_aioesphomeapi_noise_module_message() -> None: + """An aioesphomeapi without the noise module produces a clear error.""" + with ( + patch.dict(sys.modules, {"aioesphomeapi.noise": None}), + pytest.raises(espota2.OTAError, match="requires a newer aioesphomeapi"), + ): + espota2.NoiseSocketWrapper(Mock(), PSK, b"prologue") + + +class ScriptedSocket: + """Serves scripted recv chunks; b"" means the peer closed.""" + + def __init__(self, *chunks: bytes | Exception) -> None: + self.chunks = list(chunks) + self.sent: list[bytes] = [] + + def sendall(self, data: bytes) -> None: + self.sent.append(data) + + def settimeout(self, timeout: float) -> None: + pass + + def recv(self, amount: int) -> bytes: + if not self.chunks: + return b"" + chunk = self.chunks[0] + if isinstance(chunk, Exception): + self.chunks.pop(0) + raise chunk + take, rest = chunk[:amount], chunk[amount:] + if rest: + self.chunks[0] = rest + else: + self.chunks.pop(0) + return take + + +def _wrapper(*chunks: bytes | Exception) -> espota2.NoiseSocketWrapper: + pytest.importorskip("aioesphomeapi.noise") + return espota2.NoiseSocketWrapper(ScriptedSocket(*chunks), PSK, b"prologue") + + +def test_wrapper_rejects_malformed_psk() -> None: + pytest.importorskip("aioesphomeapi.noise") + with pytest.raises(espota2.OTAError, match="Invalid OTA encryption key"): + espota2.NoiseSocketWrapper(ScriptedSocket(), "not-base64!!!", b"prologue") + + +def test_handshake_socket_error_is_network_error() -> None: + wrapper = _wrapper(OSError("boom")) + with pytest.raises(espota2.OTANetworkError, match="noise handshake"): + wrapper.do_handshake() + + +def test_handshake_closed_at_frame_boundary() -> None: + wrapper = _wrapper() + with pytest.raises(espota2.OTANetworkError, match="closed connection during"): + wrapper.do_handshake() + + +def test_handshake_reject_with_other_reason() -> None: + wrapper = _wrapper(_frame(b"\x01Handshake error")) + with pytest.raises( + espota2.OTAError, match="rejected the noise handshake: Handshake error" + ): + wrapper.do_handshake() + + +def test_handshake_garbage_second_message() -> None: + """A valid-looking point with a garbage MAC fails cleanly.""" + wrapper = _wrapper(_frame(b"\x00" + bytes(range(48)))) + with pytest.raises( + espota2.OTAError, match="handshake failed; is the OTA encryption key" + ): + wrapper.do_handshake() + + +def test_handshake_invalid_curve_point() -> None: + """An all-zero x25519 point is rejected as a clean error, not a crash.""" + wrapper = _wrapper(_frame(b"\x00" + bytes(48))) + with pytest.raises( + espota2.OTAError, match="handshake failed; is the OTA encryption key" + ): + wrapper.do_handshake() + + +def test_recv_closed_at_frame_boundary_returns_empty() -> None: + wrapper = _wrapper() + assert wrapper.recv(1) == b"" + + +def test_recv_corrupt_frame_is_retryable_network_error() -> None: + from cryptography.exceptions import InvalidTag + + wrapper = _wrapper(_frame(b"ciphertext")) + wrapper._decrypt = Mock(decrypt=Mock(side_effect=InvalidTag())) + with pytest.raises(espota2.OTANetworkError, match="decryption failed"): + wrapper.recv(1) + + +def test_wrapper_blocks_unencrypted_socket_methods() -> None: + """Byte-moving socket methods must not bypass the encrypted transport.""" + wrapper = _wrapper() + # The harmless socket controls pass through to the wrapped socket + wrapper._sock = Mock() + wrapper.settimeout(1) + wrapper._sock.settimeout.assert_called_once_with(1) + wrapper.setsockopt(6, 1, 1) + wrapper._sock.setsockopt.assert_called_once_with(6, 1, 1) + wrapper.close() + wrapper._sock.close.assert_called_once_with() + with pytest.raises(AttributeError): + _ = wrapper.send + with pytest.raises(AttributeError): + _ = wrapper.recv_into + + +def test_recv_empty_plaintext_frame_is_protocol_error() -> None: + """A MAC-only frame decrypts to nothing; b'' from recv must mean close.""" + wrapper = _wrapper(_frame(bytes(16))) + wrapper._decrypt = Mock(decrypt=Mock(return_value=b"")) + with pytest.raises(espota2.OTANetworkError, match="empty noise frame"): + wrapper.recv(1) + + +def test_recv_frame_bad_indicator_is_retryable() -> None: + wrapper = _wrapper(b"\x02\x00\x01x") + with pytest.raises(espota2.OTANetworkError, match="Bad noise frame indicator"): + wrapper._recv_frame() + + +def test_recv_frame_zero_length_is_retryable() -> None: + wrapper = _wrapper(bytes([espota2.NOISE_FRAME_INDICATOR, 0, 0])) + with pytest.raises(espota2.OTANetworkError, match="empty noise frame"): + wrapper._recv_frame() + + +def test_perform_ota_blank_key_refuses_plaintext() -> None: + with pytest.raises(espota2.OTAError, match="empty OTA encryption key"): + espota2.perform_ota( + ScriptedSocket(), None, io.BytesIO(b"x"), Path("f.bin"), noise_psk="" + ) + + +def test_recv_exact_closed_mid_frame() -> None: + wrapper = _wrapper(_frame(b"partial")[:5]) + with pytest.raises(OSError, match="closed inside a noise frame"): + wrapper._recv_frame() + + +def test_recv_serves_buffered_plaintext_without_new_frame() -> None: + """A second recv drains the decrypted buffer without reading another frame.""" + wrapper = _wrapper(_frame(b"ciphertext")) + wrapper._decrypt = Mock(decrypt=Mock(return_value=b"AB")) + assert wrapper.recv(1) == b"A" # reads and decrypts one frame + assert wrapper.recv(1) == b"B" # served from the buffer, no new frame + wrapper._decrypt.decrypt.assert_called_once() diff --git a/tests/unit_tests/test_framework_helpers.py b/tests/unit_tests/test_framework_helpers.py index 8844212600..fcc5572f51 100644 --- a/tests/unit_tests/test_framework_helpers.py +++ b/tests/unit_tests/test_framework_helpers.py @@ -2280,6 +2280,32 @@ class TestGetProjectCxxCompileFlags: assert get_project_cxx_compile_flags() == [] +def test_resume_fetch_job_threads_tracker(tmp_path: Path) -> None: + """The batch runner passes the tracker positionally; the shared adapter + must deliver it as download_with_resume's progress keyword.""" + from esphome.framework_helpers import resume_fetch_job + + with patch("esphome.framework_helpers.download_with_resume") as mock_download: + fetch = resume_fetch_job("https://x/a.zip", tmp_path / "a", sha256="ff", size=9) + tracker = lambda done: None # noqa: E731 + fetch(tracker) + mock_download.assert_called_once_with( + "https://x/a.zip", tmp_path / "a", progress=tracker, sha256="ff", size=9 + ) + + +def test_warn_prefetch_failures_names_each_failure( + caplog: pytest.LogCaptureFixture, +) -> None: + """The shared failure loop warns per job with the failure reason.""" + from esphome.framework_helpers import warn_prefetch_failures + + warn_prefetch_failures([("toolchain-x@1", OSError("down"))]) + assert "Could not prefetch toolchain-x@1: down" in caplog.text + warn_prefetch_failures([("lib", OSError("gone"))], "Prefetch of %s failed: %s") + assert "Prefetch of lib failed: gone" in caplog.text + + @pytest.mark.parametrize( ("platform", "input_path", "expected"), [ @@ -2312,3 +2338,18 @@ def test_strip_win_long_path_prefix( r"""``\\?\`` and ``\\?\UNC\`` prefixes are stripped only on win32.""" with patch("esphome.framework_helpers.sys.platform", platform): assert framework_helpers.strip_win_long_path_prefix(input_path) == expected + + +def test_discard_partial_download_logs_undeletable( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """An unremovable staging file leaves a debug trace; the caller's + cache is never pruned, so silence would hide unbounded growth.""" + dest = tmp_path / "archive" + dest.write_bytes(b"stale") + with ( + patch.object(Path, "unlink", side_effect=OSError("busy")), + caplog.at_level(logging.DEBUG), + ): + framework_helpers.discard_partial_download(dest) + assert "Could not remove" in caplog.text diff --git a/tests/unit_tests/test_git.py b/tests/unit_tests/test_git.py index e296d48a46..0f7e0339c9 100644 --- a/tests/unit_tests/test_git.py +++ b/tests/unit_tests/test_git.py @@ -714,6 +714,25 @@ def test_run_git_command_without_git_dir_raises_error( git.run_git_command(["git", "clone", "https://invalid.url/repo.git"]) +def test_has_complete_clone(tmp_path: Path) -> None: + """The lock-free probe tracks the completion marker, subpath included.""" + CORE.config_path = tmp_path / "test.yaml" + + url = "https://github.com/test/repo" + subpath = Path("lib") + assert not git.has_complete_clone(url, "v1", "test_domain", subpath) + + repo_dir = _compute_repo_dir(url, "v1", "test_domain") / subpath + (repo_dir / ".git").mkdir(parents=True) + # A directory without the marker is an incomplete clone + assert not git.has_complete_clone(url, "v1", "test_domain", subpath) + + _mark_clone_complete(repo_dir) + assert git.has_complete_clone(url, "v1", "test_domain", subpath) + # The ref is part of the cache key + assert not git.has_complete_clone(url, "v2", "test_domain", subpath) + + def test_clone_or_update_with_never_refresh( tmp_path: Path, mock_run_git_command: Mock ) -> None: diff --git a/tests/unit_tests/test_helpers.py b/tests/unit_tests/test_helpers.py index 683fef22cf..ff82fa3c80 100644 --- a/tests/unit_tests/test_helpers.py +++ b/tests/unit_tests/test_helpers.py @@ -1,10 +1,12 @@ +import errno import io import logging import os from pathlib import Path import socket import stat -from unittest.mock import MagicMock, patch +import types +from unittest.mock import MagicMock, call, patch from aioesphomeapi.host_resolver import AddrInfo, IPv4Sockaddr, IPv6Sockaddr from hypothesis import given, settings @@ -965,6 +967,77 @@ def test_copy_file_if_changed_nonexistent_source(tmp_path: Path) -> None: helpers.copy_file_if_changed(src, dst) +def test_rmtree_removes_tree(tmp_path: Path) -> None: + """Test rmtree removes a populated directory tree.""" + target = tmp_path / "target" + (target / "sub").mkdir(parents=True) + (target / "sub" / "file.txt").write_text("content") + + helpers.rmtree(target) + assert not target.exists() + + +def test_rmtree_nonexistent_path(tmp_path: Path) -> None: + """Test rmtree on an already-removed path is a no-op.""" + helpers.rmtree(tmp_path / "gone") + + +def test_rmtree_retries_when_directory_repopulated(tmp_path: Path) -> None: + """Test rmtree retries when a file appears mid-delete (Finder .DS_Store race).""" + target = tmp_path / "target" + (target / "sub").mkdir(parents=True) + real_rmdir = os.rmdir + repopulated = False + + def racy_rmdir(path, **kwargs): + nonlocal repopulated + if not repopulated and Path(path).name == "target": + repopulated = True + (target / ".DS_Store").write_text("x") # Finder wins the race + real_rmdir(path, **kwargs) + + with patch("os.rmdir", side_effect=racy_rmdir), patch("time.sleep"): + helpers.rmtree(target) + assert repopulated + assert not target.exists() + + +def test_rmtree_raises_after_retries_exhausted(tmp_path: Path) -> None: + """Test rmtree gives up on a persistent ENOTEMPTY once attempts run out.""" + target = tmp_path / "target" + target.mkdir() + errs = [ + OSError(errno.ENOTEMPTY, "Directory not empty", str(target)) + for _ in range(helpers.RMTREE_MAX_ATTEMPTS) + ] + + with ( + patch("shutil.rmtree", side_effect=errs) as mock_rmtree, + patch("time.sleep") as mock_sleep, + pytest.raises(OSError, match="Directory not empty") as excinfo, + ): + helpers.rmtree(target) + assert mock_rmtree.call_count == helpers.RMTREE_MAX_ATTEMPTS + assert mock_sleep.call_args_list == [call(0.05), call(0.1)] + # Final failure chains to the last retried race + assert excinfo.value is errs[-1] + assert excinfo.value.__cause__ is errs[-2] + + +def test_rmtree_does_not_retry_other_oserror(tmp_path: Path) -> None: + """Test rmtree raises non-ENOTEMPTY errors immediately.""" + target = tmp_path / "target" + target.mkdir() + err = OSError(errno.EACCES, "Permission denied", str(target)) + + with ( + patch("shutil.rmtree", side_effect=err) as mock_rmtree, + pytest.raises(OSError, match="Permission denied"), + ): + helpers.rmtree(target) + assert mock_rmtree.call_count == 1 + + def test_resolve_ip_address_sorting() -> None: """Test that results are sorted by preference.""" # Create multiple address infos with different preferences @@ -1154,3 +1227,26 @@ def test_progressbar_interrupt_keeps_finished_bar_done(monkeypatch) -> None: def test_format_duration(seconds: float, expected: str) -> None: """Test that durations are rendered as short human-readable strings.""" assert helpers.format_duration(seconds) == expected + + +def test_get_usable_cpu_count() -> None: + """Returns a positive int on the real host.""" + count = helpers.get_usable_cpu_count() + assert isinstance(count, int) + assert count > 0 + + +def test_get_usable_cpu_count_sources() -> None: + """Prefers process_cpu_count, falls back to cpu_count, degrades to 1.""" + mock_os = types.SimpleNamespace(process_cpu_count=lambda: 8, cpu_count=lambda: 4) + with patch("esphome.helpers.os", mock_os): + assert helpers.get_usable_cpu_count() == 8 + + mock_os_no_process = types.SimpleNamespace(cpu_count=lambda: 4) + with patch("esphome.helpers.os", mock_os_no_process): + assert helpers.get_usable_cpu_count() == 4 + + # An undeterminable count degrades to one worker, never zero + mock_os_unknown = types.SimpleNamespace(cpu_count=lambda: None) + with patch("esphome.helpers.os", mock_os_unknown): + assert helpers.get_usable_cpu_count() == 1 diff --git a/tests/unit_tests/test_main.py b/tests/unit_tests/test_main.py index 08c99e2119..5372a7203d 100644 --- a/tests/unit_tests/test_main.py +++ b/tests/unit_tests/test_main.py @@ -86,7 +86,9 @@ from esphome.const import ( CONF_BROKER, CONF_DISABLED, CONF_DISCOVER_IP, + CONF_ENCRYPTION, CONF_ESPHOME, + CONF_KEY, CONF_LEVEL, CONF_LOG, CONF_LOG_TOPIC, @@ -112,6 +114,7 @@ from esphome.const import ( PLATFORM_BK72XX, PLATFORM_ESP32, PLATFORM_ESP8266, + PLATFORM_HOST, PLATFORM_NRF52, PLATFORM_RP2, Toolchain, @@ -2105,10 +2108,65 @@ def test_upload_program_ota_success( tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin" ) mock_run_ota.assert_called_once_with( - ["192.168.1.100"], 3232, "secret", expected_firmware, OTA_TYPE_UPDATE_APP + ["192.168.1.100"], 3232, "secret", expected_firmware, OTA_TYPE_UPDATE_APP, None ) +def test_upload_program_ota_encryption_key( + mock_run_ota: Mock, + mock_get_port_type: Mock, + tmp_path: Path, +) -> None: + """The resolved encryption key is passed through to run_ota.""" + setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path) + mock_get_port_type.return_value = "NETWORK" + mock_run_ota.return_value = (0, "192.168.1.100") + + key = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=" + config = { + CONF_OTA: [ + { + CONF_PLATFORM: CONF_ESPHOME, + CONF_PORT: 3232, + CONF_ENCRYPTION: {CONF_KEY: key}, + } + ] + } + exit_code, host = upload_program(config, MockArgs(), ["192.168.1.100"]) + + assert exit_code == 0 + assert host == "192.168.1.100" + expected_firmware = ( + tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin" + ) + mock_run_ota.assert_called_once_with( + ["192.168.1.100"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP, key + ) + + +def test_upload_program_ota_encryption_without_key_fails_closed( + mock_run_ota: Mock, + mock_get_port_type: Mock, + tmp_path: Path, +) -> None: + """An encryption block with no resolved key must never upload plaintext.""" + setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path) + mock_get_port_type.return_value = "NETWORK" + + config = { + CONF_OTA: [ + { + CONF_PLATFORM: CONF_ESPHOME, + CONF_PORT: 3232, + CONF_ENCRYPTION: {}, + } + ] + } + with pytest.raises(EsphomeError, match="no key was resolved"): + upload_program(config, MockArgs(), ["192.168.1.100"]) + mock_run_ota.assert_not_called() + + def test_upload_program_ota_with_file_arg( mock_run_ota: Mock, mock_get_port_type: Mock, @@ -2136,7 +2194,7 @@ def test_upload_program_ota_with_file_arg( assert exit_code == 0 assert host == "192.168.1.100" mock_run_ota.assert_called_once_with( - ["192.168.1.100"], 3232, None, Path("custom.bin"), OTA_TYPE_UPDATE_APP + ["192.168.1.100"], 3232, None, Path("custom.bin"), OTA_TYPE_UPDATE_APP, None ) @@ -2191,6 +2249,7 @@ def test_upload_program_ota_partition_table_with_file_arg( None, partition_file, OTA_TYPE_UPDATE_PARTITION_TABLE, + None, ) @@ -2252,6 +2311,7 @@ def test_upload_program_ota_partition_table_mqttip( None, partition_file, OTA_TYPE_UPDATE_PARTITION_TABLE, + None, ) @@ -2439,6 +2499,7 @@ def test_upload_program_ota_bootloader_with_file_arg( None, bootloader_file, OTA_TYPE_UPDATE_BOOTLOADER, + None, ) @@ -2601,6 +2662,42 @@ def test_has_web_server_logging_respects_log_disabled() -> None: assert has_web_server_logging() is False +def test_upload_program_web_server_warns_when_encryption_configured( + mock_run_web_server_ota: Mock, + mock_run_ota: Mock, + mock_get_port_type: Mock, + tmp_path: Path, + caplog: pytest.LogCaptureFixture, +) -> None: + """Explicitly picking web_server OTA on an encrypted config warns about + the plaintext upload path.""" + setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path) + mock_get_port_type.return_value = "NETWORK" + mock_run_web_server_ota.return_value = (0, "192.168.1.100") + + config = { + CONF_OTA: [ + { + CONF_PLATFORM: CONF_ESPHOME, + CONF_PORT: 3232, + CONF_ENCRYPTION: {CONF_KEY: "test_key"}, + }, + {CONF_PLATFORM: CONF_WEB_SERVER}, + ], + CONF_WEB_SERVER: { + CONF_PORT: 80, + CONF_AUTH: {CONF_USERNAME: "admin", CONF_PASSWORD: "pw"}, + }, + } + args = MockArgs(ota_platform=CONF_WEB_SERVER) + with caplog.at_level(logging.WARNING): + exit_code, _ = upload_program(config, args, ["192.168.1.100"]) + + assert exit_code == 0 + assert any("plaintext HTTP" in record.message for record in caplog.records) + mock_run_ota.assert_not_called() + + def test_upload_program_web_server_only_auto_dispatches( mock_run_web_server_ota: Mock, mock_run_ota: Mock, @@ -2891,7 +2988,7 @@ def test_upload_program_ota_with_mqtt_resolution( tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin" ) mock_run_ota.assert_called_once_with( - ["192.168.1.100"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP + ["192.168.1.100"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP, None ) @@ -2941,7 +3038,7 @@ def test_upload_program_ota_with_mqtt_empty_broker( tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin" ) mock_run_ota.assert_called_once_with( - ["192.168.1.50"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP + ["192.168.1.50"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP, None ) # Verify warning was logged assert "MQTT IP discovery failed" in caplog.text @@ -5113,6 +5210,7 @@ def test_upload_program_ota_static_ip_with_mqttip( None, expected_firmware, OTA_TYPE_UPDATE_APP, + None, ) @@ -5162,6 +5260,7 @@ def test_upload_program_ota_multiple_mqttip_resolves_once( None, expected_firmware, OTA_TYPE_UPDATE_APP, + None, ) @@ -5339,7 +5438,7 @@ def test_upload_program_ota_mqtt_timeout_fallback( tmp_path / ".esphome" / "build" / "test" / ".pioenvs" / "test" / "firmware.bin" ) mock_run_ota.assert_called_once_with( - ["192.168.1.100"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP + ["192.168.1.100"], 3232, None, expected_firmware, OTA_TYPE_UPDATE_APP, None ) @@ -7254,3 +7353,54 @@ async def test_wrap_to_code_comment_is_insertion_order_independent() -> None: assert first == second assert second.index("alpha") < second.index("beta") assert second.index("a: 2") < second.index("z: 1") + + +def test_host_program_path_platformio_toolchain() -> None: + """Host + PlatformIO toolchain reads the memoized idedata path.""" + setup_core(platform=PLATFORM_HOST) + idedata = SimpleNamespace(firmware_elf_path="/build/x/.pioenvs/x/program") + with patch( + "esphome.platformio.toolchain.get_idedata", return_value=idedata + ) as mock_get: + assert main._host_program_path({}) == "/build/x/.pioenvs/x/program" + mock_get.assert_called_once_with({}) + + +def test_host_program_path_esp_idf_toolchain() -> None: + """Host + native ESP-IDF toolchain asks the espidf toolchain for the ELF.""" + setup_core(platform=PLATFORM_HOST) + CORE.toolchain = Toolchain.ESP_IDF + with patch( + "esphome.espidf.toolchain.get_elf_path", return_value=Path("/b/app.elf") + ): + assert main._host_program_path({}) == str(Path("/b/app.elf")) + + +def test_command_compile_host_logs_program_path( + caplog: pytest.LogCaptureFixture, +) -> None: + """command_compile on host logs the compiled program path.""" + setup_core(platform=PLATFORM_HOST) + with ( + patch.object(main, "write_cpp", return_value=0), + patch.object(main, "compile_program", return_value=0), + patch.object(main, "_host_program_path", return_value="/b/program"), + caplog.at_level(logging.INFO), + ): + assert main.command_compile(SimpleNamespace(only_generate=False), {}) == 0 + assert "Successfully compiled program to path '/b/program'" in caplog.text + + +def test_command_run_host_executes_program(caplog: pytest.LogCaptureFixture) -> None: + """command_run on host logs and executes the compiled program directly.""" + setup_core(platform=PLATFORM_HOST) + with ( + patch.object(main, "write_cpp", return_value=0), + patch.object(main, "compile_program", return_value=0), + patch.object(main, "_host_program_path", return_value="/b/program"), + patch.object(main, "run_external_process", return_value=0) as mock_run, + caplog.at_level(logging.INFO), + ): + assert main.command_run(SimpleNamespace(), {}) == 0 + mock_run.assert_called_with("/b/program") + assert "Running program from path '/b/program'" in caplog.text diff --git a/tests/unit_tests/test_platformio_library.py b/tests/unit_tests/test_platformio_library.py index 0c873dc3fe..3bae39b3c1 100644 --- a/tests/unit_tests/test_platformio_library.py +++ b/tests/unit_tests/test_platformio_library.py @@ -10,7 +10,7 @@ from pathlib import Path import pytest -from esphome.core import EsphomeError, Library +from esphome.core import CORE, EsphomeError, Library import esphome.platformio.library as lib from esphome.platformio.library import ( SOURCE_KIND_FOR_SUFFIX, @@ -29,9 +29,13 @@ from esphome.platformio.library import ( ) -def _backend(emit=lambda component: None) -> LibraryBackend: +def _backend(emit=lambda component: None, provides=None) -> LibraryBackend: return LibraryBackend( - platform="espressif32", framework="espidf", emit=emit, cache_key="idf" + platform="espressif32", + framework="espidf", + emit=emit, + cache_key="idf", + provides=provides, ) @@ -634,7 +638,7 @@ def test_prefetch_wave_downloads_registry_archives_in_parallel( setup_core, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture ) -> None: """Registry archives in one wave download concurrently, deduped by URL; - git/local sources and failures are left to the sequential call.""" + local sources and failures are left to the sequential call.""" calls: list[str] = [] def fake_download( @@ -654,7 +658,7 @@ def test_prefetch_wave_downloads_registry_archives_in_parallel( # into the same cache directory) ("b2", ConvertedLibrary("b2", "1.0", URLSource("https://x/b.tar.gz", 1))), ("c", ConvertedLibrary("c", "1.0", URLSource("https://x/boom.tar.gz", 1))), - ("g", ConvertedLibrary("g", "*", lib.GitSource("https://x/g.git", None))), + ("l", ConvertedLibrary("l", "*", LocalSource("/some/lib"))), ] lib._prefetch_wave(wave, "", "idf") assert sorted(calls) == [ @@ -666,6 +670,83 @@ def test_prefetch_wave_downloads_registry_archives_in_parallel( assert "Prefetch of c failed (retrying sequentially)" in caplog.text +def test_prefetch_wave_clones_git_sources_in_parallel( + setup_core, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + """Git sources join the same prefetch batch as the archives, deduped by + clone target; a clone failure warns and is left to the sequential call.""" + caplog.set_level("INFO") + calls: list[str] = [] + + def fake_clone(self, dir_suffix, force=False, salt="", namespace=""): + calls.append(f"{self}/{dir_suffix}") + if "boom" in self.url: + raise RuntimeError("boom") + + monkeypatch.setattr(GitSource, "download", fake_clone) + wave = [ + ("a", ConvertedLibrary("a", "1.0", URLSource("https://x/a.tar.gz", 1))), + ("g", ConvertedLibrary("g", "*", GitSource("https://x/g.git", "v1"))), + # Same url@ref and target dir must clone once + ("g2", ConvertedLibrary("g", "*", GitSource("https://x/g.git", "v1"))), + ("h", ConvertedLibrary("h", "*", GitSource("https://x/boom.git", None))), + ] + monkeypatch.setattr( + URLSource, "download", lambda self, dir_suffix, progress=None, **kw: None + ) + lib._prefetch_wave(wave, "", "idf") + assert sorted(calls) == ["https://x/boom.git/h", "https://x/g.git#v1/g"] + assert "Cloning 2 library repo(s): g, h" in caplog.text + assert "Prefetch of h failed (retrying sequentially)" in caplog.text + + +def test_source_base_prefetch_defaults() -> None: + """The base Source is not prefetchable and reports cached (nothing to do).""" + source = Source() + assert source.prefetch_key("x") is None + assert source.is_cached("x") is True + + +def test_prefetch_wave_single_clone_uses_the_batch( + monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + """A wave with only git sources still clones through the batch runner.""" + caplog.set_level("INFO") + calls: list[str] = [] + monkeypatch.setattr(GitSource, "is_cached", lambda self, *a, **kw: False) + monkeypatch.setattr( + GitSource, + "download", + lambda self, dir_suffix, force=False, salt="", namespace="": calls.append( + self.url + ), + ) + lib._prefetch_wave( + [("g", ConvertedLibrary("g", "*", GitSource("https://x/g.git", None)))], + "", + "idf", + ) + assert calls == ["https://x/g.git"] + assert "Cloning 1 library repo(s): g" in caplog.text + assert "Downloading" not in caplog.text + + +def test_prefetch_wave_warm_git_cache_is_silent( + setup_core, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + """An already-complete clone is neither re-fetched nor announced.""" + caplog.set_level("INFO") + monkeypatch.setattr( + GitSource, + "download", + lambda self, dir_suffix, **kw: (_ for _ in ()).throw(AssertionError("cloned")), + ) + monkeypatch.setattr(GitSource, "is_cached", lambda self, *a, **kw: True) + wave = [("g", ConvertedLibrary("g", "*", GitSource("https://x/g.git", None)))] + lib._prefetch_wave(wave, "", "idf") + assert "Cloning" not in caplog.text + + def test_prefetch_wave_unknown_size_left_to_sequential( setup_core, monkeypatch: pytest.MonkeyPatch ) -> None: @@ -952,3 +1033,202 @@ def test_source_kind_map_shape() -> None: assert SOURCE_KIND_FOR_SUFFIX[".S"] == "aspp" assert SOURCE_KIND_FOR_SUFFIX[".c"] == "c" assert SOURCE_KIND_FOR_SUFFIX[".cpp"] == "cxx" + # SCons's case-sensitive C++ suffixes: PIO compiles .C as C++ + assert SOURCE_KIND_FOR_SUFFIX[".C"] == "cxx" + assert SOURCE_KIND_FOR_SUFFIX[".C++"] == "cxx" + + +def test_versionless_platform_filtered_dependency_stays_quiet( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A version-less dependency the platform filter excludes is + deliberately absent, not a drop to warn about.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + { + "esphome/A": { + "name": "A", + "dependencies": [{"name": "Hash", "platforms": "espressif8266"}], + } + }, + ) + convert_libraries([Library("esphome/A", None, None)], _backend()) + assert "has no version to resolve" not in caplog.text + + +def test_versionless_ignored_dependency_stays_quiet( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A lib_ignore'd version-less dependency is deliberately excluded, not + a drop; no reconciliation warning.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + {"esphome/A": {"name": "A", "dependencies": [{"name": "Hash"}]}}, + ) + CORE.platformio_options = {"lib_ignore": ["Hash"]} + convert_libraries([Library("esphome/A", None, None)], _backend()) + assert "has no version to resolve" not in caplog.text + + +def test_versionless_dependency_without_provider_warns( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A backend whose tree could supply the name warns on the drop; one + without provides() can never act on it, so it stays at debug.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + { + "esphome/A": { + "name": "A", + # The duplicate entry warns once (reconciliation dedup) + "dependencies": [{"name": "Hash"}, {"name": "Hash"}], + } + }, + ) + convert_libraries( + [Library("esphome/A", None, None)], _backend(provides=lambda name: False) + ) + assert ( + caplog.text.count( + "Hash of esphome/A has no version to resolve and nothing provides it" + ) + == 1 + ) + caplog.clear() + with caplog.at_level(logging.DEBUG): + convert_libraries([Library("esphome/A", None, None)], _backend()) + records = [ + r + for r in caplog.records + if "has no version to resolve and nothing provides it" in r.message + ] + assert records and all(r.levelno == logging.DEBUG for r in records) + + +def test_url_version_dependency_is_not_substituted_by_provides( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A URL-valued version names one specific source; the backend-provided + skip must not replace it with the bundled copy.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + { + "esphome/A": { + "name": "A", + "dependencies": [ + {"name": "Hash", "version": "https://github.com/o/Hash.git"} + ], + }, + "o/Hash": {"name": "Hash"}, + }, + ) + emitted: list[str] = [] + convert_libraries( + [Library("esphome/A", "1.0.0", None)], + _backend(emit=lambda c: emitted.append(c.name), provides=lambda name: True), + ) + assert "Skip backend-provided" not in caplog.text + assert "using the library bundled" not in caplog.text + assert any("o/hash" in n.lower() for n in emitted) + + +def test_versionless_owner_qualified_dependency_warns_despite_provides( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """An owner-qualified version-less dependency is not satisfied by + provides(); it must still warn.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + { + "esphome/A": { + "name": "A", + "dependencies": [{"name": "Wire", "owner": "Foo"}], + } + }, + ) + convert_libraries( + [Library("esphome/A", None, None)], + _backend(provides=lambda name: name == "Wire"), + ) + assert "Wire of esphome/A has no version to resolve" in caplog.text + + +def test_versionless_provided_dependency_stays_quiet( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """An owner-less version-less dependency the backend provides is added + by the backend after emit; no reconciliation warning.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + {"esphome/A": {"name": "A", "dependencies": [{"name": "Wire"}]}}, + ) + convert_libraries( + [Library("esphome/A", None, None)], + _backend(provides=lambda name: name == "Wire"), + ) + assert "has no version to resolve" not in caplog.text + + +def test_versionless_dependency_requested_top_level_stays_quiet( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A version-less dependency the config also requests top-level is in + the build; no drop warning even without a provides backend.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + { + "esphome/A": {"name": "A", "dependencies": [{"name": "Hash"}]}, + "Hash": {"name": "Hash"}, + }, + ) + convert_libraries( + [Library("esphome/A", None, None), Library("Hash", None, None)], + _backend(), + ) + assert "has no version to resolve" not in caplog.text + + +def test_versionless_url_ish_dependency_name_warns_cleanly( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A malformed URL-ish dependency name falls to the drop warning, never + a RuntimeError out of the key parser.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + {"esphome/A": {"name": "A", "dependencies": [{"name": "file://"}]}}, + ) + convert_libraries( + [Library("esphome/A", None, None)], _backend(provides=lambda name: False) + ) + assert ( + "file:// of esphome/A has no version to resolve and nothing provides it" + in caplog.text + ) + + +def test_versionless_dependency_matching_resolved_manifest_name_stays_quiet( + tmp_path, monkeypatch, caplog: pytest.LogCaptureFixture +) -> None: + """A bare name satisfied by an owner-qualified component's manifest + name is not a drop.""" + _patch_download_with_manifests( + monkeypatch, + tmp_path, + { + "esphome/A": {"name": "A", "dependencies": [{"name": "B"}]}, + "esphome/B": {"name": "B"}, + }, + ) + convert_libraries( + [Library("esphome/A", None, None), Library("esphome/B", None, None)], + _backend(), + ) + assert "has no version to resolve" not in caplog.text diff --git a/tests/unit_tests/test_platformio_prefetch.py b/tests/unit_tests/test_platformio_prefetch.py new file mode 100644 index 0000000000..379ef52ebd --- /dev/null +++ b/tests/unit_tests/test_platformio_prefetch.py @@ -0,0 +1,1805 @@ +"""Tests for the parallel PlatformIO package prefetch.""" + +import errno +import inspect +import json +import logging +import os +from pathlib import Path +import signal +import sys +import threading +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +from filelock import Timeout +from platformio.dependencies import get_core_dependencies +from platformio.package.manager._install import PackageManagerInstallMixin +from platformio.package.manager.base import BasePackageManager +from platformio.package.manager.library import LibraryPackageManager +from platformio.package.manager.platform import PlatformPackageManager +from platformio.package.manager.tool import ToolPackageManager +from platformio.package.meta import PackageCompatibility, PackageSpec +import pytest + +from esphome.core import CORE +import esphome.platformio.prefetch as pf + + +@pytest.fixture(autouse=True) +def _core(tmp_path: Path): + CORE.reset() + CORE.build_path = str(tmp_path) + CORE.name = "testenv" + saved_bar = os.environ.get("PLATFORMIO_DISABLE_PROGRESSBAR") + saved_sigterm = signal.getsignal(signal.SIGTERM) + pio_loggers = ("Tool Manager", "Library Manager", "Platform Manager") + saved_propagate = {n: pf.logging.getLogger(n).propagate for n in pio_loggers} + saved_filters = {n: list(pf.logging.getLogger(n).filters) for n in pio_loggers} + # The real setup_log would swap pytest's root-handler formatter + with patch("esphome.log.setup_log"): + yield + # _preinstall and main() set these process-wide; keep the suite hermetic + if saved_bar is None: + os.environ.pop("PLATFORMIO_DISABLE_PROGRESSBAR", None) + else: + os.environ["PLATFORMIO_DISABLE_PROGRESSBAR"] = saved_bar + signal.signal(signal.SIGTERM, saved_sigterm) + for n, flag in saved_propagate.items(): + pf.logging.getLogger(n).propagate = flag + pf.logging.getLogger(n).filters[:] = saved_filters[n] + CORE.reset() + + +class _FakeSpec(SimpleNamespace): + """PackageSpec stand-in for the attributes the prefetch reads.""" + + def __init__( + self, + *, + uri=None, + owner=None, + requirements=None, + external=False, + custom_name=False, + **kwargs, + ) -> None: + super().__init__( + uri=uri, owner=owner, requirements=requirements, external=external, **kwargs + ) + self._custom_name = custom_name + + def has_custom_name(self) -> bool: + return self._custom_name + + +def _fake_manager(tmp_path: Path) -> MagicMock: + m = MagicMock() + # _resolve and _preinstall construct same-class instances + m.__class__ = lambda package_dir=None, **kwargs: m + m.get_package.return_value = None + m.compatibility = None + m.is_builtin_lib.return_value = False + m.search_registry_packages.return_value = [{"any": 1}] + m.find_best_registry_version.return_value = ( + {"name": "toolchain-xtensa"}, + { + "name": "2.0.0", + "files": [ + { + "download_url": "https://dl.example/t.tar.gz", + "checksum": {"sha256": "cafe"}, + "size": 1000, + } + ], + }, + ) + m.pick_compatible_pkg_file.side_effect = lambda files: files[0] + m.compute_download_path.side_effect = lambda url, checksum: str( + tmp_path / "dl" / f"{abs(hash((url, checksum)))}" + ) + return m + + +def _mirror_patch(): + return patch.dict( + "sys.modules", + { + "platformio.registry.mirror": SimpleNamespace( + RegistryFileMirrorIterator=lambda url: iter( + [("https://mirror.example/t.tar.gz", "beef")] + ) + ) + }, + ) + + +def test_registry_jobs_resolves_like_platformio(tmp_path: Path) -> None: + """A registry spec resolves to a job keyed by mirror URL and checksum.""" + m = _fake_manager(tmp_path) + with _mirror_patch(): + jobs, failed, installable = pf._registry_jobs( + m, [_FakeSpec(name="toolchain-xtensa")], set() + ) + assert failed == 0 + assert len(jobs) == 1 + assert [n for n, _ in installable] == ["toolchain-xtensa@2.0.0"] + name, size, fetch = jobs[0] + assert name == "toolchain-xtensa@2.0.0" + assert size == 1000 + m.compute_download_path.assert_called_once_with( + "https://mirror.example/t.tar.gz", "beef" + ) + assert callable(fetch) + + +@pytest.mark.parametrize( + ("method", "attr", "value"), + [ + ("get_package", "return_value", object()), # already installed + ("search_registry_packages", "return_value", []), # unknown package + ("find_best_registry_version", "return_value", (None, None)), # no match + ("pick_compatible_pkg_file", "side_effect", lambda files: None), # no file + ], +) +def test_registry_jobs_skips(tmp_path: Path, method, attr, value) -> None: + """Entries PlatformIO would not download produce no job.""" + m = _fake_manager(tmp_path) + setattr(getattr(m, method), attr, value) + with _mirror_patch(): + assert pf._registry_jobs(m, [_FakeSpec(name="x")], set()) == ( + [], + 0, + [], + ) + + +def test_registry_jobs_skips_cached_and_sizeless(tmp_path: Path) -> None: + """A cached archive needs no download but is still installable; a + sizeless uncached one is left to PlatformIO entirely.""" + m = _fake_manager(tmp_path) + dl = Path(m.compute_download_path("https://mirror.example/t.tar.gz", "beef")) + dl.parent.mkdir(parents=True, exist_ok=True) + dl.touch() + with _mirror_patch(): + jobs, failed, installable = pf._registry_jobs(m, [_FakeSpec(name="x")], set()) + assert (jobs, failed) == ([], 0) + assert [n for n, _ in installable] == ["toolchain-xtensa@2.0.0"] + dl.unlink() + m.find_best_registry_version.return_value[1]["files"][0]["size"] = 0 + with _mirror_patch(): + assert pf._registry_jobs(m, [_FakeSpec(name="x")], set()) == ( + [], + 0, + [], + ) + + +def test_registry_jobs_dedupes_download_paths(tmp_path: Path) -> None: + """Duplicate specs resolve once and one archive yields one job (two + workers must never share a .part); nine specs against eight workers + also exercise the thread-local manager reuse.""" + m = _fake_manager(tmp_path) + specs = [_FakeSpec(name="dup"), _FakeSpec(name="dup")] + specs += [_FakeSpec(name=f"n{i}") for i in range(8)] + with _mirror_patch(): + jobs, failed, _installable = pf._registry_jobs(m, specs, set()) + # the fake resolves every spec to the same mirror URL and checksum + assert failed == 0 + assert len(jobs) == 1 + assert m.search_registry_packages.call_count == 9 # dup resolved once + + +def test_registry_jobs_uri_specs_excluded(tmp_path: Path) -> None: + """URL specs never reach the registry resolution.""" + m = _fake_manager(tmp_path) + assert pf._registry_jobs( + m, [_FakeSpec(uri="https://x/y.zip", name="y")], set() + ) == ([], 0, []) + m.search_registry_packages.assert_not_called() + + +def test_registry_jobs_dedup_keeps_distinct_owners(tmp_path: Path) -> None: + """platformio/x and pioarduino/x are different packages.""" + m = _fake_manager(tmp_path) + specs = [ + _FakeSpec(name="framework-x", owner="platformio"), + _FakeSpec(name="framework-x", owner="pioarduino"), + ] + with _mirror_patch(): + pf._registry_jobs(m, specs, set()) + assert m.search_registry_packages.call_count == 2 + + +def test_registry_jobs_all_failed_warns_once( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A whole-batch failure is a systemic fault and must be visible.""" + m = _fake_manager(tmp_path) + m.search_registry_packages.side_effect = RuntimeError("registry down") + with _mirror_patch(): + jobs, failed, installable = pf._registry_jobs( + m, + [_FakeSpec(name="a"), _FakeSpec(name="b")], + set(), + ) + assert (jobs, failed, installable) == ([], 2, []) + # The aggregate warning names a cause so an API break does not read + # as a registry outage + assert "Could not resolve 2 of 2" in caplog.text + assert "registry down" in caplog.text + + +def test_uri_fetch_job_promotes_atomically(tmp_path: Path) -> None: + """Checksum-less URL archives land via a locked staging file and an + atomic rename (the stable name is what keeps .part resume working).""" + dl_path = tmp_path / "archive" + + def fake_download(url, dest, progress=None, **kwargs): + Path(dest).write_bytes(b"data") + + manager = MagicMock() + with patch( + "esphome.framework_helpers.download_with_resume", side_effect=fake_download + ): + pf._uri_fetch_job(manager, "https://x/a.zip", dl_path, 4)(lambda done: None) + assert dl_path.read_bytes() == b"data" + # The archive is handed to pio's usage.db pruner + manager.set_download_utime.assert_called_once_with(str(dl_path)) + # no orphaned staging file; the lock file may or may not persist + # (filelock removes it on release on some platforms) + leftovers = {f.name for f in tmp_path.iterdir()} + assert leftovers - {f"{dl_path.name}.prefetch.lock"} == {dl_path.name} + + +def test_registry_fetch_job_skips_when_cached(tmp_path: Path) -> None: + """A destination another process completed is not re-downloaded.""" + dl_path = tmp_path / "archive" + dl_path.write_bytes(b"done") + with patch("esphome.framework_helpers.download_with_resume") as mock_download: + pf._registry_fetch_job( + MagicMock(), "https://x/a.tar.gz", dl_path, "ab" * 32, 4 + )(lambda done: None) + mock_download.assert_not_called() + assert dl_path.read_bytes() == b"done" + + +def test_registry_fetch_job_downloads_under_lock(tmp_path: Path) -> None: + """Registry downloads write the shared cache path under the same lock + the URL path uses; interleaved writers would corrupt the archive.""" + dl_path = tmp_path / "archive" + order: list[str] = [] + with ( + patch( + "esphome.framework_helpers.download_with_resume", + side_effect=lambda url, dest, progress=None, **kw: ( + order.append("fetch"), + Path(dest).write_bytes(b"data"), # registration needs a real file + ), + ), + patch( + "filelock.FileLock.acquire", + side_effect=lambda *a, **k: order.append("lock"), + ), + patch( + "filelock.FileLock.release", + side_effect=lambda *a, **k: order.append("unlock"), + ), + ): + manager = MagicMock() + pf._registry_fetch_job(manager, "https://x/a.tar.gz", dl_path, "ab" * 32, 4)( + lambda done: None + ) + # FileLock.__del__ may add a trailing release; the contract is the order + assert order[:2] == ["lock", "fetch"] + assert "unlock" in order[2:] + manager.set_download_utime.assert_called_once_with(str(dl_path)) + + +def test_lockless_filesystem_downloads_unlocked( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A filesystem without lock support (ENOSYS/EPERM) degrades to an + unlocked download with one warning, never a per-package failure.""" + dl_path = tmp_path / "archive" + with ( + patch("esphome.framework_helpers.download_with_resume") as mock_download, + patch( + "filelock.FileLock.acquire", + side_effect=OSError(errno.ENOSYS, "no locks"), + ), + patch("filelock.FileLock.release"), + ): + pf._registry_fetch_job( + MagicMock(), "https://x/a.tar.gz", dl_path, "ab" * 32, 4 + )(lambda done: None) + mock_download.assert_called_once() + assert "downloading unlocked" in caplog.text + + +def test_uri_fetch_job_failed_download_keeps_staging(tmp_path: Path) -> None: + """A failed fetch keeps the .part staging bytes for the next resume.""" + dl_path = tmp_path / "archive" + part = tmp_path / "archive.prefetch.part" + part.write_bytes(b"partial") + with ( + patch( + "esphome.framework_helpers.download_with_resume", + side_effect=OSError("network gone"), + ), + pytest.raises(OSError, match="network gone"), + ): + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 4)(lambda done: None) + assert part.read_bytes() == b"partial" + assert not dl_path.exists() + + +def test_uri_fetch_job_rejects_wrong_length(tmp_path: Path) -> None: + """A checksum-less body of the wrong length is never published under a + cache key pio would trust forever.""" + dl_path = tmp_path / "archive" + + def fake_download(url, dest, progress=None, **kwargs): + Path(dest).write_bytes(b"short") + + with ( + patch( + "esphome.framework_helpers.download_with_resume", side_effect=fake_download + ), + pytest.raises(ValueError, match="expected 9999 bytes"), + ): + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 9999)( + lambda done: None + ) + assert not dl_path.exists() + assert not (tmp_path / "archive.prefetch").exists() + + +def test_sweep_stale_sidecars(tmp_path: Path) -> None: + """Sidecars past pio's own expiry are pruned; fresh and foreign files + stay.""" + old_time = pf.time.time() - 110 + stale = tmp_path / "a.tar.gz.part" + stale.write_bytes(b"x") + os.utime(stale, (old_time, old_time)) + fresh = tmp_path / "b.tar.gz.part" + fresh.write_bytes(b"x") + keep = tmp_path / "c.tar.gz" + keep.write_bytes(b"x") + os.utime(keep, (old_time, old_time)) + # A held lock can carry an ancient mtime (O_TRUNC keeps it); locks + # must never be swept or the single-writer guarantee reopens + held_lock = tmp_path / "d.tar.gz.esphome.lock" + held_lock.write_bytes(b"") + os.utime(held_lock, (old_time, old_time)) + pf._sweep_stale_sidecars(tmp_path, 100) + assert not stale.exists() + assert fresh.exists() + assert keep.exists() + assert held_lock.exists() + pf._sweep_stale_sidecars(tmp_path / "missing", 100) # tolerated + + +def test_register_download_failure_leaves_a_trace( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A failed usage.db registration is traced; an unregistered archive + is never pruned, so silence would hide the leak coming back.""" + manager = MagicMock() + manager.set_download_utime.side_effect = RuntimeError("db locked") + with caplog.at_level(pf.logging.DEBUG): + pf._register_download(manager, tmp_path / "a.tar.gz") + assert "Could not register" in caplog.text + + +def test_sweep_logs_unprunable_files( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A sidecar that cannot be removed leaves a trace; a sweep that never + prunes must not look like a clean sweep.""" + old_time = pf.time.time() - 110 + stale = tmp_path / "a.tar.gz.part" + stale.write_bytes(b"x") + os.utime(stale, (old_time, old_time)) + with ( + patch.object(Path, "unlink", side_effect=OSError("busy")), + caplog.at_level(pf.logging.DEBUG), + ): + pf._sweep_stale_sidecars(tmp_path, 100) + assert "Could not remove" in caplog.text + + +def test_uri_lock_failure_is_a_counted_failure(tmp_path: Path) -> None: + """The checksum-less URL path never degrades to an unlocked shared + write; interleaved right-length corruption would go undetected.""" + dl_path = tmp_path / "archive" + with ( + patch("esphome.framework_helpers.download_with_resume") as mock_download, + patch( + "filelock.FileLock.acquire", + side_effect=OSError(errno.ENOSYS, "no locks"), + ), + pytest.raises(OSError), + ): + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 4)(lambda done: None) + mock_download.assert_not_called() + + +def test_uri_fetch_job_no_discard_without_a_file(tmp_path: Path) -> None: + """When no archive landed (degraded serialized run), the staging bytes + stay for the next resume instead of being discarded.""" + dl_path = tmp_path / "archive" + part = tmp_path / "archive.prefetch.part" + part.write_bytes(b"partial") + with patch.object(pf, "_serialized_fetch_job", return_value=lambda tracker: None): + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 4)(lambda done: None) + assert part.read_bytes() == b"partial" + + +def test_uri_fetch_job_waits_out_a_briefly_held_lock(tmp_path: Path) -> None: + """A lock freed within the deadline lets the job proceed normally.""" + dl_path = tmp_path / "archive" + + def fake_download(url, dest, progress=None, **kwargs): + Path(dest).write_bytes(b"data") + + with ( + patch( + "esphome.framework_helpers.download_with_resume", side_effect=fake_download + ), + patch("filelock.FileLock.acquire", side_effect=[Timeout("held"), None]), + patch("filelock.FileLock.release"), + ): + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 4)(lambda done: None) + assert dl_path.read_bytes() == b"data" + + +def test_lock_deadline_leaves_download_to_the_holder(tmp_path: Path) -> None: + """A lock held past the deadline means another process is fetching the + same file; skipping cleanly beats a misleading failure warning. The + tracker is still polled so a parked worker observes cancellation.""" + dl_path = tmp_path / "archive" + ticks: list[int] = [] + with ( + patch("esphome.framework_helpers.download_with_resume") as mock_download, + patch("filelock.FileLock.acquire", side_effect=Timeout("held")), + patch.object(pf, "_DOWNLOAD_LOCK_TIMEOUT", 0), + ): + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 4)(ticks.append) + mock_download.assert_not_called() + assert ticks == [0] + assert not dl_path.exists() + + +def test_registry_lock_deadline_skips_registration(tmp_path: Path) -> None: + """A registry job that lost the download race to another process + must not stamp a nonexistent archive into pio's usage.db.""" + manager = MagicMock() + dl_path = tmp_path / "archive" + with ( + patch("esphome.framework_helpers.download_with_resume") as mock_download, + patch("filelock.FileLock.acquire", side_effect=Timeout("held")), + patch.object(pf, "_DOWNLOAD_LOCK_TIMEOUT", 0), + ): + pf._registry_fetch_job(manager, "https://x/a.tar.gz", dl_path, "ab" * 32, 4)( + lambda done: None + ) + mock_download.assert_not_called() + manager.set_download_utime.assert_not_called() + + +def test_main_interrupt_exits_quietly(tmp_path: Path) -> None: + """Ctrl-C reaches the child via the shared process group; it must exit + without a traceback.""" + with ( + patch("esphome.log.setup_log"), + patch.object(pf, "_prefetch", side_effect=KeyboardInterrupt), + ): + assert pf.main([str(tmp_path), "testenv"]) == 130 + + +def test_main_bad_log_level_falls_back(tmp_path: Path) -> None: + with ( + patch.dict("os.environ", {"ESPHOME_PREFETCH_LOG_LEVEL": "verbose"}), + patch("esphome.log.setup_log") as mock_setup, + patch.object(pf, "_prefetch"), + ): + assert pf.main([str(tmp_path), "testenv"]) == 0 + assert mock_setup.call_args[0][0] == pf.logging.INFO + + +def test_main_silences_pio_manager_propagation(tmp_path: Path) -> None: + """The pio manager loggers carry their own handler; propagation to + the root handler would print every install line twice.""" + with patch("esphome.log.setup_log"), patch.object(pf, "_prefetch"): + assert pf.main([str(tmp_path), "testenv"]) == 0 + for name in ("Tool Manager", "Library Manager", "Platform Manager"): + assert pf.logging.getLogger(name).propagate is False + + +def test_main_quiet_level_reaches_pio_manager_loggers(tmp_path: Path) -> None: + """Manager construction re-pins its logger to INFO, so a quiet run + needs the logger-level filter to keep per-package lines out.""" + with ( + patch.dict("os.environ", {"ESPHOME_PREFETCH_LOG_LEVEL": "30"}), + patch("esphome.log.setup_log"), + patch.object(pf, "_prefetch"), + ): + assert pf.main([str(tmp_path), "testenv"]) == 0 + lib_logger = pf.logging.getLogger("Library Manager") + lib_logger.setLevel(pf.logging.INFO) # what pio's _setup_logger does + info = pf.logging.LogRecord("Library Manager", 20, __file__, 1, "x", (), None) + warning = pf.logging.LogRecord("Library Manager", 30, __file__, 1, "x", (), None) + # Logger.filter returns falsy to drop, the record itself to pass + assert not lib_logger.filter(info) + assert lib_logger.filter(warning) + + +def test_main_mirrors_parent_log_setup(tmp_path: Path) -> None: + """The child adopts the parent's dashboard flag and log formatter so + its warnings and progress bar match the parent's.""" + with ( + patch.dict( + "os.environ", + {"ESPHOME_PREFETCH_LOG_LEVEL": "30", "ESPHOME_PREFETCH_DASHBOARD": "1"}, + ), + patch("esphome.log.setup_log") as mock_setup, + patch.object(pf, "_prefetch"), + ): + assert pf.main([str(tmp_path), "testenv"]) == 0 + mock_setup.assert_called_once_with(30) + assert CORE.dashboard is True + + +def test_uri_fetch_job_skips_when_another_process_won(tmp_path: Path) -> None: + """A lost race discards the staging files; the cache never prunes them.""" + dl_path = tmp_path / "archive" + dl_path.write_bytes(b"done") + stale = [ + tmp_path / "archive.prefetch", + tmp_path / "archive.prefetch.part", + tmp_path / "archive.prefetch.part.meta", + ] + for f in stale: + f.write_bytes(b"stale") + with patch("esphome.framework_helpers.download_with_resume") as mock_download: + pf._uri_fetch_job(MagicMock(), "https://x/a.zip", dl_path, 4)(lambda done: None) + mock_download.assert_not_called() + assert dl_path.read_bytes() == b"done" + assert not any(f.exists() for f in stale) + + +def test_registry_jobs_one_bad_spec_keeps_the_rest(tmp_path: Path) -> None: + """A flaky resolution counts as failed without discarding the batch.""" + m = _fake_manager(tmp_path) + m.search_registry_packages.side_effect = [ + RuntimeError("registry 500"), + [{"any": 1}], + ] + with _mirror_patch(): + jobs, failed, installable = pf._registry_jobs( + m, + [_FakeSpec(name="flaky"), _FakeSpec(name="good")], + set(), + ) + assert failed == 1 + assert len(jobs) == 1 + assert len(installable) == 1 + + +def test_uri_jobs_head_sizes_the_bar(tmp_path: Path) -> None: + """HEAD sizes direct-URL specs; git and unreachable URLs are skipped.""" + m = _fake_manager(tmp_path) + resp = MagicMock() + resp.headers = {"content-length": "2222"} + with patch("esphome.net_retry.http_request", return_value=resp): + jobs, failed, installable = pf._uri_jobs( + m, + [ + _FakeSpec(uri="https://x/big.zip", name="big", custom_name=True), + _FakeSpec(uri="git+https://x/repo.git", name="repo"), + _FakeSpec(uri="https://x/repo.git#v1", name="barevcs"), + _FakeSpec(name="registry"), + ], + set(), + ) + assert failed == 0 + assert [(n, s) for n, s, _ in jobs] == [("big", 2222)] + assert [n for n, _ in installable] == ["big"] + # a successful HEAD with no Content-Length is a clean skip + resp.headers = {} + with patch("esphome.net_retry.http_request", return_value=resp): + assert pf._uri_jobs( + m, [_FakeSpec(uri="https://x/nolen.zip", name="nolen")], set() + ) == ([], 0, []) + + +def test_uri_jobs_head_failure_counts_as_unresolved( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """Network errors and transient statuses count as unresolved (and warn); + any permanent error status is a clean skip so the sentinel can still + be written (pio run names a broken URL when it downloads).""" + m = _fake_manager(tmp_path) + spec = [_FakeSpec(uri="https://x/a.zip", name="a")] + with patch("esphome.net_retry.http_request", side_effect=OSError("no route")): + assert pf._uri_jobs(m, spec, set()) == ([], 1, []) + resp = MagicMock(ok=False, status_code=503) + resp.headers = {"content-length": "999"} + with patch("esphome.net_retry.http_request", return_value=resp): + assert pf._uri_jobs(m, spec, set()) == ([], 1, []) + # 403 is how registries rate-limit; it must not be cached as warm + resp = MagicMock(ok=False, status_code=403) + resp.headers = {"content-length": "999"} + with patch("esphome.net_retry.http_request", return_value=resp): + assert pf._uri_jobs(m, spec, set()) == ([], 1, []) + resp = MagicMock(ok=False, status_code=405) + resp.headers = {"content-length": "999"} + with patch("esphome.net_retry.http_request", return_value=resp): + assert pf._uri_jobs(m, spec, set()) == ([], 0, []) + assert "HEAD https://x/a.zip" not in caplog.text + resp = MagicMock(ok=False, status_code=404) + resp.headers = {"content-length": "999"} + with patch("esphome.net_retry.http_request", return_value=resp): + assert pf._uri_jobs(m, spec, set()) == ([], 0, []) + assert "returned 404" not in caplog.text + + +def test_uri_jobs_dedupes_duplicate_urls(tmp_path: Path) -> None: + """Two specs with one URL yield one HEAD and one job.""" + m = _fake_manager(tmp_path) + resp = MagicMock() + resp.headers = {"content-length": "5"} + with patch("esphome.net_retry.http_request", return_value=resp) as mock_head: + jobs, failed, _installable = pf._uri_jobs( + m, + [ + _FakeSpec(uri="https://x/a.zip", name="a"), + _FakeSpec(uri="https://x/a.zip", name="a"), + ], + set(), + ) + assert failed == 0 + assert len(jobs) == 1 + mock_head.assert_called_once() + + +def test_uri_jobs_skips_installed_cached_and_seen(tmp_path: Path) -> None: + m = _fake_manager(tmp_path) + m.get_package.return_value = object() + spec = [_FakeSpec(uri="https://x/a.zip", name="a", custom_name=True)] + assert pf._uri_jobs(m, spec, set()) == ([], 0, []) + m.get_package.return_value = None + dl = Path(m.compute_download_path("https://x/a.zip", "")) + dl.parent.mkdir(parents=True, exist_ok=True) + dl.touch() + # cached: no download job, but still installable + jobs, failed, installable = pf._uri_jobs(m, spec, set()) + assert (jobs, failed) == ([], 0) + assert [n for n, _ in installable] == ["a"] + dl.unlink() + # a registry job already claimed this download path + assert pf._uri_jobs(m, spec, {str(dl)}) == ([], 0, []) + + +def test_prefetch_spawns_isolated_subprocess(tmp_path: Path) -> None: + """Heal runs first, then the subprocess spawns with pio run's libdeps + dir and the parent's PYTHONPATH preserved (the child is esphome).""" + proc = MagicMock() + proc.wait.return_value = 0 + order = MagicMock() + order.run.return_value = proc + with ( + patch( + "esphome.platformio.toolchain.heal_platformio_python_env", + order.heal, + ), + patch.object(pf.subprocess, "Popen", order.run) as mock_run, + patch.dict("os.environ", {"PYTHONPATH": "/leak"}), + ): + pf.prefetch_platformio_packages() + assert [c[0] for c in order.mock_calls[:2]] == ["heal", "run"] + (cmd,), kwargs = mock_run.call_args + assert cmd == [ + sys.executable, + "-m", + "esphome.platformio.prefetch", + str(CORE.build_path), + "testenv", + ] + assert kwargs["env"]["PLATFORMIO_LIBDEPS_DIR"] == str( + CORE.relative_piolibdeps_path().absolute() + ) + # The child is esphome itself; PYTHONPATH must survive so it imports + # the same tree (tests/integration pins the source tree through it) + assert kwargs["env"]["PYTHONPATH"] == "/leak" + assert "ESPHOME_PREFETCH_DASHBOARD" not in kwargs["env"] + proc.wait.assert_called_once_with(timeout=pf._PREFETCH_TIMEOUT) + + +def test_stop_child_windows_never_terminates() -> None: + """The Windows TerminateProcess cannot reach the SIGTERM handler, so + the graceful arm becomes a plain longer wait.""" + proc = MagicMock() + proc.wait.side_effect = [pf.subprocess.TimeoutExpired("x", 1), 0] + with patch.object(pf.sys, "platform", "win32"): + pf._stop_child(proc) + proc.terminate.assert_not_called() + proc.kill.assert_not_called() + + +def test_stop_child_surviving_child_warns(caplog: pytest.LogCaptureFixture) -> None: + """A child that outlives kill() may still be writing packages pio run + trusts; that must be visible at default verbosity.""" + timeout = pf.subprocess.TimeoutExpired("cmd", 5) + proc = MagicMock() + proc.poll.return_value = None # still running: the wait is announced + proc.wait.side_effect = [timeout, timeout, timeout] + with ( + patch.object(pf.sys, "platform", "linux"), + caplog.at_level(pf.logging.INFO), + ): + pf._stop_child(proc) + assert "Waiting for the prefetch child" in caplog.text + assert "could not be confirmed stopped" in caplog.text + + +def test_dependency_entries_isolate_a_bad_manifest(tmp_path: Path) -> None: + """One unreadable manifest skips that entry only, never the group.""" + m = _fake_manager(tmp_path) + m.get_package.side_effect = lambda spec: ( + SimpleNamespace(spec=spec) + if getattr(spec, "name", "") in ("bad", "good") + else None + ) + + def deps_for(pkg): + if pkg.spec.name == "bad": + raise RuntimeError("manifest unreadable") + return [{"owner": "o", "name": "dep", "version": "^1"}] + + m.get_pkg_dependencies.side_effect = deps_for + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + entries = pf._dependency_entries( + m, + [ + ("bad@1", _FakeSpec(name="bad")), + ("good@1", _FakeSpec(name="good")), + ], + set(), + ) + assert [name for name, *_ in entries] == ["dep"] + + +def test_dependency_entries_skip_nameless_spec( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A dependency whose spec has no name has no destination identity; + the drop is diagnosable under -v.""" + m = _fake_manager(tmp_path) + m.get_package.side_effect = lambda spec: ( + SimpleNamespace(spec=spec) if getattr(spec, "name", "") == "top" else None + ) + m.get_pkg_dependencies.return_value = [{"owner": "o", "version": "^1"}] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=None) + with caplog.at_level(logging.DEBUG): + assert ( + pf._dependency_entries(m, [("top@1", _FakeSpec(name="top"))], set()) == [] + ) + assert "has no name; left to pio run" in caplog.text + + +def test_dependency_entries_filter_seen_names(tmp_path: Path) -> None: + """A dependency already waved under its name is not queued again.""" + m = _fake_manager(tmp_path) + m.get_package.side_effect = lambda spec: ( + SimpleNamespace(spec=spec) if getattr(spec, "name", "") == "top" else None + ) + m.get_pkg_dependencies.return_value = [ + {"owner": "o", "name": "dep", "version": "^1"} + ] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + assert pf._dependency_entries(m, [("top@1", _FakeSpec(name="top"))], {"dep"}) == [] + + +def test_preinstall_cleanup_cannot_displace_the_inflight_error( + tmp_path: Path, caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch +) -> None: + """A failing unlock or cwd restore must not replace the pool's own + exception (SIGTERM's SystemExit included) with a downgradeable one.""" + m = _fake_manager(tmp_path) + m._install.side_effect = SystemExit(143) + m.unlock.side_effect = RuntimeError("flock broke") + real_chdir = pf.os.chdir + monkeypatch.setattr(pf.os, "chdir", MagicMock(side_effect=OSError("cwd removed"))) + try: + with pytest.raises(SystemExit): + pf._preinstall(m, [("a@1", _FakeSpec(name="a"))]) + finally: + monkeypatch.setattr(pf.os, "chdir", real_chdir) + assert "Could not release the manager lock" in caplog.text + + +def test_preinstall_memcache_failure_leaves_a_trace( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A failing cache reset warns and skips the dependency wave; the + wave itself still completes.""" + m = _fake_manager(tmp_path) + m.memcache_reset.side_effect = RuntimeError("cache broken") + pf._preinstall(m, [("a@1", _FakeSpec(name="a"))]) + assert "Could not reset the storage cache" in caplog.text + assert "Skipping the dependency wave" in caplog.text + m.get_pkg_dependencies.assert_not_called() + + +def test_prefetch_wait_failure_degrades(caplog: pytest.LogCaptureFixture) -> None: + """An unexpected wait() failure warns and continues; the prefetch must + never become a new way for the build to fail.""" + proc = MagicMock() + proc.wait.side_effect = [RuntimeError("wait broke"), 0] + with ( + patch("esphome.platformio.toolchain.heal_platformio_python_env"), + patch.object(pf.subprocess, "Popen", return_value=proc), + ): + pf.prefetch_platformio_packages() + assert "prefetch skipped" in caplog.text + + +def test_preinstall_stuck_lock_skips_dependency_wave( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A failed unlock leaves the lock state unknown; the recursive wave + would install under a lock() that silently no-ops.""" + m = _fake_manager(tmp_path) + m.unlock.side_effect = RuntimeError("flock broke") + pf._preinstall(m, [("a@1", _FakeSpec(name="a"))]) + assert "Skipping the dependency wave" in caplog.text + m.get_pkg_dependencies.assert_not_called() + + +def test_preinstall_lost_cwd_warns_and_skips_wave( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """A failed cwd restore is process-global state loss: it warns and + the rest is left to pio run from a clean process.""" + m = _fake_manager(tmp_path) + with patch.object(pf.os, "chdir", side_effect=OSError("cwd gone")): + pf._preinstall(m, [("a@1", _FakeSpec(name="a"))]) + assert "Could not restore the working dir" in caplog.text + assert "Skipping the dependency wave" in caplog.text + m.get_pkg_dependencies.assert_not_called() + + +def test_stop_child_interrupted_and_still_alive_warns( + caplog: pytest.LogCaptureFixture, +) -> None: + """An interrupt triggers a best-effort kill, warns when the child + cannot be confirmed dead, and re-raises so the build aborts.""" + proc = MagicMock() + proc.wait.side_effect = KeyboardInterrupt() + proc.poll.return_value = None + with pytest.raises(KeyboardInterrupt): + pf._stop_child(proc) + proc.kill.assert_called_once_with() + assert "could not be confirmed stopped" in caplog.text + + +def test_uri_derived_name_spec_downloads_but_never_installs(tmp_path: Path) -> None: + """A URL spec whose name is derived from the URI installs into a dir + named by the archive manifest, not the derived name; its archive is + prefetched, but the install stays with pio run.""" + m = _fake_manager(tmp_path) + resp = MagicMock(ok=True) + resp.headers = {"content-length": "4"} + with patch("esphome.net_retry.http_request", return_value=resp): + jobs, failed, installable = pf._uri_jobs( + m, [_FakeSpec(uri="https://x/v1.zip", name="v1")], set() + ) + assert failed == 0 + assert len(jobs) == 1 # still prefetched + assert installable == [] + # Cached-from-an-earlier-run archives are skipped the same way + dl = Path(m.compute_download_path("https://x/v1.zip", "")) + dl.parent.mkdir(parents=True, exist_ok=True) + dl.touch() + assert pf._uri_jobs(m, [_FakeSpec(uri="https://x/v1.zip", name="v1")], set()) == ( + [], + 0, + [], + ) + + +def test_dependency_entries_warn_when_all_reads_fail( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """Every manifest read failing is a systematic fault (a pio API + break), not one bad package; the waves must not vanish silently.""" + m = _fake_manager(tmp_path) + m.get_package.side_effect = lambda spec: SimpleNamespace(spec=spec) + m.get_pkg_dependencies.side_effect = RuntimeError("api break") + assert ( + pf._dependency_entries( + m, + [ + ("a@1", _FakeSpec(name="a")), + ("b@1", _FakeSpec(name="b")), + ], + set(), + ) + == [] + ) + assert "Could not read dependencies of 2 of 2" in caplog.text + + +def _proc(wait_effect) -> MagicMock: + proc = MagicMock() + if isinstance(wait_effect, BaseException): + proc.wait.side_effect = [wait_effect, 0] + else: + proc.wait.return_value = wait_effect + return proc + + +def test_prefetch_passes_dashboard_flag(tmp_path: Path) -> None: + """The dashboard flag reaches the child so its bar still draws.""" + CORE.dashboard = True + proc = MagicMock() + proc.wait.return_value = 0 + with ( + patch("esphome.platformio.toolchain.heal_platformio_python_env"), + patch.object(pf.subprocess, "Popen", return_value=proc) as mock_popen, + ): + pf.prefetch_platformio_packages() + assert mock_popen.call_args[1]["env"]["ESPHOME_PREFETCH_DASHBOARD"] == "1" + + +@pytest.mark.parametrize( + ("wait_effect", "spawn_error", "expected"), + [ + ("timeout", None, "prefetch timed out"), + (4, None, "prefetch skipped (exit 4)"), + # Exit 1 is the interpreter's own import-failure code, never quiet + (1, None, "prefetch skipped (exit 1)"), + (None, OSError("no exec"), "PlatformIO package prefetch skipped"), + ], +) +def test_prefetch_spawn_failures_warn_and_continue( + caplog: pytest.LogCaptureFixture, wait_effect, spawn_error, expected +) -> None: + """Timeouts, nonzero exits, and spawn failures each warn, never raise; + a timed-out child is stopped gracefully. The mock is built per test: + a collection-time mock's consumable side_effect breaks reruns.""" + if spawn_error is not None: + popen_effect = {"side_effect": spawn_error} + elif wait_effect == "timeout": + popen_effect = { + "return_value": _proc( + pf.subprocess.TimeoutExpired("cmd", pf._PREFETCH_TIMEOUT) + ) + } + else: + popen_effect = {"return_value": _proc(wait_effect)} + with ( + patch("esphome.platformio.toolchain.heal_platformio_python_env"), + patch.object(pf.subprocess, "Popen", **popen_effect), + ): + pf.prefetch_platformio_packages() + assert expected in caplog.text + + +def test_stop_child_waits_terminates_then_kills() -> None: + """The stop sequence waits for a self-unwinding child first, then + SIGTERMs, and kills only a child that will not stop. The platform is + pinned: on Windows the terminate arm is deliberately skipped.""" + timeout = pf.subprocess.TimeoutExpired("cmd", 5) + with patch.object(pf.sys, "platform", "linux"): + # Child already unwinding from its own SIGINT: no signals at all + proc = MagicMock() + proc.wait.return_value = 0 + pf._stop_child(proc) + proc.terminate.assert_not_called() + # Child needs the SIGTERM unwind + proc = MagicMock() + proc.wait.side_effect = [timeout, 0] + pf._stop_child(proc) + proc.terminate.assert_called_once_with() + proc.kill.assert_not_called() + # Child ignoring SIGTERM is killed with a bounded reap + proc = MagicMock() + proc.wait.side_effect = [timeout, timeout, 0] + pf._stop_child(proc) + proc.kill.assert_called_once_with() + # An interrupt mid-stop re-raises so the build aborts + proc = MagicMock() + proc.wait.side_effect = KeyboardInterrupt() + with pytest.raises(KeyboardInterrupt): + pf._stop_child(proc) + + +def test_preinstall_failure_removes_torn_destination(tmp_path: Path) -> None: + """A failed install removes whatever get_package can see so pio run + genuinely reinstalls it; a cleanup failure warns.""" + m = _fake_manager(tmp_path) + m._install.side_effect = RuntimeError("postinstall failed") + # cleanup lookup first, then the dependency-wave lookup + m.get_package.side_effect = [SimpleNamespace(path=str(tmp_path / "torn")), None] + removed: list[str] = [] + with patch.object(pf, "rmtree", side_effect=removed.append): + pf._preinstall(m, [("bad@1", _FakeSpec(name="bad"))]) + assert removed == [str(tmp_path / "torn")] + + +def test_preinstall_system_exit_still_cleans(tmp_path: Path) -> None: + """A worker SystemExit runs the torn cleanup before propagating.""" + m = _fake_manager(tmp_path) + m._install.side_effect = SystemExit(143) + m.get_package.side_effect = [SimpleNamespace(path=str(tmp_path / "torn")), None] + removed: list[str] = [] + with ( + patch.object(pf, "rmtree", side_effect=removed.append), + pytest.raises(SystemExit), + ): + pf._preinstall(m, [("bad@1", _FakeSpec(name="bad"))]) + assert removed == [str(tmp_path / "torn")] + + +def test_preinstall_stuck_tree_drops_metadata( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """An unremovable torn tree loses its .piopm so pio run reinstalls + it instead of trusting it forever.""" + m = _fake_manager(tmp_path) + m._install.side_effect = RuntimeError("boom") + torn = tmp_path / "torn" + torn.mkdir() + (torn / ".piopm").write_text("{}") + m.get_package.side_effect = [SimpleNamespace(path=str(torn)), None] + with patch.object(pf, "rmtree", side_effect=OSError("busy")): + pf._preinstall(m, [("bad@1", _FakeSpec(name="bad"))]) + assert not (torn / ".piopm").exists() + assert torn.exists() # tidiness is best-effort; metadata is the invariant + + +def test_preinstall_cleanup_failure_warns( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + m = _fake_manager(tmp_path) + m._install.side_effect = RuntimeError("boom") + m.get_package.side_effect = [OSError("scan failed"), None] + pf._preinstall(m, [("bad@1", _FakeSpec(name="bad"))]) + assert "Could not remove the failed install of bad@1" in caplog.text + + +def test_dependency_entries_honor_compatibility(tmp_path: Path) -> None: + """A dependency pio's install_dependency would skip as incompatible is + not pre-installed either.""" + m = _fake_manager(tmp_path) + m.compatibility = PackageCompatibility(platforms=["espressif32"]) + # only the top-level entry is installed; the deps are not + m.get_package.side_effect = lambda spec: ( + SimpleNamespace(spec=spec) if getattr(spec, "name", "") == "top" else None + ) + m.get_pkg_dependencies.return_value = [ + {"owner": "o", "name": "espdep", "version": "^1", "platforms": ["espressif32"]}, + {"owner": "o", "name": "avrdep", "version": "^1", "platforms": ["atmelavr"]}, + ] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + entries = pf._dependency_entries(m, [("top@1", _FakeSpec(name="top"))], set()) + assert [name for name, *_ in entries] == ["espdep"] + + +def test_dependency_entries_skip_builtin_libs(tmp_path: Path) -> None: + """An owner-less versioned dep naming a framework builtin (the dict + manifest form of SPI/Wire) is skipped like pio's install_dependency; + a registry copy would shadow the bundled library.""" + m = _fake_manager(tmp_path) + m.is_builtin_lib.side_effect = lambda name: name == "SPI" + m.get_package.side_effect = lambda spec: ( + SimpleNamespace(spec=spec) if getattr(spec, "name", "") == "top" else None + ) + m.get_pkg_dependencies.return_value = [ + {"name": "SPI", "version": "*"}, + {"name": "realdep", "version": "^1"}, + ] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + entries = pf._dependency_entries(m, [("top@1", _FakeSpec(name="top"))], set()) + assert [name for name, *_ in entries] == ["realdep"] + + +def test_prefetch_interrupt_stops_child_gracefully() -> None: + """On Ctrl-C the stop sequence waits first; a child that exits on its + own is never signalled, and the interrupt re-raises.""" + proc = MagicMock() + proc.wait.side_effect = [KeyboardInterrupt(), 0] + with ( + patch("esphome.platformio.toolchain.heal_platformio_python_env"), + patch.object(pf.subprocess, "Popen", return_value=proc), + pytest.raises(KeyboardInterrupt), + ): + pf.prefetch_platformio_packages() + # the stop sequence's first wait saw the child exit on its own + proc.terminate.assert_not_called() + proc.kill.assert_not_called() + + +def test_prefetch_child_handled_failure_is_quiet( + caplog: pytest.LogCaptureFixture, +) -> None: + """Exit _EXIT_HANDLED (3) means the child already warned with the + reason; the parent adds no second warning.""" + proc = MagicMock() + proc.wait.return_value = pf._EXIT_HANDLED + with ( + patch("esphome.platformio.toolchain.heal_platformio_python_env"), + patch.object(pf.subprocess, "Popen", return_value=proc), + ): + pf.prefetch_platformio_packages() + assert "prefetch skipped" not in caplog.text + + +def test_main_guards_and_exits_nonzero(caplog: pytest.LogCaptureFixture) -> None: + """A swallowed failure still reaches the parent as a nonzero exit; the + parent warns and continues, never failing the build.""" + with patch.object(pf, "_prefetch", side_effect=RuntimeError("boom")): + assert pf.main(["/b", "testenv"]) == pf._EXIT_HANDLED + assert "PlatformIO package prefetch skipped" in caplog.text + + +def test_main_runs_prefetch(tmp_path: Path) -> None: + with patch.object(pf, "_prefetch") as mock_prefetch: + assert pf.main([str(tmp_path), "testenv"]) == 0 + mock_prefetch.assert_called_once_with(tmp_path, "testenv") + + +def test_main_bad_argv_is_a_distinct_exit( + caplog: pytest.LogCaptureFixture, +) -> None: + """A parent/child wiring bug must not look like a network failure.""" + with patch.object(pf, "_prefetch") as mock_prefetch: + assert pf.main(["only-one"]) == 2 + mock_prefetch.assert_not_called() + assert "prefetch usage" in caplog.text + + +def _write_ini(tmp_path: Path, body: str) -> None: + (tmp_path / "platformio.ini").write_text(body) + + +def _write_valid_sentinel(tmp_path: Path, dirs: list[str]) -> None: + (tmp_path / pf._SENTINEL_NAME).write_text( + json.dumps({**pf._sentinel_state(tmp_path), "dirs": dirs}), encoding="utf-8" + ) + + +def test_prefetch_no_platform_returns(tmp_path: Path) -> None: + _write_ini(tmp_path, "[env:testenv]\n") + with patch.object(pf, "_registry_jobs") as mock_jobs: + pf._prefetch(tmp_path, "testenv") + mock_jobs.assert_not_called() + + +def _pio_modules(tmp_path: Path, fake_platform, fake_pm, config, lib_captures=None): + # A bare MagicMock's get_download_dir would fspath to '' and point the + # sidecar sweep at the process cwd + fake_pm.get_download_dir.return_value = str(tmp_path / "downloads") + fake_pm.DOWNLOAD_CACHE_EXPIRE = 86400 * 30 + + def fake_lib_manager(storage_dir, **kwargs): + if lib_captures is not None: + lib_captures.append(storage_dir) + return _fake_manager(tmp_path) + + modules = { + "platformio": MagicMock(), + "platformio.app": MagicMock(), + "platformio.project": MagicMock(), + "platformio.project.config": MagicMock(), + "platformio.dependencies": SimpleNamespace( + get_core_dependencies=lambda: { + "tool-scons": "~4.0", + "contrib-piohome": "~3", + } + ), + "platformio.package": MagicMock(), + "platformio.package.manager": MagicMock(), + "platformio.package.manager.library": SimpleNamespace( + LibraryPackageManager=fake_lib_manager + ), + "platformio.package.manager.platform": SimpleNamespace( + PlatformPackageManager=lambda: fake_pm + ), + "platformio.package.meta": SimpleNamespace( + PackageSpec=lambda *a, **kw: _FakeSpec( + uri=None, + name=kw.get("name") or (a[0] if a else None), + owner=kw.get("owner") + or (str(a[0]).split("/")[0] if a and "/" in str(a[0]) else None), + external=bool(a and "://" in str(a[0])), + ), + PackageCompatibility=SimpleNamespace, + ), + "platformio.platform": MagicMock(), + "platformio.platform.factory": SimpleNamespace( + PlatformFactory=SimpleNamespace(new=lambda pkg: fake_platform) + ), + } + modules[ + "platformio.project.config" + ].ProjectConfig.get_instance.return_value = config + return modules + + +def _fake_config(tmp_path: Path, env_options: dict): + config = MagicMock() + options = { + "libdeps_dir": str(tmp_path / "libdeps"), + "packages_dir": str(tmp_path / "packages"), + **env_options, + } + config.get.side_effect = lambda section, key, default=None: options.get( + key, default + ) + return config + + +def test_prefetch_all_cached_is_quiet_and_writes_sentinel(tmp_path: Path) -> None: + """A no-work run neither logs nor batches, and records the sentinel.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + (tmp_path / "packages").mkdir() + (tmp_path / "libdeps" / "testenv").mkdir(parents=True) + fake_platform = MagicMock() + fake_platform.packages = {} + config = _fake_config( + tmp_path, {"platform": "fake/p@1", "lib_deps": ["esphome/noise-c@1.0"]} + ) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + with ( + patch.dict("sys.modules", modules), + patch.object(pf, "_registry_jobs", return_value=([], 0, [])), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object(pf, "run_batch_downloads") as mock_batch, + patch.object(pf, "_preinstall") as mock_install, + ): + pf._prefetch(tmp_path, "testenv") + mock_batch.assert_not_called() + mock_install.assert_not_called() + assert pf._prefetch_is_warm(tmp_path) + + +def test_prefetch_failed_resolution_is_not_cached_as_warm(tmp_path: Path) -> None: + """A registry outage must not write the sentinel.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + (tmp_path / "packages").mkdir() + fake_platform = MagicMock() + fake_platform.packages = {} + config = _fake_config(tmp_path, {"platform": "fake/p@1"}) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + with ( + patch.dict("sys.modules", modules), + patch.object(pf, "_registry_jobs", return_value=([], 1, [])), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object(pf, "run_batch_downloads") as mock_batch, + ): + pf._prefetch(tmp_path, "testenv") + mock_batch.assert_not_called() + assert not (tmp_path / pf._SENTINEL_NAME).exists() + + +def test_sentinel_invalidation(tmp_path: Path) -> None: + """Ini changes, missing dirs, and garbage sentinels all read as cold.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + pkg_dir = tmp_path / "packages" + pkg_dir.mkdir() + assert not pf._prefetch_is_warm(tmp_path) # no sentinel yet + _write_valid_sentinel(tmp_path, [str(pkg_dir)]) + assert pf._prefetch_is_warm(tmp_path) + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@2\n") + assert not pf._prefetch_is_warm(tmp_path) # ini changed + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + pkg_dir.rmdir() + assert not pf._prefetch_is_warm(tmp_path) # recorded dir gone + (tmp_path / pf._SENTINEL_NAME).write_text("not json", encoding="utf-8") + assert not pf._prefetch_is_warm(tmp_path) + + +def test_prefetch_warm_sentinel_skips_spawn(tmp_path: Path) -> None: + """A valid sentinel skips the subprocess entirely.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + pkg_dir = tmp_path / "packages" + pkg_dir.mkdir() + _write_valid_sentinel(tmp_path, [str(pkg_dir)]) + with ( + patch("esphome.platformio.toolchain.heal_platformio_python_env"), + patch.object(pf.subprocess, "Popen") as mock_popen, + ): + pf.prefetch_platformio_packages() + mock_popen.assert_not_called() + + +def test_prefetch_end_to_end_wiring( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """Platform installs dep-free, non-optional packages plus tool-scons + resolve, libraries use the env libdeps dir, a platform sys.path rewrite + is undone, and failures warn by name.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/platform@1.0\n") + fake_platform = MagicMock() + fake_platform.packages = { + "toolchain-x": {"optional": False}, + "framework-y": {"optional": True}, + } + fake_platform.get_package_spec.side_effect = lambda name: _FakeSpec( + uri=None, name=name + ) + # Platform setup code rewrites sys.path (pioarduino penv); _prefetch + # must restore it + bogus = str(tmp_path / "penv-site-packages") + fake_platform.configure_project_packages.side_effect = lambda env, targets: ( + sys.path.insert(0, bogus) + ) + fake_pm = MagicMock() + config = _fake_config( + tmp_path, + { + "platform": "fake/platform@1.0", + "framework": "arduino", + # the bare built-in name and the interpolation are skipped; + # only the owner-qualified library resolves + "lib_deps": ["esphome/noise-c@1.0", "WiFi", "${common.lib_deps}"], + }, + ) + lib_dirs: list[str] = [] + modules = _pio_modules(tmp_path, fake_platform, fake_pm, config, lib_dirs) + (tmp_path / pf._SENTINEL_NAME).write_text("{}", encoding="utf-8") + captured: dict = {} + + def fake_registry_jobs(manager, specs, seen): + captured.setdefault("spec_batches", []).append([s.name for s in specs]) + return ( + [("toolchain-x@1", 10, lambda t: None)], + 0, + [("toolchain-x@1", specs[0])], + ) + + with ( + patch.dict("sys.modules", modules), + patch.object(pf, "_registry_jobs", side_effect=fake_registry_jobs), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object( + pf, + "run_batch_downloads", + return_value=[("toolchain-x@1", OSError("down"))], + ) as mock_batch, + patch.object(pf, "_preinstall") as mock_install, + ): + pf._prefetch(tmp_path, "testenv") + fake_pm.install.assert_called_once_with("fake/platform@1.0", skip_dependencies=True) + assert not (tmp_path / pf._SENTINEL_NAME).exists() # stale sentinel removed + fake_platform.configure_project_packages.assert_called_once_with("testenv", ["run"]) + assert bogus not in sys.path + # non-optional platform package + tool-scons (never piohome), then libs + assert captured["spec_batches"][0] == ["toolchain-x", "tool-scons"] + assert captured["spec_batches"][1] == ["esphome/noise-c@1.0"] + assert lib_dirs == [str(Path(tmp_path / "libdeps") / "testenv")] + mock_batch.assert_called_once() + assert "Could not prefetch toolchain-x@1" in caplog.text + # every installable failed its download; nothing to pre-install + mock_install.assert_not_called() + + +def test_prefetch_installs_cached_archives_without_downloads( + tmp_path: Path, +) -> None: + """Archives already in the download cache still pre-install (in + parallel) even when there is nothing to download, and no sentinel is + written until everything is installed.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + fake_platform = MagicMock() + fake_platform.packages = {} + config = _fake_config(tmp_path, {"platform": "fake/p@1"}) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + spec = _FakeSpec(name="cachedpkg") + with ( + patch.dict("sys.modules", modules), + patch.object( + pf, + "_registry_jobs", + side_effect=[([], 0, [("cachedpkg@1", spec)]), ([], 0, [])], + ), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object(pf, "run_batch_downloads") as mock_batch, + patch.object(pf, "_preinstall") as mock_install, + ): + pf._prefetch(tmp_path, "testenv") + mock_batch.assert_not_called() + assert mock_install.call_count == 1 + assert mock_install.call_args[0][1] == [("cachedpkg@1", spec)] + assert not (tmp_path / pf._SENTINEL_NAME).exists() + + +@pytest.mark.parametrize( + ("platform_group", "lib_group", "expected"), + [ + ( + [("toolchain-x@1", _FakeSpec(name="toolchain-x"))], + [], + ["configure", "install", "configure"], + ), + ([], [("noise-c@1.0", _FakeSpec(name="noise-c"))], ["configure", "install"]), + ], +) +def test_prefetch_reconfigures_only_after_platform_installs( + tmp_path: Path, platform_group: list, lib_group: list, expected: list[str] +) -> None: + """Installed platform packages get a second configure pass; libraries do not.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + order: list[str] = [] + fake_platform = MagicMock() + fake_platform.packages = {} + fake_platform.configure_project_packages.side_effect = lambda env, targets: ( + order.append("configure") + ) + config = _fake_config( + tmp_path, {"platform": "fake/p@1", "lib_deps": ["esphome/noise-c@1.0"]} + ) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + with ( + patch.dict("sys.modules", modules), + patch.object( + pf, + "_registry_jobs", + side_effect=[([], 0, platform_group), ([], 0, lib_group)], + ), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object(pf, "_preinstall", side_effect=lambda *_: order.append("install")), + ): + pf._prefetch(tmp_path, "testenv") + assert order == expected + + +@pytest.mark.parametrize( + "err", [RuntimeError("idf_tools.py failed"), SystemExit("postinstall exited")] +) +def test_prefetch_settle_failure_warns_and_continues( + tmp_path: Path, caplog: pytest.LogCaptureFixture, err: BaseException +) -> None: + """A failing second configure pass only costs the speedup.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + fake_platform = MagicMock() + fake_platform.packages = {} + fake_platform.configure_project_packages.side_effect = [None, err] + config = _fake_config(tmp_path, {"platform": "fake/p@1"}) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + with ( + patch.dict("sys.modules", modules), + patch.object( + pf, + "_registry_jobs", + side_effect=[ + ([], 0, [("toolchain-x@1", _FakeSpec(name="toolchain-x"))]), + ([], 0, []), + ], + ), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object(pf, "_preinstall"), + ): + pf._prefetch(tmp_path, "testenv") + assert f"Could not settle platform packages: {err}" in caplog.text + + +def test_preinstall_extracts_in_parallel_under_one_lock(tmp_path: Path) -> None: + """The manager lock wraps the whole batch; per-thread managers share + its package dir; one failing install leaves the rest alone.""" + m = _fake_manager(tmp_path) + installed: list[str] = [] + + def fake_install(spec, skip_dependencies, compatibility=None): + # Dependencies must be skipped: a shared dep extracted from two + # threads would race one destination dir + assert skip_dependencies is True + if spec.name == "bad": + raise RuntimeError("corrupt archive") + installed.append(spec.name) + + m._install.side_effect = fake_install + entries = [ + ("a@1", _FakeSpec(name="a")), + ("bad@1", _FakeSpec(name="bad")), + ("b@1", _FakeSpec(name="b")), + ] + pf._preinstall(m, entries) + assert sorted(installed) == ["a", "b"] + m.lock.assert_called_once_with() + m.unlock.assert_called_once_with() + assert m.memcache_reset.call_count >= 1 + + +def test_preinstall_all_failed_warns_once( + tmp_path: Path, caplog: pytest.LogCaptureFixture +) -> None: + """Every install failing is a systemic fault, not archive noise.""" + m = _fake_manager(tmp_path) + m._install.side_effect = AttributeError("_install went away") + pf._preinstall( + m, + [ + ("a@1", _FakeSpec(name="a")), + ("b@1", _FakeSpec(name="b")), + ], + ) + assert "Could not pre-install a@1" in caplog.text + assert "Could not pre-install any of 2" in caplog.text + + +def test_preinstall_dedupes_names_across_entries(tmp_path: Path) -> None: + """Two entries with one name install once (one destination dir).""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + fake_platform = MagicMock() + fake_platform.packages = {} + config = _fake_config(tmp_path, {"platform": "fake/p@1"}) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + s1 = _FakeSpec(name="dup") + s2 = _FakeSpec(name="dup") + with ( + patch.dict("sys.modules", modules), + patch.object( + pf, + "_registry_jobs", + side_effect=[([], 0, [("pkg@1", s1), ("pkg@1", s2)]), ([], 0, [])], + ), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object(pf, "_preinstall") as mock_install, + ): + pf._prefetch(tmp_path, "testenv") + mock_install.assert_called_once() + (entry,) = mock_install.call_args[0][1] + assert entry[0] == "pkg@1" + assert entry[1] is s2 # the dict comprehension keeps the last duplicate + + +def test_preinstall_runs_dependency_waves(tmp_path: Path) -> None: + """Dependencies of installed packages install in a follow-up wave, + deduped by name; name-only platform libs stay with pio run.""" + m = _fake_manager(tmp_path) + installed: list[str] = [] + m._install.side_effect = lambda spec, skip_dependencies, compatibility=None: ( + installed.append(spec.name if hasattr(spec, "name") else str(spec)) + ) + pkg = SimpleNamespace(spec="noise-c") + m.get_package.side_effect = lambda spec: ( + pkg if getattr(spec, "name", None) == "noise-c" else None + ) + m.get_pkg_dependencies.return_value = [ + {"owner": "esphome", "name": "libsodium", "version": "^1.0"}, + {"owner": "esphome", "name": "libsodium", "version": "^1.0"}, + {"name": "SPI"}, + ] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + pf._preinstall(m, [("noise-c@0.1.21", _FakeSpec(name="noise-c"))]) + assert installed == ["noise-c", "libsodium"] # dep deduped, SPI left out + # The dep wave carries its compatibility so _install searches qualified + dep_call = m._install.call_args_list[-1] + assert dep_call.kwargs["compatibility"] is not None + + +def test_preinstall_dependency_wave_skips_seen_names(tmp_path: Path) -> None: + """A dependency whose name matches an already-waved entry is not + reinstalled.""" + m = _fake_manager(tmp_path) + m.get_package.side_effect = lambda spec: SimpleNamespace(spec=spec) + m.get_pkg_dependencies.return_value = [ + {"owner": "esphome", "name": "noise-c", "version": "^0.1"}, + ] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + installed: list[str] = [] + m._install.side_effect = lambda spec, skip_dependencies, compatibility=None: ( + installed.append(getattr(spec, "name", str(spec))) + ) + pf._preinstall(m, [("noise-c@0.1.21", _FakeSpec(name="noise-c"))]) + assert installed == ["noise-c"] + + +def test_preinstall_uses_distinct_managers_in_parallel(tmp_path: Path) -> None: + """Each worker thread gets its own pre-built manager and installs + genuinely overlap (the barrier deadlocks a serial pool). The worker + count is pinned so a 1-CPU host cannot serialize the pool.""" + barrier = threading.Barrier(2, timeout=5) + used: set = set() + + class _WaveManager: + package_dir = str(tmp_path) + compatibility = None + + def __init__(self, package_dir, **kwargs) -> None: + assert package_dir == str(tmp_path) + + def lock(self) -> None: + pass + + def unlock(self) -> None: + pass + + def memcache_reset(self) -> None: + pass + + def get_tmp_dir(self) -> str: + return str(tmp_path) + + def get_download_dir(self) -> str: + return str(tmp_path) + + def get_package(self, spec): + return None + + def get_pkg_dependencies(self, pkg): + return None + + def _install(self, spec, skip_dependencies, compatibility=None) -> None: + used.add(id(self)) + barrier.wait() + + seed = _WaveManager(str(tmp_path)) + with patch.object(pf, "get_usable_cpu_count", return_value=2): + pf._preinstall( + seed, + [ + ("a@1", _FakeSpec(name="a")), + ("b@1", _FakeSpec(name="b")), + ], + ) + assert len(used) == 2 + assert id(seed) not in used + + +def test_sibling_manager_and_sigterm() -> None: + """Sibling managers inherit compatibility; SIGTERM raises SystemExit.""" + calls = [] + m = MagicMock(package_dir="p", compatibility="qual") + m.__class__ = lambda package_dir, **kw: calls.append((package_dir, kw)) + pf._sibling_manager(m) + m.compatibility = None + pf._sibling_manager(m) + assert calls == [("p", {"compatibility": "qual"}), ("p", {})] + with pytest.raises(SystemExit): + pf._sigterm(15, None) + + +def test_dependency_entries_skip_installed(tmp_path: Path) -> None: + """A dependency a previous build installed stays off the destructive + failure path.""" + m = _fake_manager(tmp_path) + m.get_package.side_effect = lambda spec: SimpleNamespace(spec=spec) + m.get_pkg_dependencies.return_value = [ + {"owner": "o", "name": "already", "version": "^1"}, + ] + m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"]) + assert pf._dependency_entries(m, [("top@1", _FakeSpec(name="top"))], set()) == [] + + +def test_group_failure_does_not_skip_other_groups(tmp_path: Path) -> None: + """One group's pre-install failure degrades that group only.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + fake_platform = MagicMock() + fake_platform.packages = {} + config = _fake_config(tmp_path, {"platform": "fake/p@1"}) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + s1 = _FakeSpec(name="toolpkg") + s2 = _FakeSpec(name="libpkg") + with ( + patch.dict("sys.modules", modules), + patch.object( + pf, + "_registry_jobs", + side_effect=[ + ([], 0, [("toolpkg@1", s1)]), + ([], 0, [("libpkg@1", s2)]), + ], + ), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + patch.object( + pf, "_preinstall", side_effect=[RuntimeError("group down"), None] + ) as mock_install, + ): + pf._prefetch(tmp_path, "testenv") + assert mock_install.call_count == 2 + + +def test_preinstall_unlocks_even_when_pool_fails(tmp_path: Path) -> None: + """A failure inside the pool cancels queued installs and releases the + lock; a failing executor construction still releases it.""" + m = _fake_manager(tmp_path) + boom = MagicMock() + boom.__enter__.return_value = boom + boom.map.side_effect = RuntimeError("no threads") + with ( + patch.object(pf, "ThreadPoolExecutor", return_value=boom), + pytest.raises(RuntimeError), + ): + pf._preinstall(m, [("a@1", _FakeSpec(name="a"))]) + m.unlock.assert_called_once_with() + assert boom.shutdown.call_args_list[0][1].get("cancel_futures") is True + m.reset_mock() + # A failing executor construction still releases the lock + with ( + patch.object(pf, "ThreadPoolExecutor", side_effect=RuntimeError("no")), + pytest.raises(RuntimeError), + ): + pf._preinstall(m, [("a@1", _FakeSpec(name="a"))]) + m.unlock.assert_called_once_with() + + +def test_prefetch_replaces_platform_tool_scons_with_core_spec(tmp_path: Path) -> None: + """A platform's own tool-scons spec gives way to the core's registry spec.""" + _write_ini(tmp_path, "[env:testenv]\nplatform = fake/p@1\n") + fake_platform = MagicMock() + fake_platform.packages = {"tool-scons": {"optional": False}} + fake_platform.get_package_spec.side_effect = lambda name: _FakeSpec( + uri="https://x/scons.zip", name=name, owner=None + ) + config = _fake_config(tmp_path, {"platform": "fake/p@1"}) + modules = _pio_modules(tmp_path, fake_platform, MagicMock(), config) + batches: list[list] = [] + with ( + patch.dict("sys.modules", modules), + patch.object( + pf, + "_registry_jobs", + side_effect=lambda mgr, specs, seen: ( + batches.append(list(specs)) or ([], 0, []) + ), + ), + patch.object(pf, "_uri_jobs", return_value=([], 0, [])), + ): + pf._prefetch(tmp_path, "testenv") + (spec,) = batches[0] + assert (spec.name, spec.owner, spec.uri) == ("tool-scons", "platformio", None) + + +def test_platformio_private_api_contract() -> None: + """The pinned PlatformIO still exposes what the pre-install drives. + + Also load-bearing but unpinnable by introspection: pio's private + _install must never re-acquire the manager's inter-process lock + (locking lives in the public install()); a re-lock would hang the + child for the full prefetch timeout, so re-check it on any bump. + + Everything else in this module mocks the managers, so this is the one + test that fails loudly when a requirements bump changes the private + surface instead of silently degrading the prefetch to a no-op. + """ + params = inspect.signature(PackageManagerInstallMixin._install).parameters + assert "spec" in params + assert "skip_dependencies" in params + assert "compatibility" in params + for cls in (ToolPackageManager, LibraryPackageManager, PlatformPackageManager): + assert "package_dir" in inspect.signature(cls.__init__).parameters + for name in ( + "lock", + "unlock", + "memcache_reset", + "get_package", + "compute_download_path", + "get_pkg_dependencies", + "dependency_to_spec", + ): + assert callable(getattr(BasePackageManager, name)) + # The dependency wave mirrors install_dependency's builtin skip + assert callable(LibraryPackageManager.is_builtin_lib) + # The prefetch keys tool-scons on this core dependency + assert "tool-scons" in get_core_dependencies() + # The pre-install passes these positionally / by keyword + assert "compatibility" in inspect.signature(BasePackageManager.__init__).parameters + lib_params = inspect.signature(LibraryPackageManager.__init__).parameters + # Capability, not implementation: an explicit compatibility= parameter + # would serve the call site just as well as **kwargs forwarding + assert "compatibility" in lib_params or any( + p.kind is inspect.Parameter.VAR_KEYWORD for p in lib_params.values() + ) + assert callable(PackageCompatibility.from_dependency) + assert callable(PackageCompatibility.is_compatible) + # Every URL spec derives a name from the URI; only a custom name + # (Foo=https://...) is also the destination dir the wave installs into + derived = PackageSpec("https://x/y/archive/master.zip") + assert derived.name and not derived.has_custom_name() + assert PackageSpec("Foo=https://x/y/archive/master.zip").has_custom_name() diff --git a/tests/unit_tests/test_platformio_toolchain.py b/tests/unit_tests/test_platformio_toolchain.py index 63c40f3609..fb99ea9208 100644 --- a/tests/unit_tests/test_platformio_toolchain.py +++ b/tests/unit_tests/test_platformio_toolchain.py @@ -932,8 +932,13 @@ def test_run_compile(setup_core: Path, mock_run_platformio_cli_run: Mock) -> Non config = {CONF_ESPHOME: {CONF_COMPILE_PROCESS_LIMIT: 4}} mock_run_platformio_cli_run.return_value = 0 - toolchain.run_compile(config, verbose=True) + with patch( + "esphome.platformio.prefetch.prefetch_platformio_packages" + ) as mock_prefetch: + toolchain.run_compile(config, verbose=True) + # The only wiring of the prefetch into a build lives here + mock_prefetch.assert_called_once_with() mock_run_platformio_cli_run.assert_called_once_with(config, True, "-j4") @@ -947,7 +952,8 @@ def test_run_compile_without_process_limit( config = {CONF_ESPHOME: {}} mock_run_platformio_cli_run.return_value = 0 - toolchain.run_compile(config, verbose=False) + with patch("esphome.platformio.prefetch.prefetch_platformio_packages"): + toolchain.run_compile(config, verbose=False) mock_run_platformio_cli_run.assert_called_once_with(config, False) @@ -1677,8 +1683,8 @@ def pio_core_dir(tmp_path: Path) -> Path: def test_current_python_minor_matches_running_interpreter() -> None: - """_current_python_minor returns major.minor of the running interpreter.""" - assert toolchain._current_python_minor() == _CURRENT_MINOR + """current_python_minor returns major.minor of the running interpreter.""" + assert toolchain.current_python_minor() == _CURRENT_MINOR def test_pio_stamp_round_trip(tmp_path: Path) -> None: diff --git a/tests/unit_tests/test_yaml_util.py b/tests/unit_tests/test_yaml_util.py index 3bdbd04396..8e1f9c25c0 100644 --- a/tests/unit_tests/test_yaml_util.py +++ b/tests/unit_tests/test_yaml_util.py @@ -1706,6 +1706,53 @@ def test_dump_path_dotdot_reference_outside_anchor() -> None: assert output.strip() == "file: ../shared/font.ttf" +@pytest.mark.parametrize( + "data_dir", + [ + pytest.param(Path("/config/.esphome"), id="cli"), + pytest.param(Path("/data"), id="addon"), + ], +) +def test_dump_path_under_data_dir_uses_default_location(data_dir: Path) -> None: + """Test that Path values under data_dir dump as .esphome/ for any layout.""" + anchor = Path("/config").absolute() + path = data_dir.absolute() / "image" / "c44630d6" + output = yaml_util.dump( + {"file": path}, relative_to=anchor, data_dir=data_dir.absolute() + ) + assert output.strip() == "file: .esphome/image/c44630d6" + + +def test_dump_path_equal_to_data_dir() -> None: + """Test that the data dir itself dumps as .esphome, matching the default layout.""" + anchor = Path("/config").absolute() + data_dir = Path("/data").absolute() + output = yaml_util.dump({"dir": data_dir}, relative_to=anchor, data_dir=data_dir) + assert output.strip() == "dir: .esphome" + default = yaml_util.dump( + {"dir": anchor / ".esphome"}, relative_to=anchor, data_dir=anchor / ".esphome" + ) + assert default == output + + +def test_dump_path_outside_data_dir_still_relative_to_anchor() -> None: + """Test that data_dir does not affect paths that are not under it.""" + anchor = Path("/config").absolute() + path = anchor / "fonts" / "arial.ttf" + output = yaml_util.dump( + {"file": path}, relative_to=anchor, data_dir=Path("/data").absolute() + ) + assert output.strip() == "file: fonts/arial.ttf" + + +def test_dump_path_data_dir_without_relative_to_is_unchanged() -> None: + """Test that data_dir alone does not change the output.""" + data_dir = Path("/data").absolute() + path = data_dir / "image" / "c44630d6" + output = yaml_util.dump({"file": path}, data_dir=data_dir) + assert output.strip() == f"file: {path}" + + def test_dump_relative_to_does_not_leak_between_calls() -> None: """Test that the relative_to flag is scoped to a single dump call.""" anchor = Path("/config/esphome").absolute()