diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..94bc76b --- /dev/null +++ b/.dockerignore @@ -0,0 +1,9 @@ +.git +.venv +.pytest_cache +.ruff_cache +.coverage +htmlcov +dist +tests +docs diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..c9a2e17 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,19 @@ +version: 2 +updates: + # Production dependencies only: a new mail-parser on PyPI becomes a PR, + # then a release and a new image. + - package-ecosystem: uv + directory: / + schedule: + interval: weekly + allow: + - dependency-type: production + labels: + - patch_release + + - package-ecosystem: github-actions + directory: / + schedule: + interval: weekly + labels: + - patch_release diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..5c4cc93 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,95 @@ +name: CI - Build and Test + +on: + pull_request: + branches: [main] + # labeled/unlabeled re-run the label check when release labels change. + types: [opened, synchronize, reopened, labeled, unlabeled] + +# Cancel in-progress runs for the same branch +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +permissions: + contents: read + pull-requests: read + +jobs: + # Lint, test, and build in a single runner — avoids 2x checkout + uv-sync overhead + lint-test-build: + runs-on: ubuntu-26.04 + steps: + # The release label check runs here, in the required job, and not in a + # separate job this one needs: a job skipped because a needed job failed + # satisfies the required check, so an unlabeled PR would be mergeable. + - name: Check release labels + env: + GH_TOKEN: ${{ github.token }} + PR_NUMBER: ${{ github.event.pull_request.number }} + REPO: ${{ github.repository }} + run: | + # Fetch labels from GitHub API to ensure we get the latest + PR_LABELS=$(gh api "repos/${REPO}/pulls/${PR_NUMBER}" --jq '.labels[].name') + echo "PR Labels: $(echo "$PR_LABELS" | tr '\n' ' ')" + + # Count release labels: one label per line, whole-line matches only, + # so a label such as not_patch_release does not count. + TOTAL_RELEASE_LABELS=$(echo "$PR_LABELS" | grep -cxE "major_release|minor_release|patch_release" || true) + + echo "Found $TOTAL_RELEASE_LABELS release label(s)" + + if [ "$TOTAL_RELEASE_LABELS" -eq 0 ]; then + echo "::error::No release label found. Please add exactly one of: major_release, minor_release, or patch_release" + exit 1 + elif [ "$TOTAL_RELEASE_LABELS" -gt 1 ]; then + echo "::error::Multiple release labels found. Please use exactly one of: major_release, minor_release, or patch_release" + exit 1 + fi + + echo "Valid release label found" + + - name: Checkout code + uses: actions/checkout@v7 + + - name: Set up Python 3.13 + uses: actions/setup-python@v7 + with: + python-version: '3.13' + + - name: Install uv + uses: astral-sh/setup-uv@v10.3.3 + with: + enable-cache: true + + - name: Install dependencies + run: | + uv sync --all-extras + echo "VIRTUAL_ENV=.venv" >> $GITHUB_ENV + echo "PATH=${{ github.workspace }}/.venv/bin:${PATH}" >> $GITHUB_ENV + + - name: Lint + run: make pre-commit + + - name: Test + run: make test-cov + + - name: Upload coverage report + uses: actions/upload-artifact@v7 + with: + name: coverage-report + path: htmlcov/ + retention-days: 7 + + # Building the image installs the package from uv.lock, so a broken + # lockfile or Dockerfile fails here, before a release tag exists. + - uses: docker/setup-buildx-action@v4 + + - name: Build image + uses: docker/build-push-action@v7 + with: + context: . + push: false + platforms: linux/amd64 + cache-from: type=gha + cache-to: type=gha,mode=max diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..190a982 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,175 @@ +name: Release + +# pull_request_target runs in the context of main, so a merged pull request +# from a fork still gets the deploy key and packages: write. It is safe here +# because no job ever checks out the pull request code: the release job checks +# out main and the later jobs check out the new tag. +on: + pull_request_target: + types: [closed] + branches: [main] + +# Two quick merges queue instead of racing on the version bump. +concurrency: + group: release + cancel-in-progress: false + +# Each job asks only for the permissions it needs. +permissions: {} + +env: + REGISTRY: ghcr.io + VERSION_FILE: src/mail_parser_api/__init__.py + +jobs: + check-release: + if: github.event.pull_request.merged == true + runs-on: ubuntu-26.04 + outputs: + release_type: ${{ steps.check-labels.outputs.release_type }} + should_release: ${{ steps.check-labels.outputs.should_release }} + steps: + - name: Check PR labels for release type + id: check-labels + env: + PR_LABELS: ${{ toJson(github.event.pull_request.labels.*.name) }} + run: | + if echo "$PR_LABELS" | grep -q "major_release"; then + echo "release_type=major" >> $GITHUB_OUTPUT + echo "should_release=true" >> $GITHUB_OUTPUT + elif echo "$PR_LABELS" | grep -q "minor_release"; then + echo "release_type=minor" >> $GITHUB_OUTPUT + echo "should_release=true" >> $GITHUB_OUTPUT + elif echo "$PR_LABELS" | grep -q "patch_release"; then + echo "release_type=patch" >> $GITHUB_OUTPUT + echo "should_release=true" >> $GITHUB_OUTPUT + else + echo "release_type=none" >> $GITHUB_OUTPUT + echo "should_release=false" >> $GITHUB_OUTPUT + echo "No release label found — skipping release." + fi + + release: + needs: check-release + if: needs.check-release.outputs.should_release == 'true' + runs-on: ubuntu-26.04 + # The release environment holds RELEASE_DEPLOY_KEY and only main can use it. + environment: release + # The bump commit and the tag are pushed over SSH with the deploy key, not + # with GITHUB_TOKEN, so the token only needs to read. + permissions: + contents: read + outputs: + new_version: ${{ steps.bump-version.outputs.new_version }} + steps: + # The deploy key is the ruleset bypass actor: it lets the bump commit + # and the tag reach main without a pull request. + - uses: actions/checkout@v7 + with: + ref: main + fetch-depth: 0 + ssh-key: ${{ secrets.RELEASE_DEPLOY_KEY }} + + - name: Configure Git + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + + - name: Bump version + id: bump-version + env: + RELEASE_TYPE: ${{ needs.check-release.outputs.release_type }} + run: | + CURRENT=$(grep -oP '__version__ = "\K[^"]+' "$VERSION_FILE") + echo "Current version: $CURRENT" + [[ $CURRENT =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::invalid version"; exit 1; } + + IFS='.' read -ra PARTS <<< "$CURRENT" + MAJOR=${PARTS[0]}; MINOR=${PARTS[1]}; PATCH=${PARTS[2]} + + case $RELEASE_TYPE in + major) MAJOR=$((MAJOR + 1)); MINOR=0; PATCH=0 ;; + minor) MINOR=$((MINOR + 1)); PATCH=0 ;; + patch) PATCH=$((PATCH + 1)) ;; + esac + + NEW="${MAJOR}.${MINOR}.${PATCH}" + echo "New version: $NEW" + echo "new_version=$NEW" >> $GITHUB_OUTPUT + + sed -i "s/__version__ = \"$CURRENT\"/__version__ = \"$NEW\"/" "$VERSION_FILE" + + git add "$VERSION_FILE" + git commit -m "chore: bump version to $NEW [skip ci]" + git tag -a "v$NEW" -m "Release v$NEW" + git push origin main --tags + + publish-docker: + needs: release + runs-on: ubuntu-26.04 + permissions: + contents: read + packages: write + steps: + - uses: actions/checkout@v7 + with: + ref: v${{ needs.release.outputs.new_version }} + + - name: Set lowercase image name + id: image + run: echo "name=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT + + - uses: docker/setup-qemu-action@v4 + - uses: docker/setup-buildx-action@v4 + + - name: Log in to GHCR + uses: docker/login-action@v4 + with: + registry: ${{ env.REGISTRY }} + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + + - name: Build and push + uses: docker/build-push-action@v7 + with: + context: . + push: true + tags: | + ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:${{ needs.release.outputs.new_version }} + ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:latest + labels: | + org.opencontainers.image.title=mail-parser-api + org.opencontainers.image.description=Stateless HTTP API that parses raw emails with mail-parser + org.opencontainers.image.source=https://github.com/${{ github.repository }} + org.opencontainers.image.version=${{ needs.release.outputs.new_version }} + org.opencontainers.image.licenses=Apache-2.0 + cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:buildcache + cache-to: type=registry,ref=${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:buildcache,mode=max + platforms: linux/amd64,linux/arm64 + + create-github-release: + needs: [release, publish-docker] + runs-on: ubuntu-26.04 + permissions: + contents: write + steps: + - name: Set lowercase image name + id: image + run: echo "name=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT + + - name: Create GitHub Release + uses: softprops/action-gh-release@v3 + with: + tag_name: v${{ needs.release.outputs.new_version }} + name: Release v${{ needs.release.outputs.new_version }} + generate_release_notes: true + body: | + ## Docker Image + + ```bash + docker pull ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:${{ needs.release.outputs.new_version }} + ``` + draft: false + prerelease: false + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5968e0d --- /dev/null +++ b/.gitignore @@ -0,0 +1,135 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + + + + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +Pipfile.lock + +# poetry +poetry.lock + +# pdm +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582 +__pypackages__/ + + + +# Environments +.env +.env.* +!.env.example +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject.db +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# IDE +.idea/ +.vscode/ +*.swp +*.swo + +# OS +.DS_Store +Thumbs.db diff --git a/.markdownlint.json b/.markdownlint.json new file mode 100644 index 0000000..1dd8622 --- /dev/null +++ b/.markdownlint.json @@ -0,0 +1,6 @@ +{ + "default": true, + "MD013": false, + "MD033": false, + "MD041": false +} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..8c36981 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,54 @@ +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.17.4 + hooks: + - id: ruff + args: [--fix] + - id: ruff-format + + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + # Sample emails are test data and must stay byte-for-byte as received. + - id: trailing-whitespace + exclude: ^tests/unittests/files/ + - id: end-of-file-fixer + exclude: ^tests/unittests/files/ + - id: check-yaml + - id: check-added-large-files + args: ['--maxkb=5000'] + - id: check-case-conflict + - id: check-json + - id: check-merge-conflict + - id: detect-aws-credentials + args: ["--allow-missing-credentials"] + - id: detect-private-key + - id: mixed-line-ending + exclude: ^tests/unittests/files/ + - id: check-ast + + - repo: https://github.com/executablebooks/mdformat + rev: 0.7.22 + hooks: + - id: mdformat + additional_dependencies: + - mdformat-frontmatter + - mdformat-gfm + - mdformat-tables + + - repo: https://github.com/DavidAnson/markdownlint-cli2 + rev: v0.24.0 + hooks: + - id: markdownlint-cli2 + language_version: 22.17.1 + args: ['--config', '.markdownlint.json'] + + - repo: local + hooks: + - id: pyright + name: pyright + entry: uv run pyright + args: [src/, tests/] + language: system + pass_filenames: false + types: [python] diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..a9492eb --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,119 @@ +# AGENTS.md + +Shared instructions for coding agents. `CLAUDE.md` imports this file, so Claude +and Codex follow the same rules. + +## Language + +- Write all code, comments, docstrings, commit messages, and documentation in English. +- Everything under `docs/` (specs, issues, ADRs, agent docs) must be in English. +- This applies even when the conversation with the user is in another language + (e.g. Italian): chat language never changes the language of repository content. + +## Security + +- The service handles untrusted emails: never log request bodies, email + headers, or any email content, and keep email content out of exception + messages. +- Parse emails only in the mail-parser subprocess: fixed argument list, email on + stdin, timeout. Never use `shell=True` or pass input as arguments. +- Validate and reject input at the HTTP boundary (content type, size, rate limit) + before parsing. +- Never hardcode secrets, tokens, or credentials. The only secret is the + `RELEASE_DEPLOY_KEY` GitHub secret used by the release workflow. +- Pin dependency versions in `uv.lock`. + +## Engineering Principles + +- **DRY** — extract repeated logic; no copy-paste code. +- **KISS** — simplest solution that works; no clever tricks. +- **YAGNI** — no code for hypothetical future needs. +- **SRP** — one function/class, one responsibility. +- **Fail fast** — validate at boundaries; trust internal code. +- No dead code, commented-out blocks, or unused imports. +- Every third-party import must have an explicit entry in `pyproject.toml`. Use extras when the runtime feature requires them (e.g. `mail-parser[outlook]`). + +## Python Style + +- Follow PEP 8. Use 4 spaces, never tabs. +- Lines: 88 chars max (enforced by ruff `line-length`). +- `snake_case` for functions/variables, `CapWords` for classes, `UPPER_CASE` for constants. +- Imports order: stdlib → third-party → local. +- Add docstrings to all public functions, methods, classes, and modules (params, return values, exceptions). + +## Stack + +- Python 3.13+, package manager: **uv**, build backend: **hatchling** +- Web framework: **FastAPI** served by **uvicorn** +- Parser: **mail-parser** CLI, run in a subprocess +- Linter/formatter: **ruff** (line-length 88, aggressive rule set — see `pyproject.toml`) +- Type checker: **pyright** (runs as pre-commit hook on `src/` and `tests/`) +- Tests: **pytest** with `tests/unittests/` layout and FastAPI `TestClient` + +## Project Layout + +```text +src/mail_parser_api/ + app.py # FastAPI app: routes, request checks, access log + parser.py # mail-parser subprocess and JSON shaping + rate_limit.py # in-memory per-client rate limiter +tests/unittests/ # mirrors src layout; sample emails in files/ +``` + +## Workflow + +After every change: + +1. Add/update unittests to cover the change. +1. Update README.md if the change affects usage, API, limits, or setup. +1. Stage changes and run pre-commit; fix all reported issues before proceeding. +1. Run full test suite; fix all failures before reporting done. + +```bash +git add +make pre-commit +make test +``` + +Every pull request needs exactly one release label (`major_release`, +`minor_release`, `patch_release`); see the release process in `README.md`. + +## Commands + +```bash +make install # install dependencies via uv +make test # run tests +make test-cov # run tests with coverage (HTML report in htmlcov/) +make lint # ruff check +make lint-fix # ruff check --fix +make format # ruff format +make pre-commit # run all pre-commit hooks +make clean # remove build artifacts and caches +make up # build and start the container on port 8000 +make down # stop the container +``` + +Run single test: `uv run pytest tests/unittests/path/to/test_file.py::test_name` +Type check: `uv run pyright src/ tests/` + +## Ruff Rules + +Strict config — many rule families enabled. Key ignores: + +- `D100`, `D104`: no module/package docstrings required +- `D203`/`D213` disabled (use `D211`/`D212`) +- `tests/**`: `S101` (assert), `ANN`, `D` all ignored + +## Agent skills + +### Issue tracker + +Issues and specs live as markdown files under `docs/features//` in this repo. See `docs/agents/issue-tracker.md`. + +### Triage labels + +The five canonical triage roles, used verbatim (`needs-triage`, `needs-info`, `ready-for-agent`, `ready-for-human`, `wontfix`), recorded as a `Status:` line in each issue file. See `docs/agents/triage-labels.md`. + +### Domain docs + +Single-context: `GLOSSARY.md` + `docs/adr/` at the repo root, both created lazily. See `docs/agents/domain.md`. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..9a8da17 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,5 @@ +# CLAUDE.md + +The shared agent instructions live in `AGENTS.md`. + +@AGENTS.md diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..757a233 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,36 @@ +FROM python:3.13-slim + +RUN pip install --no-cache-dir uv + +# Bytecode is compiled at build time because the container root filesystem is +# read-only at runtime. +ENV PATH="/app/.venv/bin:$PATH" \ + UV_COMPILE_BYTECODE=1 \ + UV_LINK_MODE=copy \ + PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 + +WORKDIR /app + +COPY pyproject.toml uv.lock README.md ./ + +RUN uv sync --no-dev --frozen --no-install-project + +COPY src/ src/ + +RUN uv sync --no-dev --frozen + +RUN useradd --system --uid 10001 --no-create-home --shell /usr/sbin/nologin app + +USER app + +EXPOSE 8000 + +# One worker keeps the in-memory rate limiter consistent; uvicorn's access log +# is replaced by the application's own, which omits client addresses. The +# concurrency limit is above the two parse slots so that health checks still +# get through while parses wait for a slot. +CMD ["uvicorn", "mail_parser_api.app:create_app", "--factory", \ + "--host", "0.0.0.0", "--port", "8000", \ + "--workers", "1", "--limit-concurrency", "12", \ + "--no-access-log", "--no-server-header"] diff --git a/GLOSSARY.md b/GLOSSARY.md new file mode 100644 index 0000000..8121d24 --- /dev/null +++ b/GLOSSARY.md @@ -0,0 +1,28 @@ +# mail-parser-api + +Stateless HTTP service that turns a raw email into the JSON produced by +mail-parser, without storing anything. + +## Language + +**Raw email**: +The bytes of an email exactly as received, in RFC 822 / RFC 5322 format, sent +as the request body with `Content-Type: message/rfc822`. +_Avoid_: EML, message body, input + +**Parsed message**: +The `mail_json` that mail-parser produces for one raw email, returned under +`message` with the `payload` key removed from every attachment. +_Avoid_: Result, report, analysis + +**Parse service**: +This API: it receives a raw email, runs the mail-parser CLI on it in a +subprocess, and returns the parsed message. It keeps no state except the rate +limiter's counters. +_Avoid_: Backend, parser server, worker + +**Client key**: +The identity the rate limiter counts requests against: the first +`X-Forwarded-For` value or the peer address, an IPv4 address whole or an IPv6 +address collapsed to its `/64` network. +_Avoid_: Client IP, user, session diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0030b68 --- /dev/null +++ b/Makefile @@ -0,0 +1,50 @@ +.PHONY: help install lint lint-fix format test test-cov pre-commit clean up down + +PYTEST := uv run pytest +RUFF := uv run ruff +PRE_COMMIT := uv run pre-commit + +help: + @echo "Commands:" + @echo " install Install all dependencies" + @echo " lint Run ruff linter" + @echo " lint-fix Run ruff linter with auto-fix" + @echo " format Run ruff formatter" + @echo " test Run tests" + @echo " test-cov Run tests with coverage report" + @echo " pre-commit Run pre-commit on all files" + @echo " clean Remove build artifacts and caches" + @echo " up Build and start the service on port 8000" + @echo " down Stop the service" + +install: + uv sync + +lint: + $(RUFF) check . + +lint-fix: + $(RUFF) check --fix . + +format: + $(RUFF) format . + +test: + $(PYTEST) tests/ + +test-cov: + $(PYTEST) tests/ --cov=mail_parser_api --cov-report=term-missing --cov-report=html + +pre-commit: + $(PRE_COMMIT) run --all-files + +clean: + find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null; true + find . -type f -name "*.pyc" -delete + rm -rf .pytest_cache .ruff_cache .coverage dist build htmlcov + +up: + docker compose up -d --build + +down: + docker compose down diff --git a/README.md b/README.md index 1021b91..8073f35 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,127 @@ # mail-parser-api Stateless HTTP API that parses raw emails with -[mail-parser](https://github.com/SpamScope/mail-parser). +[mail-parser](https://github.com/SpamScope/mail-parser) and returns the parsed +message as JSON. It powers the live parser on [spamscope.ai](https://spamscope.ai). + +Nothing is stored: each email is parsed in memory, in a short-lived subprocess, +and only the JSON goes back to the caller. + +## Endpoint contract + +### `POST /api/parse` + +Send the raw email as the request body with `Content-Type: message/rfc822`. + +```bash +curl -s -H 'Content-Type: message/rfc822' --data-binary @email.eml \ + http://localhost:8000/api/parse +``` + +Response `200`: + +```json +{ + "mail_parser_version": "4.10.0", + "message": {"subject": "...", "attachments": [{"filename": "...", "binary": true}]} +} +``` + +`message` is the full `mail_json` of mail-parser. Every entry of `attachments` +keeps its metadata and loses the `payload` key. + +| Status | When | Body | +| ------ | ------------------------------------------------------------ | --------------------------------------------------- | +| `413` | Body larger than 5 MB | `{"detail": "Body exceeds 5 MB"}` | +| `415` | `Content-Type` is not `message/rfc822` | `{"detail": "Content-Type must be message/rfc822"}` | +| `415` | `Content-Type` is `application/vnd.ms-outlook` | `{"detail": "Outlook .msg not supported yet"}` | +| `422` | mail-parser fails on the email | `{"detail": ""}` | +| `429` | More than 10 requests in 60 seconds from the same client key | `{"detail": "Too many requests"}` | +| `504` | Parsing takes longer than 10 seconds | `{"detail": "Parsing timed out"}` | + +mail-parser is tolerant: most malformed emails still return `200`, with +`has_defects` and `defects_categories` describing the problems. + +### `GET /healthz` + +Returns `200` with `{"status": "ok"}`. It is meant for container health checks; +the reverse proxy does not expose it. + +## Limits and isolation + +- Each request runs the installed mail-parser CLI (`mail-parser --stdin --json`) + in a subprocess. The email goes to its stdin, never through a shell; the + subprocess is killed after 10 seconds. +- The request body is limited to 5 MB. +- At most 2 emails are parsed at once; further requests wait for a free slot. +- In the container each parse is limited to 192 MiB of address space + (`prlimit`) and is the first process the kernel kills when memory runs out + (`choom`), so the server survives. Such an email gets `422` with + `email too complex to parse within the service limits`. +- Rate limit: 10 requests per 60-second sliding window per client key, in + memory, for at most 10 000 keys (least recently used evicted first). The + client key is the first `X-Forwarded-For` value, or the peer address without + it: an IPv4 address whole, an IPv6 address collapsed to its `/64`. The header + is trusted because the service runs only behind a reverse proxy that sets it. +- uvicorn runs one worker with `--limit-concurrency 12`, above the parse + slots so that health checks still get through. +- The access log has only method, path, status and response size. Request + bodies and email headers are never logged. +- The container image runs as a non-root user and works with a read-only root + filesystem, all capabilities dropped and a `tmpfs` on `/tmp`. + +## Run locally + +Requirements: [uv](https://docs.astral.sh/uv/) and, for the container, Docker. + +```bash +make install +uv run uvicorn mail_parser_api.app:create_app --factory --port 8000 +``` + +With Docker Compose, using the same hardening as production: + +```bash +make up # build and start on http://localhost:8000 +make down +``` + +## Development + +```bash +make pre-commit # ruff, ruff-format, pyright, mdformat, markdownlint, ... +make test-cov # tests with coverage +``` + +See [CLAUDE.md](CLAUDE.md) for the coding rules. + +## Release process + +Every pull request to `main` needs exactly one release label: `major_release`, +`minor_release` or `patch_release`. CI checks the label, then runs lint, tests +and a `linux/amd64` image build without pushing (`lint-test-build`, required +before merge), so a broken lockfile or Dockerfile fails before a tag exists. + +When the pull request is squash-merged, the release workflow +(`pull_request_target`, so merged fork pull requests release too; it never +checks out pull request code) runs one release at a time and: + +1. bumps `__version__` in `src/mail_parser_api/__init__.py` according to the + label and tags `vX.Y.Z`, pushed with the `RELEASE_DEPLOY_KEY` deploy key, + a secret of the `release` environment that only `main` can use; +1. publishes `ghcr.io/spamscope/mail-parser-api:X.Y.Z` and `:latest` for + `linux/amd64` and `linux/arm64`; +1. creates the GitHub release with generated notes. + +Two rulesets protect `main`. `main` requires a pull request and the +`lint-test-build` check; the deploy key is its only bypass actor, so the bump +commit can land without a pull request. `main-protect` blocks deletion and +force pushes with no bypass, not even for the deploy key. + +Dependabot opens weekly pull requests, labelled `patch_release`, for production +dependencies and GitHub Actions, so a new mail-parser on PyPI becomes a new +release and a new image. + +## License + +[Apache-2.0](LICENSE) diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..4685ac5 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,10 @@ +# Local run with the same hardening used in production. +services: + api: + build: . + ports: + - "8000:8000" + read_only: true + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + tmpfs: [/tmp] diff --git a/docs/agents/domain.md b/docs/agents/domain.md new file mode 100644 index 0000000..bd5bbb6 --- /dev/null +++ b/docs/agents/domain.md @@ -0,0 +1,35 @@ +# Domain Docs + +How the engineering skills should consume this repo's domain documentation when exploring the codebase. + +This is a **single-context** repo: one `GLOSSARY.md` and one `docs/adr/` at the repo root. + +## Before exploring, read these + +- **`GLOSSARY.md`** at the repo root — the glossary / ubiquitous language. +- **`docs/adr/`** — read ADRs that touch the area you're about to work in. + +If any of these files don't exist, **proceed silently**. Don't flag their absence; don't suggest creating them upfront. The `/domain-modeling` skill (reached via `/grill-with-docs` and `/improve-codebase-architecture`) creates them lazily when terms or decisions actually get resolved. + +## File structure + +```text +/ +├── GLOSSARY.md +├── docs/adr/ +│ ├── 0001-some-decision.md +│ └── 0002-another-decision.md +└── src/mail_parser_api/ +``` + +## Use the glossary's vocabulary + +When your output names a domain concept (in an issue title, a refactor proposal, a hypothesis, a test name), use the term as defined in `GLOSSARY.md`. Don't drift to synonyms the glossary explicitly avoids. + +If the concept you need isn't in the glossary yet, that's a signal — either you're inventing language the project doesn't use (reconsider) or there's a real gap (note it for `/domain-modeling`). + +## Flag ADR conflicts + +If your output contradicts an existing ADR, surface it explicitly rather than silently overriding: + +> _Contradicts ADR-0007 (event-sourced orders) — but worth reopening because…_ diff --git a/docs/agents/issue-tracker.md b/docs/agents/issue-tracker.md new file mode 100644 index 0000000..be12adc --- /dev/null +++ b/docs/agents/issue-tracker.md @@ -0,0 +1,31 @@ +# Issue tracker: Local Markdown + +Issues and specs for this repo live as version-controlled Markdown files in +`docs/features/`. Add new files to Git as part of the implementation workflow. + +## Conventions + +- One feature per directory: `docs/features//` +- The spec is `docs/features//spec.md` +- Implementation issues are one file per ticket at `docs/features//issues/-.md`, numbered from `01` — never a single combined tickets file +- Triage state is recorded as a `Status:` line near the top of each issue file (see `triage-labels.md` for the role strings) +- Comments and conversation history append to the bottom of the file under a `## Comments` heading + +## When a skill says "publish to the issue tracker" + +Create a new file under `docs/features//` (creating the directory if needed). + +## When a skill says "fetch the relevant ticket" + +Read the file at the referenced path. The user will normally pass the path or the issue number directly. + +## Wayfinding operations + +Used by `/wayfinder`. The **map** is a file with one **child** file per ticket. + +- **Map**: `docs/features//map.md` — the Notes / Decisions-so-far / Fog body. +- **Child ticket**: `docs/features//issues/NN-.md`, numbered from `01`, with the question in the body. A `Type:` line records the ticket type (`research`/`prototype`/`grilling`/`task`); a `Status:` line records `claimed`/`resolved`. +- **Blocking**: a `Blocked by: NN, NN` line near the top. A ticket is unblocked when every file it lists is `resolved`. +- **Frontier**: scan `docs/features//issues/` for files that are open, unblocked, and unclaimed; first by number wins. +- **Claim**: set `Status: claimed` and save before any work. +- **Resolve**: append the answer under an `## Answer` heading, set `Status: resolved`, then append a context pointer (gist + link) to the map's Decisions-so-far in `map.md`. diff --git a/docs/agents/triage-labels.md b/docs/agents/triage-labels.md new file mode 100644 index 0000000..b716855 --- /dev/null +++ b/docs/agents/triage-labels.md @@ -0,0 +1,15 @@ +# Triage Labels + +The skills speak in terms of five canonical triage roles. This file maps those roles to the actual label strings used in this repo's issue tracker. + +| Label in mattpocock/skills | Label in our tracker | Meaning | +| -------------------------- | -------------------- | ---------------------------------------- | +| `needs-triage` | `needs-triage` | Maintainer needs to evaluate this issue | +| `needs-info` | `needs-info` | Waiting on reporter for more information | +| `ready-for-agent` | `ready-for-agent` | Fully specified, ready for an AFK agent | +| `ready-for-human` | `ready-for-human` | Requires human implementation | +| `wontfix` | `wontfix` | Will not be actioned | + +When a skill mentions a role (e.g. "apply the AFK-ready triage label"), use the corresponding label string from this table. + +Edit the right-hand column to match whatever vocabulary you actually use. diff --git a/docs/features/outlook-msg-support/issues/01-accept-outlook-msg.md b/docs/features/outlook-msg-support/issues/01-accept-outlook-msg.md new file mode 100644 index 0000000..e238d95 --- /dev/null +++ b/docs/features/outlook-msg-support/issues/01-accept-outlook-msg.md @@ -0,0 +1,34 @@ +# 01: Accept Outlook .msg files + +Status: needs-triage + +**What to build:** Let `POST /api/parse` accept Outlook `.msg` files sent with +`Content-Type: application/vnd.ms-outlook` and return the same response shape +as for a raw email (`mail_parser_version` and `message` without attachment +payloads). Today this content type is rejected with `415` and the detail +"Outlook .msg not supported yet". + +**Context:** + +- The image already installs `mail-parser[outlook]` (the `extract-msg` extra), + so no new dependency is needed. +- The mail-parser CLI cannot read Outlook files from stdin + ("You can't use stdin with msg Outlook"): it needs `--outlook --file `. + The body would have to be written to a temporary file under `/tmp`, the only + writable path in the container (`tmpfs`), and removed after parsing. +- The same limits apply: 5 MB body, 10-second subprocess timeout, rate limit, + no email content in logs. + +**Open questions:** + +- Is `application/vnd.ms-outlook` the only content type to accept, or should + the live parser page send another one for `.msg` uploads? +- Does `extract-msg` write anything outside the temporary file that would fail + on a read-only filesystem? + +**Acceptance:** + +- [ ] A sample `.msg` returns `200` with the parsed message and no attachment + `payload`. +- [ ] The temporary file is removed after success, failure and timeout. +- [ ] README endpoint contract updated; the `415` row for Outlook removed. diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..60fcfc9 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,107 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "mail-parser-api" +dynamic = ["version"] +description = "Stateless HTTP API that parses raw emails with mail-parser" +authors = [ + { name = "Fedele Mantuano", email = "mantuano.fedele@gmail.com" } +] +readme = "README.md" +license = "Apache-2.0" +requires-python = ">=3.13" +dependencies = [ + "fastapi>=0.115.0", + "uvicorn[standard]>=0.30.0", + "mail-parser[outlook]>=4.10.0", +] + +[project.urls] +Homepage = "https://spamscope.ai" +Repository = "https://github.com/SpamScope/mail-parser-api" + +[tool.hatch.version] +path = "src/mail_parser_api/__init__.py" + +[tool.hatch.build.targets.wheel] +packages = ["src/mail_parser_api"] + +[dependency-groups] +dev = [ + "pytest>=8.0", + "pytest-cov>=6.0", + "httpx>=0.27.0", + "pyright>=1.1", + "ruff>=0.17.0", + "pre-commit>=4.0", +] + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "-v --tb=short" + +[tool.ruff] +target-version = "py313" +line-length = 88 +src = ["src"] + +[tool.ruff.lint] +select = [ + "A", # flake8-builtins + "ANN", # flake8-annotations + "ARG", # flake8-unused-arguments + "B", # flake8-bugbear + "BLE", # flake8-blind-except + "C4", # flake8-comprehensions + "C90", # mccabe complexity + "D", # pydocstyle + "DTZ", # flake8-datetimez + "E", # pycodestyle errors + "EM", # flake8-errmsg + "ERA", # eradicate (commented-out code) + "F", # pyflakes + "FBT", # flake8-boolean-trap + "G", # flake8-logging-format + "I", # isort + "ICN", # flake8-import-conventions + "ISC", # flake8-implicit-str-concat + "LOG", # flake8-logging + "N", # pep8-naming + "PERF", # perflint + "PIE", # flake8-pie + "PT", # flake8-pytest-style + "PTH", # flake8-use-pathlib + "Q", # flake8-quotes + "RET", # flake8-return + "RSE", # flake8-raise + "RUF", # ruff-specific rules + "S", # flake8-bandit (security) + "SIM", # flake8-simplify + "SLF", # flake8-self + "SLOT", # flake8-slots + "T20", # flake8-print + "TCH", # flake8-type-checking + "TID", # flake8-tidy-imports + "TRY", # tryceratops + "UP", # pyupgrade + "W", # pycodestyle warnings + "YTT", # flake8-2020 +] +ignore = [ + "D100", # missing docstring in public module + "D104", # missing docstring in public package + "D203", # one-blank-line-before-class (conflicts with D211) + "D213", # multi-line-summary-second-line (conflicts with D212) +] + +[tool.ruff.lint.per-file-ignores] +"tests/**" = ["S101", "ANN", "D", "FBT", "ARG001"] + +[tool.ruff.lint.isort] +known-first-party = ["mail_parser_api"] + +[tool.ruff.format] +quote-style = "double" +indent-style = "space" diff --git a/src/mail_parser_api/__init__.py b/src/mail_parser_api/__init__.py new file mode 100644 index 0000000..6c8e6b9 --- /dev/null +++ b/src/mail_parser_api/__init__.py @@ -0,0 +1 @@ +__version__ = "0.0.0" diff --git a/src/mail_parser_api/app.py b/src/mail_parser_api/app.py new file mode 100644 index 0000000..f96b045 --- /dev/null +++ b/src/mail_parser_api/app.py @@ -0,0 +1,140 @@ +"""FastAPI application exposing the parse service.""" + +import asyncio +import logging +from collections.abc import Awaitable, Callable +from importlib.metadata import version + +from fastapi import FastAPI, HTTPException, Request, Response +from fastapi.responses import JSONResponse + +from mail_parser_api.parser import ParseError, ParseTimeoutError, parse_email +from mail_parser_api.rate_limit import RateLimiter, client_key + +MAX_BODY_BYTES = 5 * 1024 * 1024 +RATE_LIMIT_REQUESTS = 10 +RATE_LIMIT_WINDOW_SECONDS = 60 +RATE_LIMIT_MAX_KEYS = 10_000 +# Parses running at once. It bounds total child memory (2 x 192 MiB, see +# CHILD_ADDRESS_SPACE_BYTES in parser.py, plus the server) under the 512 MiB +# container limit; further requests wait for a free slot. +PARSE_CONCURRENCY = 2 + +RFC822_CONTENT_TYPE = "message/rfc822" +OUTLOOK_CONTENT_TYPE = "application/vnd.ms-outlook" + +# Read once at startup: the version is fixed for the lifetime of the process. +MAIL_PARSER_VERSION = version("mail-parser") + +access_logger = logging.getLogger("mail_parser_api.access") + + +def _configure_access_logger() -> None: + """Send access log records to stderr. + + uvicorn's own access log is disabled because it includes client addresses + and query strings; this log only has method, path, status and size. + """ + if access_logger.handlers: + return + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter("%(asctime)s %(message)s")) + access_logger.addHandler(handler) + access_logger.setLevel(logging.INFO) + + +def create_app() -> FastAPI: + """Build the application with a fresh rate limiter. + + Returns: + The FastAPI application. + + """ + _configure_access_logger() + app = FastAPI( + title="mail-parser-api", + docs_url=None, + redoc_url=None, + openapi_url=None, + ) + rate_limiter = RateLimiter( + limit=RATE_LIMIT_REQUESTS, + window=RATE_LIMIT_WINDOW_SECONDS, + max_keys=RATE_LIMIT_MAX_KEYS, + ) + parse_slots = asyncio.Semaphore(PARSE_CONCURRENCY) + + @app.middleware("http") + async def log_access( + request: Request, + call_next: Callable[[Request], Awaitable[Response]], + ) -> Response: + response = await call_next(request) + access_logger.info( + "%s %s %d %s", + request.method, + request.url.path, + response.status_code, + response.headers.get("content-length", "-"), + ) + return response + + @app.get("/healthz") + async def healthz() -> dict[str, str]: + return {"status": "ok"} + + @app.post("/api/parse") + async def parse(request: Request) -> JSONResponse: + peer = request.client.host if request.client else None + key = client_key(request.headers.get("x-forwarded-for"), peer) + if not rate_limiter.allow(key): + raise HTTPException(status_code=429, detail="Too many requests") + + _check_content_type(request.headers.get("content-type", "")) + raw_email = await _read_body(request) + + try: + async with parse_slots: + message = await asyncio.to_thread(parse_email, raw_email) + except ParseTimeoutError as error: + raise HTTPException(status_code=504, detail="Parsing timed out") from error + except ParseError as error: + raise HTTPException(status_code=422, detail=str(error)) from error + + return JSONResponse( + {"mail_parser_version": MAIL_PARSER_VERSION, "message": message} + ) + + return app + + +def _check_content_type(content_type: str) -> None: + """Reject any media type other than ``message/rfc822`` with 415.""" + media_type = content_type.split(";")[0].strip().lower() + if media_type == RFC822_CONTENT_TYPE: + return + if media_type == OUTLOOK_CONTENT_TYPE: + raise HTTPException(status_code=415, detail="Outlook .msg not supported yet") + raise HTTPException( + status_code=415, detail=f"Content-Type must be {RFC822_CONTENT_TYPE}" + ) + + +async def _read_body(request: Request) -> bytes: + """Read the request body, rejecting more than ``MAX_BODY_BYTES`` with 413. + + The declared Content-Length is checked first so that an oversized upload is + refused before it is read; the streamed size is checked as well because the + header can be absent or wrong. + """ + too_large = HTTPException(status_code=413, detail="Body exceeds 5 MB") + declared_length = request.headers.get("content-length", "") + if declared_length.isdigit() and int(declared_length) > MAX_BODY_BYTES: + raise too_large + + body = bytearray() + async for chunk in request.stream(): + body.extend(chunk) + if len(body) > MAX_BODY_BYTES: + raise too_large + return bytes(body) diff --git a/src/mail_parser_api/parser.py b/src/mail_parser_api/parser.py new file mode 100644 index 0000000..164bdfc --- /dev/null +++ b/src/mail_parser_api/parser.py @@ -0,0 +1,129 @@ +"""Run the mail-parser CLI in a subprocess and shape its JSON output.""" + +import json +import signal +import subprocess +import sys +from typing import Any + +PARSE_TIMEOUT_SECONDS = 10 + +# Address-space cap of one parse. Real emails up to 5 MB stay well below it; +# header-heavy ones that would grow past it fail with MemoryError instead. +CHILD_ADDRESS_SPACE_BYTES = 192 * 1024 * 1024 + +# The installed mail-parser CLI, run with the same interpreter as the service. +# ``-l ERROR`` keeps warnings off stdout; error lines may still precede the JSON. +MAIL_PARSER_COMMAND = ( + sys.executable, + "-m", + "mailparser", + "--stdin", + "--json", + "--log-level", + "ERROR", +) + +# On Linux (the container) util-linux tools set the child limits before exec: +# ``choom`` makes the kernel kill the child, never uvicorn (PID 1), when memory +# runs out, and ``prlimit`` caps the memory of one parse. ``preexec_fn`` is +# avoided because the parse runs in a worker thread. macOS has neither tool. +LINUX_CHILD_LIMITS = ( + "choom", + "-n", + "1000", + "--", + "prlimit", + f"--as={CHILD_ADDRESS_SPACE_BYTES}", + "--", +) + +# Prefix of the line the CLI logs on stdout when parsing fails. +ERROR_MARKER = "An error occurred: " +GENERIC_ERROR = "mail-parser could not parse the email" +# The child was killed by the kernel or logged a MemoryError, which has no text. +TOO_COMPLEX_ERROR = "email too complex to parse within the service limits" + + +class ParseError(Exception): + """mail-parser failed to parse the email.""" + + +class ParseTimeoutError(Exception): + """mail-parser did not finish within the timeout.""" + + +def parse_email(raw_email: bytes) -> dict[str, Any]: + """Parse a raw email with the mail-parser CLI. + + The email is passed on stdin, never through a shell. Attachment payloads are + removed from the result; their metadata is kept. + + Args: + raw_email: The raw email bytes. + + Returns: + The mail-parser JSON of the email without attachment payloads. + + Raises: + ParseError: mail-parser exited with an error or printed no JSON. + ParseTimeoutError: mail-parser ran longer than the timeout and was killed. + + """ + try: + completed = subprocess.run( # noqa: S603 - fixed argv, email on stdin + _command(), + input=raw_email, + capture_output=True, + timeout=PARSE_TIMEOUT_SECONDS, + check=False, + ) + except subprocess.TimeoutExpired as error: + raise ParseTimeoutError from error + + if completed.returncode == -signal.SIGKILL: + raise ParseError(TOO_COMPLEX_ERROR) + stdout = completed.stdout.decode("utf-8", errors="replace") + if completed.returncode != 0: + raise ParseError(_error_message(stdout)) + + message = _extract_json(stdout) + for attachment in message.get("attachments", []): + attachment.pop("payload", None) + return message + + +def _command() -> tuple[str, ...]: + """Return the CLI command, wrapped in the child limits on Linux.""" + if sys.platform == "linux": + return (*LINUX_CHILD_LIMITS, *MAIL_PARSER_COMMAND) + return MAIL_PARSER_COMMAND + + +def _extract_json(stdout: str) -> dict[str, Any]: + """Return the JSON object printed by the CLI. + + Log lines start with a timestamp; the JSON object is printed with indent=2, + so it is the first line made of a lone ``{``. It is decoded in place, without + copying the output, to keep the memory of large results low. + """ + if stdout.startswith("{\n"): + start = 0 + else: + start = stdout.find("\n{\n") + 1 + if start == 0: + raise ParseError(GENERIC_ERROR) + try: + message, _ = json.JSONDecoder().raw_decode(stdout, start) + except ValueError as error: + raise ParseError(GENERIC_ERROR) from error + return message + + +def _error_message(stdout: str) -> str: + """Return the error message logged by the CLI, or a generic one.""" + for line in stdout.splitlines(): + _, marker, message = line.partition(ERROR_MARKER) + if marker: + return message.strip() or TOO_COMPLEX_ERROR + return GENERIC_ERROR diff --git a/src/mail_parser_api/rate_limit.py b/src/mail_parser_api/rate_limit.py new file mode 100644 index 0000000..1b2e8db --- /dev/null +++ b/src/mail_parser_api/rate_limit.py @@ -0,0 +1,101 @@ +"""In-memory sliding-window rate limiter keyed by client address.""" + +import ipaddress +import time +from collections import OrderedDict, deque +from collections.abc import Callable + +IPV6_PREFIX_LENGTH = 64 + + +def client_key(forwarded_for: str | None, peer: str | None) -> str: + """Return the rate limit key of a client. + + The first ``X-Forwarded-For`` value wins over the peer address because the + service runs behind a reverse proxy that sets it. An IPv4 address is used + whole; an IPv6 address is collapsed to its /64 network, since one host + usually controls a whole /64. + + Args: + forwarded_for: Value of the ``X-Forwarded-For`` header, if any. + peer: Address of the TCP peer, if known. + + Returns: + The client key. A value that is not an IP address is returned unchanged. + + """ + raw = forwarded_for.split(",")[0].strip() if forwarded_for else peer or "" + try: + address = ipaddress.ip_address(raw) + except ValueError: + return raw + if address.version == 6: + network = ipaddress.ip_network(f"{address}/{IPV6_PREFIX_LENGTH}", strict=False) + return str(network) + return str(address) + + +class RateLimiter: + """Allow at most ``limit`` requests per ``window`` seconds for each key. + + Keys are kept in least-recently-used order. Expired keys are purged on each + call and, above ``max_keys``, the least recently used key is evicted, so + memory stays bounded whatever the number of clients. + """ + + def __init__( + self, + limit: int, + window: float, + max_keys: int, + clock: Callable[[], float] = time.monotonic, + ) -> None: + """Create an empty rate limiter. + + Args: + limit: Requests allowed per key within the window. + window: Length of the sliding window in seconds. + max_keys: Maximum number of keys kept in memory. + clock: Monotonic time source, replaceable in tests. + + """ + self._limit = limit + self._window = window + self._max_keys = max_keys + self._clock = clock + self._hits: OrderedDict[str, deque[float]] = OrderedDict() + + def __len__(self) -> int: + """Return the number of keys currently tracked.""" + return len(self._hits) + + def allow(self, key: str) -> bool: + """Record a request for ``key`` and tell whether it is within the limit. + + Args: + key: Client key, see :func:`client_key`. + + Returns: + True if the request is allowed, False if the limit is exceeded. + + """ + now = self._clock() + expiry = now - self._window + hits = self._hits.pop(key, deque()) + while hits and hits[0] <= expiry: + hits.popleft() + allowed = len(hits) < self._limit + if allowed: + hits.append(now) + if hits: + self._hits[key] = hits + self._purge(expiry) + return allowed + + def _purge(self, expiry: float) -> None: + """Drop expired keys from the oldest end and evict above the key cap.""" + while self._hits: + oldest_hits = next(iter(self._hits.values())) + if oldest_hits[-1] > expiry and len(self._hits) <= self._max_keys: + break + self._hits.popitem(last=False) diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unittests/__init__.py b/tests/unittests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unittests/conftest.py b/tests/unittests/conftest.py new file mode 100644 index 0000000..09a6ad1 --- /dev/null +++ b/tests/unittests/conftest.py @@ -0,0 +1,21 @@ +from pathlib import Path + +import pytest +from fastapi.testclient import TestClient + +from mail_parser_api.app import create_app + +FILES = Path(__file__).parent / "files" + + +@pytest.fixture +def client() -> TestClient: + return TestClient(create_app()) + + +@pytest.fixture +def read_sample(): + def read(name: str) -> bytes: + return (FILES / name).read_bytes() + + return read diff --git a/tests/unittests/files/mail_malformed_2 b/tests/unittests/files/mail_malformed_2 new file mode 100644 index 0000000..7c8b6b2 --- /dev/null +++ b/tests/unittests/files/mail_malformed_2 @@ -0,0 +1,60 @@ +Return-Path: <> +Delivered-To: tanya@infospacemail.com +Received: (qmail 32129 invoked from network); 22 Aug 2016 09:22:13 -0000 +Received: from c.netpar.com.br (HELO apus.netpar.com.br) (189.125.104.100) + by smtp.customers.net with SMTP; 22 Aug 2016 09:22:13 -0000 +To: tanya@infospacemail.com +Subject: Delivery failure (abh@netpar.com.br) +From: postmaster@netpar.com.br +Message-Id: +Date: Mon, 22 Aug 2016 06:23:36 -0300 +MIME-Version: 1.0 +Content-Type: multipart/report; report-type=delivery-status; boundary="48461/50/1471857816/MailSite/apus.netpar.com.br" + +--48461/50/1471857816/MailSite/apus.netpar.com.br +Content-Type: text/plain + +Your message has encountered delivery problems +to the following recipient(s): + +abh +(Was addressed to abh@netpar.com.br) +Delivery failed +User's mailbox quota exceeded + + + + +--48461/50/1471857816/MailSite/apus.netpar.com.br +Content-Type: message/delivery-status +Content-Disposition: attachment; filename="DSN57BAC498.txt" + +Reporting-MTA: dns; apus.netpar.com.br +Arrival-Date: Mon, 22 Aug 2016 06:23:36 -0300 + +Final-Recipient: rfc822; abh@netpar.com.br +Action: failed +Status: 4.2.2 (Persistent transient failure - mailbox: mailbox full) + +--48461/50/1471857816/MailSite/apus.netpar.com.br +Content-Type: message/rfc822-headers + +Received: from cygnus.netpar.com.br (unverified [189.125.104.24]) by apus.netpar.com.br + (Rockliffe SMTPRA 4.5.6) with ESMTP id for ; + Mon, 22 Aug 2016 06:23:36 -0300 +Received: from [117.201.229.175] (unknown [117.201.229.175]) + by cygnus.netpar.com.br (Postfix) with ESMTP id 9B8AE886048E + for ; Mon, 22 Aug 2016 09:22:04 +0000 (UTC) +From: "Reynaldo Stevens" +To: +Subject: Trabajo perfecto a distancia +Date: 22 Aug 2016 18:37:49 +0400 +Message-ID: <004801d1fc84$01c934ac$b247f0b7$@infospacemail.com> +MIME-Version: 1.0 +Content-Type: multipart/alternative; + boundary="----=_NextPart_000_0045_01D1FC84.01C36A99" +X-Mailer: Microsoft Outlook 14.0 +Thread-Index: Ac1doyjrxh5tdsxl1doyjrxh5tdsxl== +Content-Language: en + +--48461/50/1471857816/MailSite/apus.netpar.com.br-- diff --git a/tests/unittests/files/mail_test_10 b/tests/unittests/files/mail_test_10 new file mode 100644 index 0000000..824fdd1 --- /dev/null +++ b/tests/unittests/files/mail_test_10 @@ -0,0 +1,4186 @@ +Return-Path: +Delivered-To: lina.vailati@dududu.it +Received: (qmail 20959 invoked from network); 8 Mar 2017 16:46:30 -0000 +Received: from mx0b-001b2d01.pphosted.com (HELO mx0a-001b2d01.pphosted.com) (148.163.158.5) + by smtp.didi.net with SMTP; 8 Mar 2017 16:46:30 -0000 +Received: from pps.filterd (m0098419.ppops.net [127.0.0.1]) + by mx0b-001b2d01.pphosted.com (8.16.0.20/8.16.0.20) with SMTP id v28GdUiK046963 + for ; Wed, 8 Mar 2017 11:46:30 -0500 +Received: from e06smtp10.uk.ibm.com (e06smtp10.uk.ibm.com [195.75.94.106]) + by mx0b-001b2d01.pphosted.com with ESMTP id 292hw54kbu-1 + (version=TLSv1.2 cipher=AES256-SHA bits=256 verify=NOT) + for ; Wed, 08 Mar 2017 11:46:27 -0500 +Received: from localhost + by e06smtp10.uk.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted + for from ; + Wed, 8 Mar 2017 16:46:25 -0000 +Received: from b06cxnps4076.portsmouth.uk.ibm.com (9.149.109.198) + by e06smtp10.uk.ibm.com (192.168.101.140) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; + Wed, 8 Mar 2017 16:46:21 -0000 +Received: from d06av25.portsmouth.uk.ibm.com (d06av25.portsmouth.uk.ibm.com [9.149.105.61]) + by b06cxnps4076.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id v28GkLOt35979332 + for ; Wed, 8 Mar 2017 16:46:21 GMT +Received: from d06av25.portsmouth.uk.ibm.com (unknown [127.0.0.1]) + by IMSVA (Postfix) with ESMTP id 21D6911C05C + for ; Wed, 8 Mar 2017 16:46:12 +0000 (GMT) +Received: from d06av25.portsmouth.uk.ibm.com (unknown [127.0.0.1]) + by IMSVA (Postfix) with ESMTP id 2C31711C04A + for ; Wed, 8 Mar 2017 16:46:11 +0000 (GMT) +Received: from d50lp03.ny.us.ibm.com (unknown [146.89.104.211]) + by d06av25.portsmouth.uk.ibm.com (Postfix) with ESMTPS + for ; Wed, 8 Mar 2017 16:46:11 +0000 (GMT) +Received: from localhost + by d50lp03.ny.us.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted + for from ; + Wed, 8 Mar 2017 11:46:19 -0500 +Received: from smtp.notes.na.collabserv.com (192.155.248.67) + by d50lp03.ny.us.ibm.com (158.87.18.22) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; + (version=TLSv1/SSLv3 cipher=AES128-GCM-SHA256 bits=128/128) + Wed, 8 Mar 2017 11:46:17 -0500 +Received: from localhost + by smtp.notes.na.collabserv.com with smtp.notes.na.collabserv.com ESMTP + for from ; + Wed, 8 Mar 2017 16:46:15 -0000 +Received: from us1a3-smtp02.a3.dal06.isc4sb.com (10.106.154.159) + by smtp.notes.na.collabserv.com (10.106.227.16) with smtp.notes.na.collabserv.com ESMTP; + Wed, 8 Mar 2017 16:45:51 -0000 +Received: from us1a3-mail113.a3.dal06.isc4sb.com ([10.146.45.236]) + by us1a3-smtp02.a3.dal06.isc4sb.com + with ESMTP id 2017030816455096-411668 ; + Wed, 8 Mar 2017 16:45:50 +0000 +X-Disclaimed: 23094 +MIME-Version: 1.0 +Subject: *** ATTENZIONE *** - Modelli POWER7+ inclusi nella campagna Move To Eight +X-KeepSent: 0C5D2406:A7134351-C12580DD:00582F46; + type=4; name=$KeepSent +X-Mailer: IBM Notes Release 9.0.1FP2 SHF37 August 25, 2014 +From: Nicoletta Bernasconi +Date: Wed, 8 Mar 2017 16:45:48 +0000 +X-LLNOutbound: False +X-TNEFEvaluated: 1 +Content-Type: multipart/mixed; boundary="=_mixed 005C1243C12580DD_=" +x-cbid: 17030816-0040-0000-0000-0000033C4B1B +X-IBM-SpamModules-Scores: BY=0.042297; FL=0; FP=0; FZ=0; HX=0; KW=0; PH=0; + SC=0.377267; ST=0; TS=0; UL=0; ISC=; MB=0.000914 +X-IBM-SpamModules-Versions: BY=3.00006745; HX=3.00000240; KW=3.00000007; + PH=3.00000004; SC=3.00000206; SDB=6.00831769; UDB=6.00408122; IPR=6.00609362; + BA=6.00005201; NDR=6.00000001; ZLA=6.00000005; ZF=6.00000009; ZB=6.00000000; + ZP=6.00000000; ZH=6.00000000; ZU=6.00000002; MB=3.00014562; XFM=3.00000013; + UTC=2017-03-08 16:46:13 +X-IBM-AV-DETECTION: SAVI=unsuspicious REMOTE=unsuspicious XFE=unused +X-IBM-AV-VERSION: SAVI=2017-03-08 13:34:59 - 6.00006406 +x-cbparentid: 17030816-0328-0000-0000-0000030B1E03 +X-IBM-AV-DETECTION: SAVI=unused REMOTE=unused XFE=unused +To: undisclosed-recipients:; +X-TM-AS-GCONF: 00 +X-IBM-AV-DETECTION: SAVI=unused REMOTE=unused XFE=unused +Message-Id: +X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10432:,, definitions=2017-03-08_12:,, + signatures=0 +X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 suspectscore=0 + malwarescore=0 phishscore=0 adultscore=0 bulkscore=0 classifier=spam + adjust=0 reason=mlx scancount=1 engine=8.0.1-1702020001 + definitions=main-1703080133 + +--=_mixed 005C1243C12580DD_= +Content-Type: multipart/related; boundary="=_related 005C1243C12580DD_=" + + +--=_related 005C1243C12580DD_= +Content-Type: multipart/alternative; boundary="=_alternative 005C1243C12580DD_=" + + +--=_alternative 005C1243C12580DD_= +Content-Transfer-Encoding: quoted-printable +Content-Type: text/plain; charset="ISO-8859-1" + +Gentili Business Partner, vi segnalo che oggi =E8 stato annunciato un=20 +aggiornamento della campagna Move To Eight - plet ZWEP6227F. Lo sconto=20 +addizionale del 5% verr=E0 riconosciuto in caso di sostituzione di un=20 +sistema POWER5, POWER5+, POWER6, POWER7 o POWER7+ con uno dei modelli=20 +POWER8 previsti. Anche i modelli POWER7+ sono quindi diventati eleggibili=20 +alla sostituzione. Rimane invece invariata la lista dei modelli POWER8 che = + +beneficiano della campagna; il nuovo sistema S812 annunciato a febbraio=20 +NON =E8 eleggibile.=20 + + + +Ricordo che l'offerta =E8 valida per ordini RICEVUTI e CARICATI da IBM tra = + +il 20/01/2017 e il 31/03/2017. + + +In allegato la nuova lettera di annuncio in cui, nell'Appendix B,=20 +troverete la nuova lista dei modelli eleggibili alla sostituzione: + + + + + +=20 + +Cordiali saluti=20 + Nicoletta Bernasconi + +Power Systems - IBM i Product Manager +IBM Italy +Segrate (MI) Italy +Mobile: +39 335 7368459=20 +Email: nicoletta=5Fbernasconi@it.ibm.com +IBM Italia S.p.A. +Sede Legale: Circonvallazione Idroscalo - 20090 Segrate (MI)=20 +Cap. Soc. euro 347.256.998,80 +C. F. e Reg. Imprese MI 01442240030 - Partita IVA 10914660153 +Societ=E0 con unico azionista +Societ=E0 soggetta all?attivit=E0 di direzione e coordinamento di=20 +International Business Machines Corporation + +(Salvo che sia diversamente indicato sopra / Unless stated otherwise=20 +above) +--=_alternative 005C1243C12580DD_= +Content-Transfer-Encoding: quoted-printable +Content-Type: text/html; charset="ISO-8859-1" + +Gentili Business Partner, vi segnalo che +oggi =E8 stato annunciato un aggiornamento della campagna Move To Eight - +plet ZWEP6227F. Lo sconto addizionale del 5% verr=E0 riconosciuto in caso +di sostituzione di un sistema POWER5, POWER5+, POWER6, POWER7 o POWER7+ +con uno dei modelli POWER8 previsti. Anche i modelli POWER7+ +sono quindi diventati eleggibili alla sostituzione. Rimane invece invariata +la lista dei modelli POWER8 che beneficiano della campagna; il nuovo sistema +S812 annunciato a febbraio NON =E8 eleggibile. +
+
+
+
Ricordo che l'offerta =E8 valida per= + ordini +RICEVUTI e CARICATI +da IBM tra il 20/01/2017 e il 31/03/2017. +
+
+
In allegato la nuova lettera di annu= +ncio +in cui, nell'Appendix B, troverete la nuova lista dei modelli eleggibili +alla sostituzione: +
+
+
+
+
+
  +
+
Cordiali saluti
+                     +                      +                      +  Nicoletta Bernasconi
+
+Power Systems - IBM i Product Manager
+IBM Italy
+Segrate (MI) Italy
+Mobile: +39 335 7368459
+Email: nicoletta=5Fbernasconi@it.ibm.com
+IBM Italia S.p.A.
+Sede Legale: Circonvallazione Idroscalo - 20090 Segrate (MI)
+Cap. Soc. euro 347.256.998,80
+C. F. e Reg. Imprese MI 01442240030 - Partita IVA 10914660153
+Societ=E0 con unico azionista
+Societ=E0 soggetta all’attivit=E0 di direzione e coordinamento di Int= +ernational +Business Machines Corporation
+
+(Salvo che sia diversamente indicato sopra / Unless stated otherwise above)= +
+--=_alternative 005C1243C12580DD_=-- +--=_related 005C1243C12580DD_= +Content-Transfer-Encoding: base64 +Content-Type: image/gif +Content-ID: <_1_0B4E24640B4E1564005C1243C12580DD> + +R0lGODlhDARgAecAAAAAAP////j48Pj44PjgqOCoYPD4+Mj4+OD4+AAgiCAAAKhYIAAAQFgAACCI +yIjI8PjIiKjg+ABYqPj4yPj46IggAAAAIAAAYOj4+Fio4MiIQODg4KioqAAAGNj4+AAAMPj42AAA +CPj40AAAKJDQ8AAASAgAAOjw+Pjw6IiIiHjA6FhYWAAAOAAYeLhwMND4+BhwuODo8ODg6MjIyHAY +APjouAAAUJjY8HC46DAIAEAIALjw+Ljo+ABAmECY0Oi4cPjosPjwuEAgCPjw0AAgSPC4ePjYmPjY +oPjwwAAISLDo+MDw+NiYUOjg4Giw4Pjw2EAAAOiwaNjw+GgQAPDIiAgACJhAGMCAQNCQSDCQ0MDo ++OCoaMjAsPjwyPDAgNDw+AAgQKDY+DgAABgAAEgAAGhAGHAoCPDo6PjgsGi46JA4EPDo4AAIMPjQ +kKiooMjIwAAAEBgAIAAIOAAIYGCo2AAQaAAwkEggCLhoKMiISNigWPDQmAA4kIDA6MDIyPjw4ABI +YBBQeBhYWCAgGCAwYCBYkDAAODBAODBIaDBooDgAYDh4eEAogEA4IEB4sEgIKEgYaEhoiFAgOFBA +cFBQOFBYoFgAQFg4kFiAoFiQwGh4gGigqHBYQHBgaHh4WHigyIBIKIggOIhIcIh4sIiQYIjAqJBg +MJCwwJhISJhwkJjQyKBgWKCAaKC42KiYeLDQ4LiIiLiQYLjguMCwgNiwmAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAADARgAUAI/wADCBxI +sKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bN +mzhz6tzJs6fPn0CDCh1KtKjRo0iTKl3KtKlTlRAUAADA4MHCqFMvRBAoQMNUABIQDByQZ8zXs1Or +DsQKQOtAAg2ypoh7dg6JgV2/hiVIoAzatHQMMJxQ4asDgkFofE1wQCDcrKX8Tj0s8AeUvwBG+BBM +cIgLzIsbC2TLeCDhtFbxbrn810KGAQtAuxZYQ/JftU9z697Nu7fv38BnssWdkK3bAHmn7qXweSoM +zgFOU00dwPhWx3SPB2CuV2xysGK5A//o4KOidACUFz5ue31s7Kk9PAwUDyB+gMRTP+AgSFp0dakA +2HCDaYVNJxB+45WXkHTEGfQEB26AcpZ9wVVo4YUYZqjhhhwSVABoU9XRXocklmjiiSimqOKKLLbo +4oswxijjjDTWaOONOOao44489lghYaV5OMIKcmDiBidwOICBQAXgxlwSm/gxywrUCTQALJ7kQEQK +KXwi2A8jRMIBF6zo0AIP2AFyRyEclGnDXQHAlV4XVhAR5SxlJFGlkEQaaYoJPXwhEJ12SplnanIO +RGeYEHJSRSHyFRGHggEcQQZxXkx60A9xJOIHF6QoCBsRlACyiSt3MKCColYweuSjkWr/KpClmGr6 +5J1UFnRlllt2KRhcahbihicK2KGFQBTkEeanppAHHV8NUAZbabdKSeWuWnLppUHJVhEIhKTkIGIA +Q6SAJCIpjCJoQYTeeSh26TWZGhpmAHIKF6soAEgKaMpr5QKkmupKGRZsFsC0oiW7LBfNGmwQkKJB +zBUTHzjBlQZatSGGA9CBsAAfBxQw20FRpRdAEWNQ1u23boQ7LnMCDqQHAEFScEXM7Rqq50AFlMCJ +HIt4smpBPyhAxJ4CMDGCxQNJmkEANdR7yhuuXHJADebCgW4K11GhQyBTu6JDD6L13ImdA3+wiSmA +tGnmddVOuWdlnX4a6kBeg0312GX7/wy00EZAAcOSB9IggXx5h833v4CUsaUmPERtL9VWGyQppbRS +l6mCBQxZ5JFJEp4znjszWUInnyOp5EGwAcKJwAQbLLFAs/f8c9Cr1lZkm3cMHkDnfYK+OgV42Dmm +KVX4HgCnnoKqoMKRMOuslS50wCYrdxxigskD1TDFt1y4UQYL+23nApTWzr08o2SaiaZBrTueAuQB +jP7uwQu4DnvBgiFcGftlOpOVrmA9DgysDmiyX+l+dzq0lUFtbHNbC+CmrOgxbHpxasAiyiAsYhkL +alnb2ohkMjueNchfv8MNBAjxCWZV7CAeY4GRTmEAAWChA80zRRzi8LQMHiIOjnDbuP8ymB4CmIEB +mfDDDIaVCMIVpHONMB7yIOWYIyZxiZ5oIhHfckRM+OFIHXCEEyeghgANKIMAaMEOEDKBUHhxbzAQ +i//+FSQjMsCLYBSjacoYMzSqcS0sdCHTChLDGf4qWtCijMdwqEQyMUIJB0kU/kqzwhYy7IUBKKQb +aGiQRSbiXqzIQQ+OxaSRRdKKSmTikiSZwtR47SwWSMT7UAgbMAiBZQ+kAx1F48lGsuKRB5kdYZKg +CS6loBFh9A7G2gOXEHCMZ6YsSMkS4klQipKUAtFYfeQTgC2YAADP4SISU5lFwqHwIEBoABEwASFT +KGCUeGECAJLEma4U4hQzwNMEZ9X/gDpAaCsC2IK+8PkGN1CCaeec4xarE8hLDtI0bvQDHL0jUHvN +oKAHZVKDBuIFqSRgCaoZ6EUNyjSF2hOf+hzhHs2InTSu0YRVQqEdr6hKjcZ0o/+SQyNw+QFdVkYB +/oxQ44J0zmzqwHgDk8CSiuovEVgBSvkswyDc0sY3ii2OmVwAI2fgSEjWr1WO4AKqVrCxgxhhbKrY +mxD2UklBGsSGjGTYDnuoqwUESZw0LSf+dMpTn/oPrjmc66BaJaYjzQGSMyWnFlvpnrtKspdc/aVX +WbnQSvXznz7KrGY3y9nOevazoA2taEdL2tKa9rQUERldu6CGOpwxAPQa4oeS0IeE/1BgBk4MXDgN +8iEiwOmsISiEoASgB/JwJQ895cwAXDCCHlJBDFgNwB7MgB6BPHd1B3PBHK5T1MY2Zo4/YMHQCAIb +7QTguoRb7naRg1yfJk0BOK1sb+GEhNa+DyI2Wy/M4IS/4K4rtl6dL/WWZt2NpVe7W4GNfwvsOwG0 +d2LwRRQit3OFF3KKrgUhDBE4wOFVAFEsP1VehitQxwYkl8IjSENlxHsQ1RLktrkVXP/sWjbcoJd6 +6z0vdEE83erCbwELhq0Z6uDVGUhhIE79I/FaANKC3Di7OR5xkKLyLQiBggi1vZhWknzfwJXHxSRT +QHpiOLTnFuLIP93LD4yLPwCUAP9OZLQPaz9Itx7ChTxONMgPdBCCQHwCxBnci/nW673dQkvQ9VMD +nZfHQ+yc2KkA8C0/7VPoZ6H20jAC00MFgKepdAARMX2zQgJ6BwD0WRULQLSHRL3LgaTTZGjgxDcj +/Yk81+BPkaYDEKaQhYE8IRZCmEoICJEJEPeMv+RdgB1egL9lC2QPkulze4aAaz40+dfBNjWxAU0F +v/S5FT9gdUHg0mvTIfvYEOncQ/eIwGnJAtdECIwJ+xCLHGTGEesSCLaFve1mM/tfzrautwMBblaT +OwBIMAPZBtIGHRzOIJD+Chgi0QonFk3EBCFMwA/+lgaUG9rCDkR7AmpvBtSW1Kb/DgSq9wKbgKNb +38Dmd7G7B29d85p1qb71N+MNnb5MxU5bcAsFUDWVEeDb1zHX9swfVoGAn/Urw8bEK/CyzLG4oARV +igKBw1xuhAwhlFNhgyOwSTs1OLPjLCaIAGhhGzCMHTtdP0gNSJFt640QLuKuHyoAFG8ngrwDz1x7 +29+ewbgnFA+l6cLef06HPCPk4o7HtOQnT/nKW/7ymM+8hUDE+c57/vOgD73oR0/60pv+9KhPvepX +z/rWu/71sI+97GdP+9rb/va4N73md48Q0B+GLV95jvcSZIAnuCEFrTAAnQBQMBCO4hVUkAr//sAF +DhxrZmFpAgaGMIM9kCEsWHEN/wU2IIA3WB9qZpjDKV5hgD/MIJ9i0Ip0nEWB6rdCLEVjzxO+QP2K +23DWuReAAjiAoMcYBGAJfWBDZzE4VKAIEQAbCRIATeAGbpB8ETd91Xd97EEBMdB/GPB/4BF+GTB+ +5XcKgrIHOjAVO4M1o3Asr0SArHcYBfBRZPQVS+NgYbEeC1cDHBYDQjYVczAgXcABfvCB/wEAK5gu +LpiCrvEdMAiDjHEe8XEaWvEEUuB+G2AF9dEYPMgBPkgvQHgXQ9gKUgACWpiELXheKRiEa5cCHCAD +XsGGtOCGcKiCVvEgHMB+y6UcCKB93Od9ssd7gkgQvhcAT/B+M+CD0kVdU8ECFv9jfFxyCjHwIYzB +BVySfAQwBVRRW3jIfh8CfgDChyKIHPV3fmCYRjwgANU3C1AgfwXiiAFAfSlwCgiQNN/kil+Bi0+4 +i7yYewZIFwSmgFnxgLHBYmjAJbOUFpzIYZ7IHueBi6DIfBnwHU3oFWm0FVhziU/wHr1oejL4FUQW +ABEHHo8RAnGkil1yLHtAF9YGNZuEAWdgAFixT9mIfNsojU7YjbgXhQXyF7oobOdoiZ+gjuwIUl0Y +Ax5zjSCkjbHhALLILwJQANvzkKkokQrZBa6QAuw3BO8RjbU3iCCpjyI5kiRZkiZ5kiiZkiq5kiyp +kiA5iC0ZkzI5kzRZkzZ5kzj/mZMr+ZKCqJM++ZNACRq/F4oEFgWzFh+7Bh7Lk4I9hUYgMwRaCABN +aZRBWZVWuXqMIQKrsAJcuQLBRk8oGCIPiAfMt0GLsQQRpxUQiBrfURXJsRdUUGpT8ZRROZUmcAFh +IAJlNE+DAIM8yXtXGZiC2ZJD+RcElnBnAX5LNwRXAIAMsAmAVn7cOJiUWZlowY+gAQjJNxB/MAul +hkPrQgGzQAdrWR/vs3xhhGZfRwcCcAV82FFo8ZiR+QaxMQd94ERoICEE+Je7Z5m++ZvAGZzCOZzE +OXq8qXnFmZzKuZzM2ZzOSZLHmXnPOZ3UWZ3WeZ3YeRbRiXnZ2Z3e+Z3gGZ42/7mdlyee5nme6Jme +6hmI5Fl5X9GeN/Ke7imf8xla9AmfmHafYVZEZoB1OKExglZ+9zURcKFqImFDI+BTsfgG8mEzJvcW +U8AH/1YDV7YJC2Be83EFLUAK0dQb+mkQHfVMWcVqR5AJaPYELuBMgpFw7YgcBVAFXbdcSTBeGaKd +DeEFhjAXiEahdnKhKoUcTGADntBcKzIVFjFHlEUiH4qfprWk/CFmCKGXf4QXV0CiZAADZvgcmZIG +u/ZMHjOlLRZf1GQFrLY5A4AHYCoQQyA2Q1SggFYA+pEQlJVQNNYQliKhuuVEcEUp/6Id6QQaW+eh +RpoQXEYQgUMh5LIAM6p2FP9TPgLhVHgpjmpwV//BPb5ho6xDlqChVMmGoVT5F2lnIoOaEEfQAD3Q +CicQHRXAcnVaWSXipEw6WrCaGx4TZbEaEbNaWphKeaPqWbl6q77aq8DaIr8qq8VqrPYprMMqWse6 +rBvSrKC1q5OnrJsFrc66I9Z6rZtHraglrZLHrZmVrdoan+A6GlAqEGRWYGc2EEWjZmwGgawWZ4hj +YDjGXUiYZY/HZ34GaLXaHk6zPKF6aIA2Z9h0YY4mb5AmaZaFqOTVmGGymQTxA3dQJGVQB/hqEJn4 +UQcRkVUgopdarrQBCp/mCXKwdJ20AA86QPqSAmtCdswhQG56Id6qEBnbZBj/OwUaOxAJtxeJ0QP/ +diIgC2MDoVszVmKWyiHiOq41kqtREXcG8XX2BgBiR3bRYXZF1AABa4hJN2xL93IIMXd1Vwgj5DFw +EHcgl3Ij8neBx3YSR3gcZ1NjgXj+QRC0wAkAUiT59mtyCQBggAloNo51EQYB8HR/8XAfCwALIXhf +EUvXYYut0UO3BiDDti3o1ACcuq3lCrhfMQeCq7lAGAYeE44GoTEYh7SIO2pbUGqnlmpypGz/9rav +CrJKyyNJO7u8UbuaNbOXJrvYyru2iyPrGbzCO7zEG7y/G6yne7xK6rvJyrzJ2rzKy1lMe65MAqMG +gQIyYGkVcQaKiBAokKq8/9WhEIG9zxKz15u9CnEG4MsV6IsQ5fWj7+seTHYQNsNmA7EHj0AHYPYb +ubq/v5O1TTMG9mG+GbRbz+UwGqK7BQGVEkDABVG/fCqOViABu2agsesQAtAE3dtqrrq8yRu9PjK9 +R7sdePAmBJFkL+VUCcAFj6BiiQEDP5CyMPNavCWmCOExkZpofCALU+CxEdtogQZolyOnEwa3HKwe +puoB00QQHdV109UDA3owsGBMXHIuXMO/5VpCqhpw1LaoaqcBDdKaokY8OSwQWyC+ggqubUjFvOIr +z6ZwUXwweGAXG1DHdXxx2vusH3wQehCqhMGqRosiuAvCKjLIQ7EGG0zIhv/cIwp8Ws5LrntMyDqy +yJJsFJTcu4/8WZm8tJtcyZ78yaAcyqI8yqRcyqZ8yqicyqq8yqzcykYBfJsKYtZxMaFBEcNBHeuB +oW9ljUq5EecBGoFAtSbRHyTBIOrjysiczKEMy/7YHrOMHLy8HM2xTQSCGmsBINqRyyMnT/AhH98h +zVMRTWsZpwrxy6AxRGjEHnX1FYhKH/aBIPZ7hDTjH8RMOwWCG/AcwSNmzfMxzQDwLRCrzAI90M7K +zIUry9jcuNEMaBz5F4JAF8TxzOmMGZoBHd8MaHFiG7dxzNU8GQ2hzY/HGrEpbwSxjmgxJGYxzyVN +F19BBKVwz1UyAKuBGab/VBto4Rql+Rd2QdA83dM+/dNAHdRCPdREXdRGfdQxQQVduQI5wAZLrUvd +laHkExHlQrkfXcQYi9XpZsNIPMImoVAxUdXlq9UVIUn1JUAKIdYWoTFO+xCSZDNTvRBwXT5gnWyU ++hDCVAFOzZWNUB+k1BUdIARoPW5xgcb/QQRcSQkmcGI3URsjsAhc0ggIZBF7cMWnFdVLgdkpscRP +UddJUdk/SkIkNreMBVNGfDBEBwhWLbAvNgt9vbh2htVifBeSZNAAsGge0iAa9wK2/UG1Tb32XBpw +8RxtYAgPUNwWswV5VxBsWyRoplD+w9nB3RjDbQDFfdyGkNziNgCpvdod/6dqlJUo5pwWNNpx0tKq +3F1qqs0ZDpxxo/3FuOG/T4oZvl3EKISChfAKGzALOqA8tNSqAtHEk9QY400V5T3dCM4VN1QeXSF0 +V3cXTZJl8n3NMICI66uqlNoV8a0fNsQYWEBksCGh8owWdKbZB4GiKnofNBAfZzrYNbB3dgdNdJWP +nuY7dOpYRZzeALDeCNHcfgvNmNEBNr5RsDEukmIxND4evlPXL64AMR5JDUDcxo3c3SRuTKUWvU1K +V64+YC3gJVQ7DSLduX1TqdEFqxC1wzgQPn5kBa4qA/6kI7wHspaYIKbjPM4trg1LGOZd8/0XH9Tl +CtBrcySarx3OT6PF5v9K31pOHAol3v14Fm7uqqw04UgNn/RCBC3EVagwKXkMkrDBuajs2Z4O4JVe +6qZ+6qjuEhAAxLsh5gmB2aKeEPFbERrO0RVRqsI3BQYaOItguRh9E7V+EbODovFczu99EZTuvq1q +4gzh6m/eErPD2fTSRw1OCkRaEDY0B55g2JxtRP55EwAKYgJqEe1tEltgwj+wQKmOeWBmQ+TMUYF+ +2gdRqqeaqn/866fd6BNGus+y25/uVeZ6GF/6UmHK5XVa12uqA+My61mVpoemp2CsPpN+QlyNTpr4 +FykO1mBWVG468Mp+V/5ToBCPG6xEXHEwCHEdTMduroa2IMce3lqd8LL/FU30jqqqCsg1ZhUej3OH +Bec4R6ku5jFJQAc+2OAjUn5ThAA7PxjHLt1dEadGH+Bi5lQi/jvcDtwnrAZpOtuzcqVZagBb2qWc +AaeOmtVeDUNkehc2IyC71vKxyAW5hB2IRvZEbDI3PrfUF/frvveTF+ulzfczUqoWDPgCXbyGf/iI +n/jKSfhMUYgoUMfoKwB7JoDOYgRkAHo9ICUiHSieq/g2GSSlapglNZml949nUfmXX5zpoQcACI6T +xdKkV5idV43DyRgZvAHoa9PmyfhLUYjMPDjeI6aA+AE/LgAg55a8TOewHI20/xXLdho5yNK4iPxo +MZT/aPqeD4UH8Bjx/5FwRFaDavkemH7hvzMdSX79EQD9CCCC1DiNXnHXE4OT32hcHTU42hT91QXL +/Gj6Qwn/QAoQACxkEKABwEGECRUuZNjQ4UOIESUmOAACVooUlBQkvBBhQoWEDgJA2IiQ4seTIBVS +DNDSZQABTA4SOYUhwJ9ZOmbWvJkTQMqEDB4UBCABAUmJSR2+ZNrU6VOoUaVOpVrV6lWsWbVu5drV +61esSsWOJbtwINGyadWuZdvW7Vu4ceXOpVvX7l28efXu5csX7F/AgQUPJlzY8OGrfRUvZtzY8WPI +kSVPplzZ8uW0iDVv5tzZ82fQLjGPJl3a9FiRSE+vZt0aMlC5HQcscP/NNvRt3Ll17+Zc2/dv4HlT +l0TI50UQGgRlHjSqGoDsBSOcxAxe3fpl2AnnKBFhpWELHgJmlTEhdPZB6AiFogWw3mDRo8SlU38o +BxOPAARoMObd3/9/AANs6ToCCzRwrA9wCCAKExRqjrgDI5RwQgoZEvBCDDPU8K8KO/TwQxBDFHFE +yTY08UQUUwyARBZbdPFFGGOsUEUaa7QRNxlz1HFHHnv0sa4bgxRySMF+NPJIJJNU0kUim3TySaoQ +gnJKKneTskoaE8KyxoO29O9KL8MUE0MwxzTzzKzKRDNALdckEwA3QVMzTjrrBGxOpkgSqSUQFmBB +hZaoEKMQKVz6QQH/owL4oQMfWjqvBBJamkCNHjwIQFAHbApgABfmiKClAgBIoo+oftAhhEA+QcCl +Pj11qYg4MlD0T6cIaCDRlrpQww4tDI21JVs/oMOAALoDgIhIAziigUqdGuAKE0aIpBViX/rhDvvK +qIPUpmbriKkazIDBpgIGOhNPcEHpABFP5MhkVaf6ZIDbTa9QAJAU7iikV0kr6MENTjZiwxF+0WwT +KgpcAC+/W+F9ydtPmULCjESR6+EFO5/qMioKZtA0ACOggIHY2VhieM+MX0I3ZZZbhmrllkjKIqoh +WMnhoIELllSNEFC2ldaXnohFiINCIORdUCGNqgZSiAagg0IiZnUB/zhmdmmPMooOROoAsH7aAWIF +oCXrg8AgGNgGrAZVKJcGwMNkpmgJ+CD7vnBJ6DsQAgOTQltadiGlm4pCunM3hkpssgVKJOKYGlTI +3ABqMKUkoz+ptqUaUNnI6FMuL9xwqoC49eO/FYK0zzqUcKoNMcZ1GXSnBNgib1RVWSDR2ezAmGG1 +W4bZZeBfhz144of8vfjCDkbes+GX5+p456MPc0nqq7f+euxHk377OKHn/vvcvAd/K+XHH6x586US +P332UfxdT5cIMKOEBy5kHVcB3sCPK1tx1UwALIyADi75wxssRYErzCt+UzAOTGbBk/yYAWgiSMUr +WiI7BSRgCWb6nf8XFAA2Pi0gcEfIRN+e4IKeEWtifNggTApQhd61xAuGSEHD3FQ+pogHgvIDmg41 +xUNAvSQmNvDECGRVPPRVpWQHQBvKfJfE9kVRRe/74FNEoIYW7ECIVxghGWAAAiuMzAtxSAMQpgDC +PmURKgVgm1XAGLgx+sBtanzJEFyhgzpErH8OK0CCoGIrJ7Kxfo5aANyicgQyGCdkrrsgFhj1kj0w +a385ZEIHHOEwDkKxOwtzScia1ZIhLCAJQbwgE/zoku5cIAxuc4gEPjYmHDolkj2YJFNmWcuWMIgh +QBOeVJbVg1acIAAfwV0hmXiy4K1PistkExSp1CquMdN9zpRmlJT/WU2nUHOZ18RmN+WkTW+Gsyrc +DGcsxTkVcEaRnOdk5/nS2U54Duid7DRnPJsyz/St05771Io++SlNf1aznv9cEZy44rYGBkB0MUxZ +QAn6UI05kyQwmMEMuGCKKsBgVQik30u6sx2FTqFiNFgBFBoFMpPCRAM2uMFLYJUGUFnAB55zChpM +0aBtVWsLvwpAwvKoKAHWyoYxi8NJW4Ic19lqZI08ZQDAaMiXUGA8T9uXELdwM0v2rVsu+IATXCKA +PLQgYuU6Iiy1SQCy9cCCTzmURoPmggYl4RMfE92xMMEBN9y0B3Yz2O+oYAivMsx/D+NqYF0yxiMm +LHDAmycxV7XE/yYmE58QpWxUHBoAFGxgA8L8igCasIEYbMWzoHUKAm2QrJesgbRN8WxomaJaGdAU +LJmVAWdz+NnYgs97qt2sVjK7WqecYQO57d5lmalNzxJ3fMatLESZ29ztPbd9A/3nZJdrXehmN3vb +5W53vfvdzGRXvOMlb3nNe170ple962Vve937XvjGV77zpW997Xtf/OZXv/vlb3/9+18AB1i+qvmW +Sk1yzKyopo0MQ080Wfse+IxJNVAVcIUtfOF2OqchuCKwgwtjqwZLhT2D/cpHIvLIz0wYwYYxcXsG +iWEYx1jGUNLwQgo8kpIUeMTwQg5CgAms/bjYJR2OXwMOwoBN9P9qAHkYw0FOueNceQcAI+BbAIbg +Ah9bKiotBoATe8wceIGYISL5MgAC0asrI4SlLqECFA7SgUTwawtN/gmCVeySFi+4zQgJxP4kB7k8 +vxgmywHAjzc1ngXPWNGLZjRoFCxopxDZwGAepkq6/JJADznHUhPzjQMQqoOwBMrGggjkoMJlhjBg +WC/pdDS57MRPI+Rbj37JnWNWErhlGsdHhjRTdN22KziElo0mdrGNLZgaL4TDm74ghHEVsjfHOQBP +cIWbhXzrEKPtIGuOHCgQ8tNJRzgAXZByoTvXkifAogGJdsqrqdLqppT5zFbG8rZbOmj1rFpyBy4y +RPRsbTP72RT/kCN1Ufi6qQXA+RTwqoG3D7LUY0dc4hMPELQBQEeKZ1zjG+e4VWrgBodHe+EdJ3nJ +TX5ylKdc5Stnectd/nKYx1zmM6d5zU8UhdNCBQXKNcxCoeJzreActVgB+m0QursMFd0rRV+DazeD +BlCYgA1lrUrRdy5bp1zdUXhIaLe4jnSbQ0noWBq7bo4gCapD6ej/RMmKP802AdSWKnG3bVP2mHW5 +s7oBe0KB0yN727o7RZAtOUPgv9qEwAPSKU0nDOPbZkzM8vy1fucK3f841L+fgfIv0bxUFH+4vKON +xE/ROlPIOhXPJn7vUum7VCAbd89Blimd33IFTNb2TkIhUQW5/4AqaCABLbtkYhI4faSr6JIXMrT0 +Xkl9VFBgeIhxZfmfNjVTpp9Dnrc+dqGHiuObcv2XPP8q4Oe858ivlcFbPnaIj4r65y758Qce9i9J +P/c5D/+WeH/2m/9qbuF3uCbgP5iwP7wzPKg4A5pqPtCLPcgLPwJ0icJbPwPsP/MTwACgvQPcvOIT +ENyjv6YSAC5KlsGLHJHCJKEavVrjKaW6nI9Qo8/7iE/qKReoA1wClabCsZGBweDzKfz4vBVasZBx +JbdxlYQBhDJolu6IQZegADxwFaaYDYz7CN0JgB98iSDEgCH8lCI8QktJQkupgRL0PMxjGIgLAA+a +mYLgtpZ4Kf+h2hPIAsPRu7vS4iJB+yjVob60wzN/2cEZ7MHVW5v6cRuTiYkCG0Eo1KJm86PXW6l7 +W0MyajfbOyZUA4CcabZvKQAjagkE+qkNzBMFoCiLwii34qg6tAKQMqORKqmTCplG0cEl7MOYmimO +mSqo4ZfZcELkSJQfCKqm6EQIKKqXQCpyaaor4iRlIYM9gUMTZAomdMIUNKoAEEbqk0XkIxwZdJVf +hEZpnI2cMxRehIoslEEjREIr+KQ+UpALCsFKi0EetEF0hAl17JYFwLiC8KMOrDSTKRdqpEIauBjB ++8B4zCEN+JZmjKY0bMQAYMOCUKBXGQNYewrHIkEUjIpfzEP/hOvGfmFHWDzEr9IARWzApqjInroC +jNRDjaRBd0QlLJokRBKJg3SpRyTDyzlD5Ks+ALlHQKS/NhpBcPm9ZZRDp7KCFmihkVDBP+yXoUSm +aOzH4JOKAmABesFBA7CYptS7ZJwCf8y9pYoJoViAcUmYFpAFGgAh13OBb5E9hGMJMMzKlliksGGC +rvxKhRFLsuzJOBzDz4ushFFDMXRDkHSJGvBJwVpGTcSDktwkROzEYGTKp8jLwesOGPCsGaA8QwTJ +gqAVyNpLhKy924tEl3JIlSqwSWkBV+ApPHyK/2sKJjxMoUTE7kgALngEmEKqH2BIqlwjdhPDTxKU +LIgCXmKK/x/gqU6EFWg0vQVDy7x8icCcSEcxy08hTtzsNVREqmqBzqdAy6YITovkygfwSgwAS7q8 +HJ58u/q5zacYz/F8vKTUxCuglSuCGySggXxMtLWsypxEPrZBJIjjPQfjlI7QzKfgqKErAtBsCj3g +pYi0SxMEo/UsSovETvOUxwZFIMyEPAYlSpFczc1cSiU0zhdDztUD0MY8SqU8zTChLawTogC0PuBa +P/z7Ps2aQBgVwN+SUc4brhQVrc+y0agQrhe1ChQVsRXFitGyQKoI0tsyUsyKUeljUqo4gkeARhBc +rKdYgwdkrc9S0gyp0dly0qygLQOcGLZ0CdXiv8wyPNjKUf8gxdH229EqZVOwSNOqKFPQ4NKDgjwr +NcDM0tLb6i2syNP189M+FUBARb0mwD8k1bkW9S0vTUsmKlTnW9QbNdNG7Yoi3YozDTv++i0+TS/3 +mzgMhK9Q1VRSLVVTPVVUTVVVXdX1IjcGwAQ3+AQsSU2nzE1HJUGQ+h8NsNUfMAFX2ooaKINGGQIr +qMuW+IEViASduZCFHKRe/dWrAAFWWAFqTdZP0KqpEIFVqAT71AzZS8+roNXHozDP0FZubQk06IRq +XQFNoBZrodaoFKJZoNahe4l0XddNWCsMkSryWBdVuZGP2A5vCQNWha4aWIFGMJpk5Zca8ASsQoRz +y6UWeIX/WMgBFnhH5fQEoqmcFI0C8JgqIhgWockBo4lXoWmEmdgEbBUaoglZKji+npoqAACEucLP +XrvVtUNXTmgQIsgEDNiCFRACC6BWZdVEmaXZV5IcBUCVVtjVmy06j+WBsaFER8BWVusEUqmBThgg +TFMDo4gC09wUPIABlj0WpJFYqc2aEZC2JTzamhVbsq3YY7Ec5ZwcpnXalvC5PiGCRpQfY+0XuNFP +TRkCDtBXX/NMhXoEJ5AcE1gXrkGDnTVbDCAAhFXYFeCWht1YQqDbWyXPtiUbpA2aoTkWOnjZh0zL +DRjdkP0YOyKbvdEq8cgaVHkxfj2I0IVEk6FVPRgBmArN/wgIyGP9E8XUNCeaKE0RG0pokIHZnyuK +QSPQgbqcod4NAMjdiLpxCSBQ3LEJAUYylCr4WyisJSTwWpuomZtZWy0AgVXQCDCgVp/VWevFhIPL +XieA3GhxhC9AHLN1GPOdMmmjgiojAExY1oKtrA3Ugxs0w+MD18WrKC4QzF48TpD8PP30nLaLPuK9 +yE3gAA7mAFYQTluFLNmrASsYAUd4hcvBYA3uYA/+FaBs1ja02ZfQA1uVClgxLOTgg2PCzuIbzz3i +xg3u4A+WFbR8KiZ6YbwtUUXZiJI83InVrA2wGWPkzGNKzpbEnBI+Yc8Z3gBYAwcWzG9lGyBm4SFG +OE8TV/9CMqRORIGKegNTKDAq0AEi+ASnG2MhDls9zN1PhOKLyiib4M+QAr7IoQHX4eJdQwh36RsG +RcR0FOMFQEkvsAFVsIJE0YPAKRdHYGE3sKHkPJzMUQBhySWeumH2rIJACCa98x9M1mROJlGezMwr +MGVULuD12kAzEiuXQAMz0KD7jB0m4KVIQsFXnuA/dBsWMCxOAZoo+F5NQYOs2ZNDyRQhkmF5ZAnZ +Q8BX+ZWEUSVr+aBXEoCtY4AgEgBTsVXHTDQGhgrUucMlvIKPtCR40WVejrVh2xQXAJpo/uY0RjAR +xgNxvqByHqTP45Q5uAEB0ANGwbp7DCWgIVw/gEjETc7/z8NmRzwi6xw0YLahMHZWb57mXGJmdH1m +Z0m4S0LXXd4gtwSlBfgWAXA6BPqWfPbopuhAWo0kXgZkfAOA1KlJi8Sx0/1otzrWHCBLrvQEbmZC +IuAEjAsXXmGKaunkqCpcSGqAhJqUOuCEecYs24rPkYpBpl7Wp3ZlCWYJ8WsJribMl+gCqaZltmYf +7PTQtt6e4CzOuK5ru75rvM5rsAAvvu5rv/5r6tHrKQJswi5swz7sDxHsFPmN9kVZtRhajUDs6+kI +JLA0hWhsyX44DPgBOnuIgUCgzPYQxZ6miBgOhOBeBEiYhSCCoGUIyHachDCayF4IMJhthxhax0YI +oxAz/4jAbIdg7ZsJ7cegCDSQVc5OiKoJAFqIgPNICNbObYWQbeLoCBMD7qRgA4RtiA4QBNuuDpGg +hVWqN4Q4nVFAAN4+CMiGkIRoX6IxbYTY7u4+CwgbkewYl0kcWqdBiPRuCNxmCPhW77LJ7ssW8Ogm +hNZuiNoGcLgY7RNJCvc+sI/omYTs7EpBJFXiFIVIbg9SNgQIl4R4EIFQDseRcGjbbSNrMBNLbkFB +CD8KlY4oON2ZROHeC4qwldRpbuMggClIjzGLNQ0H8BcvtxgHCRA/CyZwHEgBQRdT7TdrFD3w7lgb +Fx0HgOTeAl81byMzDl1JiJGxlfXAgvduFJIQCiZ/Gv8nD3H2oO+KuIgUoBYQqLf/DLbieIEtR4gu +bwBIAW2FIHPxfqQnrxRdVghANwPTIQGwSogs6hP48HC8YHATcfBDPoi9Uu1HItCImINVSrhGsXQH +iY8P9/SzAPODSG7WgQ/epm6QeKQNdzIcoA5UlzWPsOwZp/EDALEUqgHmhnPmpg0avCKEEIlQqfTO +hnUue/UiJwgIk28AYKkyLxBgPzJSoYUXCEwwA7FKmRguN4CQyXM5p/KZIQlmF+/HQfYWyQ6FePUs +w3Y713YoUKVmt7d33zAPOO+imPcGcPduv7gdMBYQb3RH1xC6GFpqze8AJ3DnHnixkG+FTV7aXoHu +Xgj/7HZ4BZ/16lh42FYI1j7wu2hfiYeR7UZ4s6BW6B7wjv+uj9f4hPj4hwcAju9uyyX4l2eIjB/5 +vvh3gL8O1iZ4it95nu95EbH5DPF5oR96oi96hQD6NzF6pV96pjdspL+Qpi96G3gAKK56KBb3qA/t +PLL6DVhx7Hl6Acn6pX9woygdMzeAUDEKJmBboZGPs4EJLgg5se8Rc3fuf+2JvAEApoUXAfAaYckt +3rKCPynzwa83o9gCpDECMpiytxeAuEeIJKADeHmCPLh4vwB7AJl7o39wAPAUDGcpRYcP54AOc6kB +Fl44etf8GKGIAeCCDs6r54gACnD9Dn5oUNN7QtAE/4zggebmcRdjD/cAM+co/dPHcpkyAKmK3MbA +/MxX/aHnfL0HmyZAgFIHs5jYiFCGtkoh1oQYgUFw/h2pe4FolD3QCb25mZGp/h7QguZmdjwI80sR +AwAQFgNAi36XdA/gfoTwfgCQA4YHCAAlSAxYAOAgwoQKFzJsyDAAxIgSJ1KsaPEixowaN3Ls6PEj +yJAiR5IsaTKjw5QqV7Js6fIlzJgyZ9KsafMmTptzwlBwoVACAggKchItavQo0qRKlzJt6rTmyahS +p1KtavUq1qwen3Lt6vUr2LBix5Ita/Ys2rRntbJt6/Yt3LhyI6qta/cu3rx69/Lt6/evzbmCBxMu +bP/YLeDEihczbuz4MeTIRw9Trmz5MmaIkjdz7uz5M+jQoltmLm36NOqoo1ezbu36NezYOFPTrm37 +dgDZunfz7u37917cwocTHwz8OPLkypczV1n8OfToVJtTr279OvbI0rdz774xO/jw4seTf+r9PHrv +5dezb+/+/cH08ucTR0j/Pv6q9vOnTsifdnz/CbafgAUa+BaBByq4YIILHuafg5YFGKFWDVJ4IYYa +WTgRGp2s8OEKm7yCGgWzlGFCB4h8goBwXbDSCABsRNKKARHVQIoQAKR4So0T1WBKCzxYJMAPH/bx +34YT/eFKGQcRsYkUEtXwYoyRCBmRALRwMhQbjlz/KdETTJoQAiGf9IhkkhV1uEImGFD0Y5AWDcAK +m25mKNGEIRWUwAEQEdCAA3fmlqeghQqaJkRCBRqRUDDYmSUlJsToJUQiqNGDBxEZoYMDZ3phSBoQ +ldgkAIB8YmcAUbTwSiw5sIADRT9U0SlFW3wAa0QUXDGHEgGgwYmkRLQJwiqUKADGh21C9OtQcmDy +RURAPOLEryaM4MgXWTYpLIsUUYAHCypU9O1ANtIgQaYSFXRBBBSBsACmBViQAZoAZPRDBz70OIAL +O1kkFFAB1DBFD9BC9EMc9Aag6wVhUAghRgLoMccNfwY80brtUtSGGBkMgIe/hRJaUQ2e5EimmRDt +/9lnAH8umiGihsp8YMxCJSRHJlEGAIIVLewgkQBXMPBAAAXVIaQXNqhiRcB6lFuQDZtwMDUHrCQM +UQFDbyRADago8AEdEAExBboBBEGDowJbce0rZ7bcwMUByOsI1Ry4ATeLLkuUNdEqL8AnRihw0WQd +Gj9xRRyOvLGKAnWQQFHGEm2qsNzz1puRALPcEYgfmstBh9t+mtGCxsuCQsQng3eQiMF/9qBFri7c +WiDEFYnAdLoWd6vuAuxO1FMdvUJUxBi03jmyRWvMMAMX57K4sp+AHor8zNUbWLMCL1MURRUw7P5D +DsYLwAQDnjS8MB5EcOJzRD9kj2oAAkTE90UUcP8wYkR7NMDHCxAJgAUDOsGAI0HkDGcqwtXMRgNM +2cgMdoCdRHqkt/lpzW+Am8gQOKCz+DGhClkIAMcYKKorzI53vruIvCiHH0RZimISoYIYYFCjIZiC +AbgCGhYs4AOJIEEN7AvAFvLVoy5YoXC0i9lEdAe53pXubWnj4ei+dCHq+Y8J4cof3or2N5ZNEGZU +tB4YV/jF9NRggekKY3eQiEaT1G6NVxmjGy+ixjjSsThzrCMeKwTHPH6kjXxko73+qKE9CrKQmbmj +IRMpEkQqkiJ+bORWAglJPBFykpaECyMvqUlKSnKTg6ykJ0GJx0x6spSqEaUpL0nKST4ylRNBJR3/ +V+nKWUayk7SkpSwb2cpbwjKOubwlMC3yy2COspeQ3CUubclKYxKzmXQZ45pAJCISmQhFKtqdbVwE +IxnRyEY40hEieJQrWngiBwAQ1gYDEKYT7Sh09EHikkj1pHROaZtWApqWuEQpNXlIWUccIwXIaU50 +SiSg5TxnzioypzrJjJnQe5v2pshMZzYTe9pr1KNoEalJXclSIgzApowXgE+FamEmOoipUKUqVrnq +hu2blTtt5VJd8cpXwEIoBohlLGQx1KbNela0plWta2WLFtvKBDZzBS5xeQsP5YJIGctGEQFowHIV +mUAFTihGZU4EX/pSWb8cVhGAsWhgBWtfAv03/7GKZfGfXL0IVa061aqqEIQd+1jIpqeRkp2sTPva +YvQi+rCJUjSY2LtZQnfWs59hSWhEMxrSlMY0FjntcVCTGtWspjD6aYRrXgOb2MiWqbOlrQZrc0Tb +JKJErFmAblS7W8C6KLcKavGCFhEc4QyHOMUxznFT3YICvFcRELiABU4QUMwyt7nO3eFz7iTA6JqI +htOlrgyrM9jtpLpa5M5RAMAV7m+Di03gCS8AxBMphgipPOY5r7ZclN7xCFtYXo5RURfhHngDAD7x +kc98DvuW+n6o3/cBjYJ9G9f9JKI//vkPgAIkYAAMGBEEKuxsH62BAyEYEQnCF2u0fahEMrjB8f95 +0K4f1VUJ9xDFioxPAYlIKn9YqAYXRgSGMgwADW041RzuMCI9FLBq28rdMao4ThUpshQj8qcn+njF +XoyYFZkaAP0F7KGylehb56tlR8oXN2X86Jb1mOVZIpPMYzbkMMOcyjSruaFdFmSZXfnmmbG5zZus +s53je+Y14/mPc3bznvNcUfgQutCGPvRuBJ3nPis6Qowu5p/5GGmRTbrRhXy0pWlW6Vhiuo6b9mKg +M23mUIu6ep325alRHcpPl5rTZxYKET4UKbC5kzIDuEIVCJGCFFBiBCUVyRBSkDK31KAMI1jErhtx +NNE9iQNMAi0Hc60Jk4WgEGeMlhkAINetZoT/uCOIhN04UQVrQ2RTYIhECnLrP+AGwm6kyIERbWRs +cLvBEy92K0f4dZCLkZgQ0xZCta8dPQAEz80ksXKH08vqVrvRohI5r6jyUIV2u+HdRuyJDW4QET0A +4IK6yvjC8vBtP3DBFELEWgk4IYdFeELK2P6APzUFBSafDV0YBsQp3uCKSxxgALAoJxF2nTIq6CAQ +OXeFDnrw3kVIIhJuEHchXMEATDz7uBVxHxEOLJE2JL1dT3BBEiCMMTyU8GAlIFoKL4cRIibBCQbw +bg4cAT+JRMEEN/5fBxwRJei+rlJWABwKZFDr/MQZDWXo1HbHXvb4YWEO7YpCvgw1xoG1mwtu/yjD +qyz4XsE6euEMRyP2YLC8GZxAIli1bfw0UMEC3Op/fMJC8ArCYKwyhAFM5ezWwJeAJSzMBSCPQtm7 +poAOFKJ0q6UqQzqQNtniHsQX+XoIOnXrJKigR1S4A+m6mnSDafGsrK3rO8cIPkd0qwYL+IDV5W2D +xzWwB1caQCzEGwCsgpl4HxzymLewfiULuX3bn8jZ1EHdIN3u6VVG7MFNIUSVARZETQ+pfZ4mOZxF +vMvqnAIXsEIO9F1EcAwAiNAWSMqNQQQFJoIfMA8rMILw4B7k4MG3TQ0r3EHYSQ4UAAAfsAxVFcIp +zICJZN/OLAALYIIb8Ih3KQDOzcAbuAElWP8d830YA0oEEDQAEWCC3ZiCAvQdvxBfDnIB4xRClNxO +CATCroVhCmjY3mzbfcSM+5iKH+jcHRCBxo2PCQSdGKYA0aCBGThLCboBKNAaRBDRtbyBifAh/nnE +ankhGM4h7BTACKRfrlzBIsZXRmxKD6iCzumAECzgBV3ZYD0gBFpSqmXGFqRVJ4bEJ4JeKZriqnHi +KOqS561iGrUiGMUZn6WiKwLTKdaidNyi9ciiKcEig/giLiocog0jMRajMS5GMCajMi4jMzajMz4j +NEajNE4jNVajNV4jNmajNm4jN3ajN34jOIajOI4jOZajOZ4jOqajOq4jO7ajO74jPMajPM7/Iz3W +oz3eIz7moz7uIz/2oz/+I0AGpEAOJEEW5CTZTEpcDEKeEPIdBOp5BELS1p8chFYNiQYoIIyRBO0x +xAhgQjfNBUI+pFVsJG0ZpEme5MwgpEMo5FAAQEVmxUS6ZBOx2EXuW0aOxEamhNLJRUiyTFaQpNah +pFAOZYREZFBSxEJqTEMCQNxAxAWOAQAwwCa8gRUcBG0lJf9RZASEyQx2JBkuZVMWTckhBBFwABli +RE6+zI8kxMXEJLs8weUBgPbAJamck1kOCS2AgpN8wiy0pG31ZEQAJUXApV46CQf4gRY1hFwJwFMi +RLslGVFGpmQWh1FmBFamHkZGxBZApUNc/2VLalVMOsROYqZNYpFDnJ1GpKVE3A5CZGIDNMSi/MAM +NsQIfJXKXIFK/KVf+qRgVhFnLsS8FIRi0gsRdeZRTiZyJudpqCRDaNVlgiWLjA9CoCZE9GYAXObb +aGVEsOZB3F1NMmW3EE9pQsTZHATIoWUFIIRaFqaO9Fh2RiWUAA0TIMR5KhBC3FhPIMRoXuduMkp/ +Vmd6RmXf5OdB7CcHKYx1JmZ3us0A5MFxKieERqhhMOdCOOdnKuV3LqB6ml6AeqZ2DpxM7k1r9gl0 +KmhKmCFF5CRtqpBbzmROhiBphmhMliRgJsp/zl+H9s2MPiiAWmVQiudCoE46SSiRFilItv9kSY7V +hfpPhj6PQRyE9lgndraoiDokiTapiToEik6EiiZED9xlEr1miHLofZ7JUvrOjkpEjfLnQQhYbxrB +bCYpl+Yo5MyCmC4EjBqpnu4pVlQmRjwnlkpnmzIWjvqof37oe2pVebYnk2ameXGmgULEEKwCj/Yo +lG4ElconfWocedJAmQYAdwIAjK4pQuYdi3ClofaefvrkgVrq4g1AKrTCRAhqx7Eqn94qrpYEhS4E +S35oiWZp7R3YlN4pR1LOr04ZsS6EnM7phmpEpnbVbHKkbdpnStiWcKYEbVFAHmipwtAqQgTnkzZE +vOUquZbrR+zqT3QLoDqqypxUB57CRtb/57A6SVzqCAnOKpYCzQVGa0dqUGoGqFxiqpi+JJjUaweC +6ZuwAlSujh+sKVQpLHxKQYL2oR4ihFQiJpjAwp3OweMw5t0gRAXepLmOLMm+RQG0GwRpy6eWLMu2 +rD4WgGjOpMvOLM3WrM3eLM7mrM7uLM/2rM/+LNAGrdAOLdEWrdEeLdImrdIuLdM2rdM+LdRGbThS +AYhULYiEjQoWFAsy4lVoIv9x3kZkbUd47Vs4X2mQLUhM0MDUFFsQ0dS5wSd8xAR9yyNmBN1andlG +RN5uhAisQiWkCwjQCYhEwiekU5GsgNgBzSx8CPtRRDR9yDSdhjZVyUe2mthyx+XGhX2l/8featLp +2WrmjkTiZQTaom1GhC7pJpxcdK5gJJ7pEqLqOmv/gQQEiCLsgq1HdC7roucFfS5EfF3kpd4FkMII +gN//zIEnbCl/vgx0Uedl/M8IhA1E/MEbCNxHpB0toS50aG9bbC567C5xYG9m+O7eDI1RTcoGRcH+ +SSoGAsAIJMJZ6tSxJIubUAAXbIm2JYLxAcqPKMAXHphsDQEr5AjxyayBne/7kqEAE3DxfS2YxAKM +nFN8/k993k4N+pgaMBmWnNT/WtAGxEKOoI7bPAEEO8kEY0EFW8EFQ0QPpY0Am1MCT4T88pSyuEz/ +pkgTjQpKnYpFTNDHMBiOtW8CzzD9sv+YRklKl1xJDaxAI5DJCkTCWbIvA+/vy6hv4zILAPDUCjyO +FXswCJ8THdgJiOlwqfDwVVVA76KxTx4BGaQNVbHLFTxV+4SL+E6E9/LnE0EKEu+TR51RSHkKqEix +jjRwRKxUq2Se1l4RxiyAkbGwGkiAm1QLThEAEzsx4kYEFjsL96kKD5wUEYAOCecAmYjdC7sv/LIY +BweC1mUyUEGEIbdU1szUrggPK3Pfx8DABpiCCcSJJAvL3FEwp4KqCvtkC7sJ35xvl6TTAg9yE3Ey +MuudnOABDJBwCCNVpVzKGfWxK6/KIeNKyZhTl0DQMTdJMkfEEDDJQYABJoxYKh8YGaf/1AOHMB1Q +QfZYBF8BAMqcSSnHsLfc71BYgP5GMy7rspEtcwHrrTRTM0J1y0PZL/4CdBMNgCvASIocmEET8jZ3 +8raAcquMckG5KzyLzbT8iDVpDCU3MSEYCWaQ7/ycE/v10LLNVt8MTJ5WROINgQxgCRaU0J8Iovss +H3wJQB7YHiabQVhijUuD1SMKNVEvi1HnTVDngSDyS/EKDMGkywfCwf0Bc1O1AO8tcrUZjI25iVBP +tQtUtVlhtQlodYOBHE0PHv81ZU+DzsI4YknBkAOIcb8YsA8D1ltTxOi+kBhwYfsowMXUMdAMtZTZ +YWx1GP1QMPvxSwHKtN+EtVMX3EPh/7VeO94Zp3FZTs0qJE63vHEE3E4jw+kOIbZ/vsy7KDIMEfbB +GDaLeJXfCAT7TQA2M/ViPzVSx6CcXIG1zMiZrFZPcPYPKPJE1HEXqMEDodVmJTVI6YBlS0zw/nX9 +4IFXU8RyN/fBJBDM+rYwF9zwXM12axjCKIxwaqB+Ibc9XzVEZPVWozCnwiwRvLQaLJtuF/VhQzdM +Q6YWWbavmEHBsTT5fjeE6YpxRUQXdBN923dMz8AGmfbPfEt2T4RmgxVnB4CNdYuKBay3zACqwOmN +WfdF4LROL57eGoR657dTLyCA2yFmM6CJN1gJeYH8LQwXZIti63e3NHi5SXchQAt19//YhRfNXkcP +H+qKr82P8h4GS3uY1unB6lWQrkxcK5ReD89u/DTB8oSiwshW5EzQn7Tba4ECwVJ2XCPAmNeNHqIp +fLFxnvruFiw5EpiBDzABZ7Px/VEE0aFODPCObfEM4MC528g5nds5nreLno+QlWO5TfefbLFxoFxW +3WjWoy8K9FR5IFx5kB21CC4W0DjW92U5mU9Nm7dLFz22BmQ4v7AtZzlf2kEPpWeW7QJoGq/KBuQ6 +BsYJaQfA2JRNGaWNatsoYukMzwBZ0GgNZI2UZDVNuax5mZ8Q9wYAbhGcxkRBAiGQ1ZkW27hNHc8N +m2dR8zXh3OLapjs6n+uAn5eha5n/urgn6ZK5CWkZc2uFOyayKrejFlzPeajU+Z3nORnsuQpKOdFA +u6mbucYM/LLCuuUQuBpDuUQQekUovNahwPK8gSmcUJ9/wp/7TdRU+tVEzmpjxHo1T8BoOqdHDJfP +gJcrVBO+TanbDcK7VxnSi/MJwMq3/LF/dZDF/KlDvOY58Ky7YAJFOhm8zLBTxpOjOdBn7R8MDrSF +adxQdyII3nUWfcKFOXwtGVwnd0nqDtdn+aJwTJxXgB30z87rgc/UOQx8zGQPCcaPm5NaK2CRfaGb +Pdr3zBKo/Q6wvdvz/PRCvfRKPTbJlt68C5BhRF+j3tOXAbQF9jUjexyzX9KH/aUb/9jBsEEEExXm +0zyT2zxgIT6hZgT5PnmjvJ0GnJCNO4AF90/lgJ+Ngq2lSP5TwTnPyJAXxEEajA2tWP7EL+tFsDGD +fdwNjE1Nn7MOxNu3o3j5HhiIXVnjR/1UxX0hsAjruZTXHyW2Z0BPGNn1X8TeIv+4SkTar70ZtD0e +vL0K0o/vU8T6L/zLp53DX5AKcgzYvj/RvEsS0MGf9zqWAMQbU1UKIQCxoMWOAAsZLhywYI6ShhAU +OGjI8EiDHq1OBJhQQQKChn+4lPlA52IAAXo6JJJhIACEOBlSBniY4EBDAg1gwKx5MyfDAhZoAlXJ +0iVMmTRFqMGZcmfPmgsLMHjA0P/owp0WDyacGmCrzgYWqRL9ehZtWrULPz5tWPWqUKtU5wZA0XEh +EhohUwah0cMDQxFWWixZKIDJTK0Nkqhg+KMizLABKLhg4FhtAQA9eDh0wcJx5ctTJw/Aw8IJ1s+Y +AxiBsoiGj4U/WHSKg2OqgBgMKVy5EMHmArfBn5pGrRo0Q9ewZQegbRv3wrsM9fK96BewWLKLyUJ2 +gKGhANJjHQrPOT3vXpHYA0+NUgWGyNk5HPgcSrOmaNYXJweAG6CpHlTZgEC86IrroQ4ckQ8NMxIw +LCvvwGNIvJraCupChoZYIDkBNPjtMCYAAKAOicrCLyWKtkvpvfgeo88nxBjw5IL/MCjDgwhOvKLM +sv0u+m+qITiQgkImqsiCoQnUqIOTBxk6w6cAilBMyjiaW6gGM+zQ4iL76iIuKLDIs8vA6uSjcLeF +egMxyy27PDClyuYghYE+GGqTy4Z8ymohKBmaEsWLlottttpue+tL/+bS7ysg4UwpwQUXatBJCvAo +AcErTHDL0eBGW0hI8Dr9zzWpAtgQRN148w04CcNj6L3vJi0DgBVDTG6hPRrgC70AzLxosMJCpPIi +Pnn8FNIFFGTQQQjNA5Aww1RKDL8tqpCVMi60YHQqR/mczFUKGepPzO2mvHKtdNX9qqnhqCqBhLfg +fTfeALpARYERiaBjwpT2oLWD//pOXSXfERLh4hH8CHiEDlpoDSEQ4BZD8k5T8gXAgkXsrKmAOV6J +JQcARnDki4ZqsHjEjDfeieJJOTFB30/6VQkLANw6KASB83PljhFHLjk4O17AagGhGULj5ZhnFqDm +mxfIOcp7L9535ob+BSBgyRpoWcyWn4hFiBFDICSTM8Wi+CGjpdaXX4auzrqmIVgJGQA2HMlzthFS +++rki1WeWKh5EUvikxlmeMMVHfjIqYB5g5PgZJj33bPooRf6OmwAxi7bwgqMhnbEEcGIpJUJPQTR +M0wbikLvqSjiOiW56bYbb7bUyHncBnCt2G+NA693Klo4uVgOTIDO3fFcadU8Yv8Ktwi5zsMcDh2M +u+klejggxlwbAKrj5NlnkimcXnTr/Uu+ISTMgENn6ZcHoPo807ZcebGbz63poHBu/3zg++c9Zb67 +3u9+IhxZmEJydIiSALagA5ElYgN4+Fzj/LcQ8tFugAMkwPKIsIktgIgC4BOZ+C4HNrGR7UyR6x4d +gDAF2B1mCz2DmCoWwBfueS92BHsgwgJFtM+ZDGUYE+BNDphAyn1uCDo0GA/vhC+sIWJjAehbAKNI +QeyFSXvbwdwJOde1szkPelFc1xjJWEYznhGNaVTjGtnYRje+EY5vXEpDBuCCOnQmjnnU4x7d+AMr +8RGQgRTkIL9iLEIeEpFxNGT/IhnZSEc+EpKRlOQkKYm0i41NZpTU5CYXkhHrcBKUoVzjIkVZSkCS +0pSpVOUqWdlKV74SlrGU5SxpWUtb3hKXudTlLnnZS1/+EpjBFOYwiVlMYx4TmclU5jKZ2UxnPhOa +0ZTmNKlZTWteE5vZ1OY2udlNb34TnOEUZ1rQAAoTsKGHtzyCJNLpHhtU0CF44IPl1pAmPq6EEDeo +iQCaYCAyUoERhtkDJCTmSnzqUyX9HKZp5rmQKLzTjOtsJ0PpN05tdoUHcrKRRTna0bW0QQwvzKWK +1tKpK/pKDS3A41coMItRHI+MHkoUQ7yQAxhUbS29USli5oBQhhxEZHsLpUzj/1LTm67rI2xYwVIb +sZnanSVDaNxDCgqalqyYVF0kTZa7DhlVihBhqSvIgYJMp4EOCEGlNdkJxtoZEwWAdQWUMMFJokTJ +AVyhCoRIQQooMYI0nHEIKfhEXQVppsH0oKIeVexiT7RPhX6lV461Z1oE8JKGoGCyKannVyqrlIqk +5AyZVVRcivUsyFq2PKgDrWgZglmVaGCmlJWBP1PyAxNYhCKfpNkcIoAH3nIWtVM5A20bEtqzoCC4 +F3EtUdEY1dZAQbdfcW5xWWuX5N5HsqXlVGyNmxvLalW7OemscJPbkM3WpLvSrYBbwIsYs7z2AqrY +S3uoYwYJYLcm4PXPkVKCXP/CmtG/nGUtfmM6W7FEVzrlvchww6NglRh4IV1Qgw8MMBj+MRbDFg0s +J+CAiBS8NABU0EEHOeAKk6DkXZyQwyI84SMpTiEQHOCCG8rAguikpHGd6KCJP7AJUwCCA6zQQQsK +2gUrjCASHHADJwjSnjp2oBBBvsMhbqumPCDZD1wwRQco/KjwgglLZgDEKRB3iQPQIgU1jsSHS0aB +K0ciy1vucgCAYIbiucEUbGhEbMsVuE7cmcPYWhdIadLC7JQHEJwAxCZMbIE55/jOCOwB0NyMZS1z +GSYPSfSieYasOkdaz3WZDBXEwJeD1KGqSVpvUBDzAaFqBsEeWfViFlGGQrj/wRMKcJMUxUxmV5i5 +BingsIep+uIYz7jG0blqXSoN50vP+clRZsWUq5wsIlCC02VwNEwsRWItw2dCfkxElknRnGbHGdOd +Y+9nFxIsiZ0uAiBt30EWR+CL6LcIYyCLm6sQYzeQIgeo5pENfKoHmwWlNwRfiIgD4Wsd9CAoO1nE +IzzsiKrV+QOZWBoTWvcnxVQmCZvwwyxW8IABwMITOSDCXgcbYh00HHEPj3gDFiGJSCyZIK5gACZ4 +vDeQi5zkpM3w0DNMYC9EpkgdH8qc1fKRWBfgAzduSlo7SQayqG9xDXGNBDAgUzHm2yIeUrjH/zra +AhbHtD8YAYrpuADVit2n/1X6a1ukdSyh5247UL+xAK6AvrWozzr5btlDdvTaqFPl8AyhSE/g3pAp +/ZXwCmGL54ZGd95YJi79qXML3mCGQ6fkI6EbEQaf9N/JuyUqUTo6xdTO9re8dypOF8myr9J4sr82 +en/SdwEL76HEXwTeN/pteDQw9oU8Xt1BoYjou9fF4BdgBPjpjcDtPREFwMBw33ZRb1QnGCtEhM5T +4ItfVgCF5rimOTJBl1+OupNJowUNCCRRHzINEYn5hS81EL/ZFvNJ9TeE/cAj9Q4DC34PBKzgKfQv +1oiOARULv5jL+sgCqy5iD5ImdJ7uS75lTPRL1nDCWEgq9JgPAD5lAo2CT/9qAF+gTGIeQrVCkPlG +g1wgkD/GxOzk4u7SojJYABM4gAdpLPeMZfW8TNaExgVFbzT4xChiELYyjwZ9xQwAQALoC/RmjQC5 +rOmokFz6AwUVQAWFAvZyxQJHhC9oT9ZEcAQd4wPZ7ctoSgEopgtWgW5GRLWmp3iIpAhDB1kawqvU +0F6sQOGCrzLmpSo2pvoU7/oMZwb8abogUO+YBiewoEQeoqE8xAw7oP2aEC0E4AdywEnYwzSozibA +BxBaTkysgxJF0BIFsAm9xbQGQBRJsQFjkaMI7AessEgSbwIZQg92R/Y4JgNNq89eDLG0Dgp6gvv8 +B+wGLu5+hM9MEBgbwo//isLtCqoyjO8i9KKh1OQK+Kw/RoXPzoJ16IBAxrFBvILw6q43cKUAdicA +js4YXcAa2244jAIb6ac3RI0GCcC+GmTXptBdkjEtoioLMXE2qMTedpE1epEMq3EZVwV9AHINXys5 +joAMTCX4isUFfoMh12IPV+Qea+9DJEZJWsAViKUQF4IDeQMPIMr7dmQwEgBh/or9fiD3qgRdZtBW +0OIgamThQioK2NFk1KMUz+RcvoJcWJGrpEgoZZEpw4nAGEgBgAxxyqAxbPAsjODhVCHmhAADSUsD +t0Mfd84PloysIuzIHIELeGYFxIAsDqIl/GAGuIAVGMFESvBZjMJDCuEU/2ZgFsqAyBZCDwiCB0vG +LcctLufSRNpgxDaBC1aBASiBG2nQG2/wLKICp9wRAx5CDhrB307MCw+BxAaiENqjMOFSLukSzMrD +LRSzgxrzMfGxO6wEJgaDJS/iI5JAE/YqBRphWagCCvnv9GZuRcIiL/eyL/8yADKiDpQMOLBSQLZy +DE0LSErzMFGzD0cmLe9gLXMyOMBACDrzJNrNCkKOL8tgEEBkAkIBE/wg5lyEOk/TRGyTCikCEHQz +5aoSvgpqJ6DGC9sqJX9KWRLhFOQyB3qgdkBqM9pjC2DGVFRiC6JyL9/ADShhb8ilWPAAyXhw2pIg +ihADANgnSiCAED4hzv9cbSEOQgfd4BQMACrH7HAmtEJX8RefQkRJVMtM9CyY5jebkkexiZ82oLrU +gp8cbI3OYAOIdA0gzLGAtI3WgEk1q7x+lLWG1PQiySiSlLb+AwWeNCWkNKaagEjzSACqtIyclLW2 +1J+o9Eu59CKwVF3cFEqJK6E2QE699JW2lE7XyEnDNEebgE3raxiV60j/i59Ea0/JNF22lE+BD1F7 +1FEfFVLNCJVqMFIrVZQeYg42ylI3lVM7lZfSqyYCzFNH9ZEqS05JFVVTVVVXlVVb1VVfFVZjVVZn +lVZr1VLNEFdzVVd3lVd71Vd/FViDVViHlViL1ViPFVmTVVmXlVmb1Vn/nxVao1Vap5Vaq9Vamc9W +b/Vat5Vbu9VbvxVcw1Vcx5Vcy9VczxVdpTVbKzVd29Vd3xVe41Ve55Ve69Ve73VX1zVS8ZVf+9Vf +/xVgA1ZgB5ZgiVVfIdVXYWAcCWQGlgxmuNUK14pYAQOoCtZiyRXVCMQUcLUHXmED0EANjvU37nBE +IrYBLhZYFXYDaOEJUdERCOQHxKBYcetidJUoThFldTVjx3EGRChn1fVgHdVXaVZfOGcT4zUkJPZn +lxZccaILtOAhRPBBhuALotZYR7YCmPZYLWIGEIAApoD5oKYJMEBphZVod/VmNUBrzRAnQg9igIPU +1rZZg1Zoe/VsR8TG/9rxYkYmTwSAC0AhdJKADuTjCfLgYT8AE9IEBWahZ0JiCzjHCMggJI6OrUQA +FTZBPmpgAQCAyHbjR6mADH4DCbK2ZBNBC3xiCBJHDiPgCCahFWACBRpIbmdXag+AAC7hBdRH9DJV +BEQhAqy2g+ypC1zgYQEAcRWXcQFgZEXhde1Cdn+TcokCBFBhcFXiakKHCD5BPv4gef/VIrYASSj3 +Aj3ACBLBa092RACBI6SjJERPfbltFjLBrWJme7s3bWk3dNqWdA/uAJWXdSuBSwYjfdfXLtoXe08B +L4YgD6ZGexeCe3tmRDbCJ2oAcDejeaWogkdwE9JEAFToNx9XJCIXWv/ptkeHdn5Fb55Cb3GGwApG +JDyjwARqpClGBA4GYUTmqWJH5gp2lAog+DeXzyzuCmaoD2aSFn39NwQXp45gJgRGM2rZBGAojCLx +F39xYisMICPwVgXW5Hc3FwACIde02EMBAIe9WIf9V4qiGIvJ4IfzJYg1ZTO+oH9BdA8ciER+Fw+8 +1z+SQw8e9kEA73wBQHWO9o4DYEFBVB+xRlIogo7tGNVMg61wlnb114VTwzXQuAsyeJDpRuAOGUkS +uXvcQA0aeUQeOY8BA0ExJmxQWWZV+UPrAw2WJzy/lod9eIRJuClNePlQ+AU+wixqgAd58BTOd9ta +ygL9SkdFMCR2WQz/EQCIM0CSjfg3lRZrRSYNxlhskIQiqrmUeYBkqXhprbgBzOIHxsAs+vg3rFZ0 +1iwF7EQzkLlmRJCbScSbs3aZ3Ria1dZnrlltNZILgpkD/MA/9FgzeKuOACBTgUqab+qSQ4cIKyCd +vXhEaNafAVqgNeN+qZirhvdh5xkAGBoKRO+h72iGma+ig/miAQCiUrepRmSlXaGl6VmAQwdeKPGe +qRWXc9luT9hnaOLo9AabcbV4OoMAaAA0kpn5bvoCnRmfozmQpXl1Q++oRSR0QiB8FWCePRqcmVac +BZkEmKY+KDeiASBv0SDlamWgjzqeTToCXLCabzqjI1ltI2KmCdYi/zSDjHs5FLZ4h6f5ZHuioUfk +oX+jYifarei6hc0wrif5AL4Ziff3ow0gsAHgoQujpHdXCeoaV0eRSLZgDEKHsw15DCw7sUekpndY +qYE2p2NRl/3GdF0ugj2AhUVvBGxYDuTKtEkgakNitkcoD9pY9OCaJoZgY+84mQFD/0KHm0OiYptY +CgQ4q9sasrc6nG0XfXdEYsc6IUq6KvGatxN7ZH47ukNPuHH2fh0tAOpY9MAgDvn1rkPHVArgYaWZ +t6BSX25AR81CvVuiZCgCvdWbekJmsWeXks3Qo+v7Qe9bR6Mvve24g6zgv+1YdEKGCGJ6nnaiwkPn +wseZJkCZri45tf+jdbVlMWEXqAm4wImMEHMp5A02dw76oF/K6YAnZHEbFwHEt5mjF5pdgf5mJXR6 +MwDaAArmWXDPRIEvZrynm7pztqvF0AMkTLkjoGJ7oKDQYBQQAK+75xRoPHmTHHqbuq8jOczflyEe +mKBDxyzitpkltiXwpsaruhDypKUqwQPEl8wdOHlvNswZ27G1us1bq3s1pxBeQUNi4WLuPADMPBAI +XU2Sd9F5I9Al+DBkPMdrVsRHvAEDdsCXnNM73dM/HdTvFdMzHWA3PdRPHdVTXdVXnVlHnQFZHdZj +XdZnndYH1tWJrtZzXdd3ndd73Vpvfeh8XdiHndiL3dhHBNgz7Nj/l53Zm93ZOT3ZMezZp53aq93a +/zXaGevat53bu93bwTXbF+vbx11YbaAPxnE38JRAXIDc251tD+BHxzFmkbUEPoELSltrw12x3J3f +f/VugXVsKMHSRQ+sMqffc73AcbUDBEHgK1EQxIqt1TlYwaDhCX4FDF70LCCuirdb9d2jDh7kc/Vu +E6KwCe6gQ6IJEKALOOAVDKA3SpbCnsANUuB1jSzkZT3hRS8JriLYRoFLREx5w4ACZowDuAQrRwAT +ulYAsk8NrAJnnV6fUR4DhmAG9oAMME3mad4AbB69e/4VqGDgf93jOermyz50/j0kWghrZGNBfxMr +8/cABgN38i10/wBjis1e1ZNSM6yiMn5cNgxOBK3Casd6RKAeDx/gFEMiS6raIug+timyRg5aXMee +7PH+5v/dCvMtJLIYuHOb777R6i0/1XN+RJJyWpin5dtuddXZ8Asf8aOeqQ9/KkIfcYlEAK634yl/ +nEQ/5P9dkB+AAmAhAuo6JFI5r5si8z+b92Gd9FX6BvreDG8qlQXfiwmfrFUAqWsa9pk5+Xk1UyX+ +WnV/95e/332fcxVCAH57qce0BtzgdSX/OLI+BU4hBrKc/D29+TkXOIJtr1rhCQBiAYAESwTQSvFJ +SoABAgF8wBGgCwcuVgD08CCAC4dXAmII0AAAgAQEEBSEDMnCSf+AJ25SpDgVo8DAA1xctjJAYMrJ +nTx7+vwJFECAoUSLGj2KNKnSpUybOn0KNarUqVSrWr2KNSvToFy7ev0KNqzYsWTLmj2LNq3atT3h +ZAngxeTJkSXBrFiRw6eFuyuEsP0LOLDgwYQLA7a7gpLck3tXNPrZ2O9JxHnDNu7LE/Fjw0G1ev4M +OrTo0aRLm47KObXq1axbu149sgYNnnQXv76NO7fu3bx7qz0NPLjw4cSLGyfqO7ny5cxzhyCEtycb +x82rW7+OPXvv49y7e/8OXrj28eTLmz+PPr369djDu38PP778oezr27+PP7/+/fxbz/8PYIACetZf +gQYeiGCCCi7/yNuADj4IYYQBMEhhhRZeiGGG/UnIYYcedqdhiCKOSGKJJg72YYoqrhjaiS6+CGOM +MlrIYo023ujUjDruyGOPPjaHY5BC4vhjkUYeiWSSZQ3JZJMeKglllFJOqaOTVl4pIJVabslllwhi +CWaY7nlJZplmntmemGquSRyabr4JZ5yGsUlnnaTJiWeeeu7ZmZ1+/nkVn4IOSuiZgB6K6FOFLspo +o0gmCmmkRjlKaaWWnihpppBeymmnniqoaaiAfkpqqaauJ2qqdZ6kaqsOsuqqaTvFelpItFIF6626 +Bpnrrr5y1+uvWc0q7Ge2FrvVscguG2GwzD4LmrPQQkXstLgK/2VtUdJmyy2IynYLLmrfhrtUteQm +G+62565757jsvkufu/DGK++8E2Lbrbr27nstvvyuqy+75v5b71MD4MHHC0MB0cBbiQb8b8TJ+otU +SUTcRYkJH9BhwH8DXFEFIS5RMkIaVw2BUMfC1VDGCIu41EgdPAxFgBlEbMKBK2VsXNQfrugAwAUR +JAWEGQBYkEGYAYPgwgiRcOAGJ1UU4sFQRugARiQplAFAHUMHIMAWCgQCNSk5eF0Uy05D7UkiCKg5 +sFIDuBDSSD3/HPTXRxHQQNdKZFqwUwwlcADNDTiwaeASL55UwCUhTlQBVThcFAoyqJzVGTEshcIJ +SBWAtFWWY/8eAN92HzX6Umd4TpQAl8u9gNBIMST7UAy1sITVlWhBu95F7fEIHaAnDWbAwxdVAAsq +JFXEGBeV3sDp0MOgMhVi+EA6m3EjNYQVEpj+tu68x+47USJ4D8QU0j9MsVICNLF5UYMXDj3kiELM +eP70MvV4Uc1DToE8VIFsbjAb2ijgAhvcgCh6mMlQKHAFBQYggE7zAxdM0QHsDaUAJeCEHBbhieUZ +pWgfyAQGjGIEKMDghEMJAg0k4IEamAEQp3iDKy5xgAHAwhM5IIJLPtExKuggEDX8WQ/ox7dFSCIS +UZuaKxiACZ19QCVI+YECiPAApLRBBz0Y2hNckIQ+HKV3R/n/QQmyeLziKa4LVkiCEwwQthw4goVH +iYIJqAc2LHTAEQqpWQ+0MJTzES4AqdMexNBQBgfgJHrhkx/5jiIALMxhaFHIoKQUV4MpkI0LbigD +CyCykAUMsn6Ja5/+TqktxZUEBjOYwQWrAIO3QfCMRTnfHP6WPru5cAVQ8IHVegk2DUiQKEWIg8kC +ADoNLgUNpjBB1/qgsi3EgXgIRNsPRkAHpICPKBCIgy+J4sIVTk9lkXwIUUBghVEehQKz4FoHCgHI +1m0hL3tUyBgf2bo8tOBracQS/gjANYu8QilWjGVRvujMJHyCjgwDABEwAbVm9uALcAsYFQxBxW0a +hYxG8cI0/x/oghKQIFKKO8oEKmC3+RnOfofCHyol5jgFsLKVrBvKSdUZTAZkEZkPiSThsFAHJTAk +YQE4qU8YIMIC6BQqAvhBDggywQQuMArmHEoNUKGAd+pNox/xSQfEyTeWKnWnocRpUr4YAkV+LAkq +qN4d9rlRfIZyopELnRpNWRSnOiJ8NVjAFI3CMhuMlCgy7MHMFhILmb7tpM8j5hgod1e8DmULgiWK +Rh1ZO3DSoA4c6GzOdABV9jVlD5xw5lzeplJSsk+yL81fTFlaFArgobLms0ILdhDIdHLhESYL5w8Y +IMaoDvNzS4UKCGIXhqF0QQ18kMUUFFnFj0JPesX8pjYPh/+84paVfkzh20X6V5S4QDaUmdWhS87L +CTggIgXlY5K+bsrdolbADgoLwBBMwVajfES7YLuCSCeIhwsklyhbsKvS1GWQ87qEhz4EImZ9d7A5 +kGADFKZwQbPnJ8XpQXlEOWlKRYlE7K62tSTe31LAi5TjdiARp+ACK3Lwx6K0QQwWqVoAtuBMPA5F +xYnwgytZwYi/IZO/G8XD2jjAijuEsSgpBAAf6PeRQpxiBu2EawCOywJMuOEUcBQbDWfwBjdQIqMi +3qB2U1sUhj00ogqI8dzeOWUurEIBhbAnylziSa2NgqJH6eeVAmZFQHzCDza8AxEWKAAmmMCHCk5B +FtFgBjn/YMLHbgDFxlTGxhE44g3tvHRFS1qUy955ayzQM0ULMAIqxvYKqRbtUq7WA1XYUAdC+PAo +w1rKEpPYpU1BAYVrepX3bSB+UxE2sVdN26KsYdhIed+xh7Ls14XG1zIAduuasAFpt8qly96AtZ/i +a2Yn5QzZxnBkGQfq92k7VrzWNbzaXSNpEs/dLQI1ubZnL3v/Ct70Phe/V7SGZ/dbK/+2Fr7npW9f +FXzg3Fo4w1ua8Hw5HFoR19XEH/6si2N8VRXP1sHfzdplaXzjxRo5yT+9uI+/q+O0MvnJd+Xyl/uT +5dNSucBCjqyYy5zdp+q5z3++nJ3nG+hEL7rRVSN0hNM8/+li0jnMnf70dC2d6RafOtX/bHWRQ73q +Usf51Zm19a+zKOw8z7rWuy72e5s97bxau7BsDjCvv93tbL8k3es+9rs/Xe9RBxfZ8W6nvwO+WXy/ +Fdz9LfekHIyoAWDYeP8k+MGvKaYXS4zGOOYxkIksBSQ7ZlVQ5uCVtexlKYjZYWt2s5ztLJtgY0LI +NOEJIYSAarm1wHo5oQCe3ZUpTFtbE2kfgKtlbWtd+1rYxla2s7V3bnVr5IEDl+jXx372No4+IWAv +e+CHum9BBVziZwfileZa8hRXpQLEOjnUrfsqmuPct5Fp4KkU0nDrI8r8kbK6orjO3LaT64OJcju5 +s05XYP9JSIEENDBcVmI88Zc8InQUzfM8l8U3OjYU3fM9jDR57QZBBTiAHJhbEpBLznc/cudscXVr +ZQZx30d+qvJa/jMGACRABGRAQ4NAw9VAowRBEkRBkWBBGKRMHORBIOSAREFCJoRCKkRHLgRDMkRD +NoRDOsRgPxREQ1REXBRiSsREUlMITxRFO6NqRmFFWKRFXORFYBRcY4QHVXUU6XNbu7cUbORGXSZH +dGQUdoRHkVRPpWMGMUYUiKRIl/V833cwalhkhBhJkxQAlWRdrqYUmbRJnfRJ/XeCsAV5hbeChhRy +q9RKr2RQs0RWAWBLuKQ+b7NLwBR8wPQRCVhMx5RM/Nf/h830TNEkXdU0NNfEekZxWd20iOF0QhNI +TlighuhkVkTBTu4ET/o3TwCQh7PjAn+FFEVjZTPndQAVEj0wUElRUM6HUACgUHR4UWRWf9KYeHPj +jGPUjF8IF7MYUoPFiE/hYagVfqo1gip4iaESUzM1A8AGX/qnAcVVAD2FBT8VVEOlMEbVE0hlZp/I +FE31VLlTg1OlhleVVYWwVRgYTF4FVig4VgAYj0uBVmp1BWzlVtE4FD/ARXy2UVdgAcrkhgQlR3zl +V+gYWOwYAIV1WAOQWAZFWewIiOfmFCZJV1V0kkbhQpzlWT8TWiM4WqW1E7YWYpSYYZZYj01nflAJ +YMkG/4q2hVtZmQC71Vs0AAO/FVwPqRQbaVzIpVzM5VzQVUbSdVnVpRS4Fjln1pFL4V0egGJDIV5E +sQd7eFj6xQRxsFcZyFr72GHzVV/3lV/8yF8C4F8kkGAKFoWh55NL0ZeGlRSX+ZcAiAcSVmEWJlOu +aEhMsWEO+I7bJX4jNpUlV5VKwWMt9mJ8OBQzVmOTlWOYw2M+5mJBlpByY2RPg2RKdoan6GRQpgFS +RmVlYGVYpmVcdnxfFmZjlpq9KYnxtTANsGZuYAptBkhvhpxyRmcKcT4hEAiNlgKAdDVO02gLJY1M +EWiDVmiH1nqLZp6PFmmTNgOV5ml7Y5FUGTjjWZ6NBv9IAGqegIRq6DhBrIaggRdysCZrP1Nr8DiJ +47ea+2Z24fZ+xYZtAvcUxoYUOUiT0CZu+gU/RxFtolkV1PZ+wrZ+osJtv0YV4cahKUiPDed16oai +3lejFaqaYSJvUxl5qXJ4aod2PKpwUjkfAbeaQeqiTNqkRWqkVbejUfokSLptTmqPU+oqWEqlNcKl +XXocX0pSYjqmUAqmV6qlZ/ogZLpaaZpxbiqkVqqmNsKmc1orchqneBqnZmqnmnJ0fwqogYoWfZqn +hCokdUqj6AanTbqohupeeuqowYGoozKplMqnkTqPmEqnkOqnlVqJl6qpldiooeodnsqgnNqpoEqq +HDf/qqsapqhqd7Bqd6rqqoRZqx9iqqzaqhZKq7f6fEyBBp3AFyuwCdcIIMVoAh2ACJ8ggg7SBazw +GGwQCTdBWKTgF8rKZcRICzzkUJlgT/r1A3cxnApYUj4TUDfzrTUJrQAgrZtpELjHro6wmUPxBDpj +As9BmZXZFMG6Akb4QNuaF0TgrbPDCv1Kh+04Fakll5nqq6fKP+dnWWZAS/MxY6cjAG8wr1LRk6UR +SdhEFH/wBlUDQcBlWVNAVAIwC6fAQjXDYavWAqQQf+QacnHBlsf1XwFwBAO7Ei6QVh2DBGbABwIo +AJJDOXOzmLr6FF5gCClgkSirsjRjBi3bOkxgA54w/wLzljhXobAoSKm72rAS0oLcJFMsZBAZE6+H +JQJq0FjBpwNsCReGcEzFGBKCRkdR0AKvEAs5EIlgWAVuS2CECEG3FABowJQCiwEgsAqKgRj+Srgm +IWkoCQSP4ASEawKa9gUGwTUC26wAJrWxhQc3W5MvZGP6pQHxd1wX4Wcy654ZpDJzMwcDdhQlYTeZ +FJQB8AOzeAUCJqo4JwB6MAc3sLFD8RExO2MZEGGwi7BIUQOxBwD42rrxuLAp+LWs+rD2g2UiZD11 +RhRWZDc/UIAMAQA3OwFqWzXW4wAs5Lr8xI3jCoY6QJ7Mek4LgIhDUUxJ8wOda1n9uVx2EE+265YN +4P9p5+NQg3UEDbC28nMFlTut2fMDdyBpZVAH7FuySSlD4pS6TgIxNQAKyuoJcpAJm3tlC0CytnMF +CgAIKXAHx2hTFdADUWMSbOAI/RuITIFALTAzwVs6U5CUAfCzukQDPVBfyWsUFDADdJRCeLS1Vkm9 +04uJD7sTHmxP6NSGrXMFS8UQMgMXNqAK3vM2evBfDGEDOONZrCBdZrmQEql7uVQ1vFiTVqBpr0A6 +lwU6juBZUIOB0WvGaIYUKMAFXIM2K3EFgvkGc1YHIQo2YmNQVqMD83bBTRIwKHsHgeAHs+DAmIeL +ZkCSaAAKRPAJfbxifOZd/YtAhCiOS3E+MER/zXr/fIkMUt1Hvy+YoxX1FGuwiS8koU9JoUzsn9Wb +FGk7xcL7mENxBGQAA+hEPR6VBukDXcf1y31GZLxnBTfrUT5wMM1sXz/zx3JMytsnVnQ5jEgxzAlz +xHSEh4u4Bwa8mQ3lE62Gdax1PjbMZFCwtkOwAEfbeoR4PrqbtjiVl6WseHgAFBJAR+eMmXVoWjyB +v5+6FAXcA63gOaeZxLmsyy2ZFP1cFFEAS43kVGyZaAzgCborW0TACb9sReerf3OpkLG1Eb/TAIwX +SQzQCSMcAGeAOfXbQj88ujLEv0ahMnjszdZpXxzwrdH3FjO2thBUVX0Jz03RyI/qzmrwu0VhPXh0 +/18MAEr6hwUrWRRIoAZTvAWsq1xW8MczDBWXpdQZOz0H+7NLDXFLkWhSe85OOZ3SO9G7fGIK8HhF +MQQvFhIwLMNFpQZplb/4+wSxIBnP8cEbBLrKa60hoVVGcVxu8TsBRZ6+swfuBF2YOxkxbDiQlcd4 +8M20AK8A8LhEUdh3MBmYYE8C3BOvixRRwM7t6da0EFBHkwjGp2g9YVc1sJ0h4bxpg1XNSwjZ+mnf +xzACnVs+8brH5cpGMWPi1NZuvQWoTZ6qsAAfRl+dLdF1rbpiIhsHLHm5SidDKnW9yt1t57UBclzz +e4nijYnpzXV+J6vnbRzuTd/3At8tZ98ZaN737Wyl8+3fSrHf/pnf+t3fAa4iA87dCq6vBFPgXYvg +jgzgET4pE56oKffgokrhQ8LgE93h7ZzhV3rgG84hgmriJ47iPkHiK87iLe7iLw7jMS7jM07jNW7j +N47jOa7jO87jPe7jPw7kQS7kQ94tAQEAOw== +--=_related 005C1243C12580DD_= +Content-Type: image/gif +Content-ID: <_1_0B4E420C0B4E3DD0005C1243C12580DD> +Content-Transfer-Encoding: base64 + +R0lGODlh7QMuAucAAP///wAAAOgYIPj44Pj48OD4+Kjg+PjgqAAAYAAAQAAAGBgAAFio4AAAIPD4 ++IggAPj4yEAAAFgAACAAAPjIiAAgiKhYIMj4+OCoYPj46MiIQABYqIjI8AAAKCCIyAAYeLjw+Lhw +MHAYAPC4eBhwuAAAMHC46PjwuAAASNiYUGAYAFgYAIjI6PjYmABAiMjw+HBAGAAAUECIyABAmJhA +GJjY8Pj40Nj4+KhgKMjg+OCoaECY0IhAGPjwyBhgqGCo4PDIiMiISAAYaBhYiIhYKNjw+AAYWABA +gLjg+ABAcPDYuJhwQLjY8LDI4Pjw2Hi44Pjw0PjgyEB4uKiwyEBwmJhYKPDQoODIsPjguFiIoMiw +mIiosHCYqHhAGLh4QNCYYKiIWKDI4KjY8AAYYBhYoNDw+EBwoABAeJjQ8KioiKi42MiIWHCo0Jio +uOC4gEBwqNi4mODIoBhYkHCgyMioiIjI4PjgwNi4qLCYcLiomFiY0PDYqKiYcNi4sODIkNi4iBhA +QBhYWCBwcCCAmEA4GFhYKFhwaHBoMHCIcICAWIggQIiIwJh4oJjQwLCIkLjguAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAA7QMuAkAI/wABCBxI +sKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bN +mzhz6tzJs6fPn0CDCh1KtKjRo0iTKlUpoGnTpVBFOn1qMECAqEWtYt0qVCvXrxy9gh1bdKoAsmgf +BjB7UGxCChOsJuBAsEUEqwE8CByxwKoCGQ4M8vW7Y+ABCVZLmBCIwWoMRH0VAyCQAu8HEAMJaMBb +4cJCCA/w6h1ogwbeGTcGgpZLt6LbkZo5exZIGe9cACdE4HXxwmDu06kFHk68GEDjAI8jL65t9bLq +0FZHK4TLuu7dAAoKP68ucTgCAy9fd/+kHuD2QLui9/bFDljw+uwDB1jASyLwcAVUdAeoDwB9AMkD +kWdeQrFZ1VlmlTlWw3nXxRCGFkTIxQUTJYk302rREVSabAAMxl5gBXkI30DHBeCcfFadEaGJmG1o +FX8CCdgagZsZONtkCSK3oEIHqICXDwXoxFZEBQZwIG053pZBCHihwIJBS+IVw47GWYYZigGo2FyL +pr0IIgAY5sWQjNYRtlCPPwbJI2LfdbTWVG1dtRCZC2UQBF4BGLFFkATAAQOeqBX0G55TDuShlQUV +eWRCYUoHxHUBCAEebRpQ0UYO8Wnx55YNWQiSojcm9CheHWSBKQBKLEEolQMNKiWVh3L/SlCjY8ZV +Xmt24glkZpVemummLK4ZQJsueaoRnQrlipeefPoJaHADRYnniLjphxeABCGLEKgC9cADqT8Q5GoS +YUymA6QwgmQsTLTWeeeye07mLHDu4RlAoABIi2e6Mdo64LY1Gjmbt+AepC+2PA0JEbcLEYzXEE0I +5AQekFJr6Hr05sukvfyCCZ2Yc/qL67tW7VrQwcU55N2kG73pVJxp8bRuzDSbNHPNON+M884rKcxz +zS5TVZDOP6NEdNFIU3R00lstzfTTGZkl9dRUV2311VhnrfXWXHft9ddbw6yQXYUKKsK/BB1GrELy +NcDAQbkhzNi90DIEmtsQtf22byLI/10lvgo5DRLZrAqUG9qGSbB2QnrD3XfKJNL90N17O9T42BGg +FmXH4cn5EVxlk0YD3p89QLrG+30pnAShAxzABmo21BjsDz16BBKgIS6QXZozyblHgpsEeuGlnc6o +6ZXT+HrsBc3O/ENqs0zkZrT3u/hk1D9PU/ALxQb47hFcb1Bs1U83gfgCXR6R+iorLj1Bzh9Um3PA +e44Q97X9DkD0DLHf6uMGacz3KMIX+hXEf4YDYPMktxDumSR/qkub+/pnAeP9z28CrBsBF2BAgiAw +gfayl99Y4sCFoEg68BPYAdewgAQ8ASGbi+BhWoeQw+gOIfFTXgjtdSRX7XCELbPfTP9OeJDGLCp9 +LHRhdyRwwxxGhH8O8cMKFCAF7VnvfQKhHE5KWEMmzig+80GhQKRIRSuyLYwI+SAFLcgQKAZwefKr +TAeD2EAhQk0lXLzjHfOox6DwsY+ArIodAxmVmf2RkGoZJCIXOZBDMvImjnwk1CIpSZgYUpEXhJx6 +OhimYWGRUnhiIyjxIsqGaHEiuTldlMQYQ4ZQcoNzbOUorVJKj+EJfbbECy4nEqXyweV6RHxOLWXy +yiseEI11YlL5+HLEDnEQMwbRwQJ8kLsvNsSNrivf6hBXminFTZPqwuRLfvm+YCoklcljZqicOceD +8GWXBsEmQ6RJzQeg7ZTWuWFMKEn/vufZ0JruXAA8wfevIgVgmApxYkTeKT2FGkYFf4mgRi5ZEbu0 +c3UDBYAaPVjB5GWEnOP7QgtfGE8vGgQuFx2aOGMCwYNsVIIZladErDDFKkLJdxGszQAPAtJ9rrQi +skQQAwtC0zIaxJzPkYxBd6jCa07wnArUEA2opa8dpnSiP11JUJE01MyIVIlHReasHjBCKFQhALeb +iEwJstQdHgmfBNnqTCj5TYOUxmIDMStakQCRDYkRjAhNiEMVote0FhGOjgPiRShaSZEUs7FNyypk +gfLYyQJNspbVCWMzGxbMcnZnlf2szTwrWj2GtrThrGMyA8AbghCMX53EpUFLCQcx/0RzATRcSG1v +S0NpjgENpQtsQk7rkNxElCCPQthsPTrWW35SozgIABnKYJF+9i+60+1ewA7KXJ9+hC9OiuudUoqF +LqAAERNoZm46EC7RHbdhPAhv+z4AhvcKpDRjSERTs/gxTyIEriQhrlolIN+HImy3BZFm69bb3vtO +tT2g1OaAM7o/FXRADxLN1vne10szetcjjWktQaRpQCy0QYYQ1Y5AomQyHLG2NwNB8IhxW7gzCpcg +bojAGVT118Hu4U8irp9qG3IFVVllCFM4HEAx+lyOBpYAXyUpR0MoYdpE+aQb5ptiudpMsclkAJqy +SqmaoE6XdtSp4rNuiJ65OnsF1v8u5lEzQQoIzWPeOCWPjQLFrKKnHDBpNKDJroaPCGCPlZJwh7XX +2g7TQ91Qy4jrTByFhdrljAhYIo+aIxlVnKgrF6TQhTYInGdUIl2ybK1jZaMse5pgNkOStA3JFb8G +wMLcCqSoNmVr9hK165COtKRurtxLAUCBC6suNj1GrF2nymk6Bg7WqPVytJ926Wl31tqNrTa2LbLZ +bUdE295+dbh9Au5x+xHa5h7tkHnkoyFQCFURkpT8nDXQVHEXhwFAspri8Cd5Tw55dgM4fPP9bn4H +oMXPlgma3C0QJcT7k336Ey4bo2+BGNzfBbH3nT8t8ITiRw2BGQAdVnBwM9rFCIX/SF1NiinNUhVh +Mn8gOcKJSvL9rvhORnhCYKKgKowDgGAQkxjF7NtGxEQKi9K0ERgTMCGBRAEMC2AvxzeOkXLHGufx +iviLl950ADw96g2eW8UBcPFPTuwuVZadshmi8e6mL7qlejcArgD1tc8V3QMPOgDObl/5MP3dX5c6 +ciPgco1+gfBhN7TbITLYg5Q3AEmYQrOkPLfygdnIhv1It9PIQqaWEtVOXrxB7J15LOEp7a79lv4G +8loQsTpAE7C1Sr/c+R1+/qkNIT1fzSxK0+MF9axXfYY16oUAFFhcIlhwVC2J94XYYUU7bJOdjAp7 +Qnf8OdQqL1jB/CdjJy7YiTuS/zSHAAP6QTohjw/ywFfP7eaLZABeoH6RrSJox3dh62xXVebfmPZS +W2Vtjcc4Z1ZSsicz7ocQ2kdS3BcA3oeA96d+cgZKO1UQrZc+82Ev5ROAEfY8AxBdgBOAKMJ+SrNS +OuMhTBcx/9VfeHJEbcUdA3EFaVBz+SZ5EkEAfRCDD0ODiXKDMjh2BuEEOAh5bfByDmF1ASUhKHgQ +nbSC6wSDPaiDusZU+iQ/PJiDz7OE9qIkIYBXa1aAJ1FM+pIEvuIQcFFpBHAHK/J3CBEFQThmS1Rp +kbMo5MFUi2KDQTiDHmZpB/h+EGKFBTGHbhUqTuiHWMZUf5VQTOWCLXgrCKEEaf8ALGIod+IGEmxY +c274h7ZCh+ukBHX3cRJlh0+Yh/iWiGhTiVYRedrjf9hhKafiWCSYiLAYi7I4i7RYi7Z4i7iYi7q4 +i7zYi774i8AYjMI4jMRYjMZ4jMiYjMq4jMzYjM74jNAYjdLYjOumED8WQr/FbhnVgaWEhRziEN6o +dAPxePayf7kUiK60hxpxjfaSjQnRIxMnhZRXJTsEVv+WiIsSjjYnOgpiE8UEBUaGJw2YEEnXZfAX +QvY4EOyIJ+4IPUbHOYNyRIBoL2JEjnhijteGEwuJFwrwBkRogTtEfZFTj/PYasCHiKRIakyFkRpV +eyFELlukjgaxkX7hkezGiAb/kWP2IpK0cS4IyQbDZ2awuCgAuUNnYFspxFQd+ZGa94rztAAKYAan +coaqcnvbOID9E2bHJxELWGCv1y/61JVPko4yIU1ROZV3UJVuB3qzxHRMGYUS8pZcqZVjmUZ0eTJb +yGl0dncfgSYw2XB8gHZq0oGC1y/Wx0arIR1mKZW0kZb31j4HUhooUAcpIHjnlxB6dhdB9pXENgFT +6Boy6RE8x3R1B3nlciYQBWHjEzBuiYgnKViwGJbRpX6cSW6hSRCjyQWl+ZcDQU+xU01RKGGxcUT8 +JoYrcpZ5c4GaGB+HRwVBmABz8DwgOB+vORGbN4ocyZgGEY4suF14MiC+hydy/9CKDRGeeDGeBkFT +IbR/5mkV6Nkpt2kR/oec26mC33iO9nKUzWWUSGk5ymkv7wmSOxSgzjSBqGOgRhOfbYYnvBkyXaZX +WViS86mdEMFokZZCizIcIdQBMqA96lmOu9eUOaGTO2mTsDeUsxGO+omJhsh4sdka+oiTeRWQIaR3 +/qigAECi02Kix4M4UIYxfpFr8VF8PxmUYYWi43h/IbSiI7lDhRcSlzSNUjqlVFqlVnqlWJqlWrql +XNqlXvqlYBqmYjqM1ZhuZWqmaWGEaEqWa2paONqmI3imBWEXfgMaXMhkayR6rYagKWgvfdYQ0vQ9 +nFmbswcT81NnsGdrw4anPP+ViUcGhQ6xVJfIK3YnZ0v4p9sjk3QKTnbKaT+6K8iGieLTU4dTB455 +ZCAXEY2hFz3iHN5yGUhloR0oGXYiGZcpOmVTV0J2Ez8KeTRIUz6HEBuSLoOaZZizZfwnire2Av5W +hqGiq13xpnAqEdfZEHo1czDVZIAlermCrZbjCJIoHBaWePlyJ96qHj7XI1t5P9KKETRVmGElXGt1 +AFsgl9IUrArhBjp3QNHVYizGPNIUZAMArvE0rnwpEtcqiqG6ZumqAsfHFw1ZrvindocIRiCzOnA4 +N0eyJHfKTohade1KERuifgDwKMdXVDyKEHzRsMf3owkAlPJpd2SYXuuUKwn/ORDPV50roabTShDV +2rMAwLNAWyEhO7RFWLRGq1lIm7TS1rRGK7RMm1pR2xJQO7V4tLRWKxA/C3viE2r7g3sCKEq5YgR1 +IFXwGnBU1y08IDdeC58s1Wsahj6L+rXog2gXEYEHYbcPMbdXW11wy7XPpYGSpq0FkWkfeyYS0Bl2 +IWJ2ASS3WiUeQBnHRRnshVQOVihytas28SgcGju1ca5CZUD/hGUGhLcSIbgAcFfNdhCqSxRVO61b +i5qKxZYWKEp8kVujdhFRslPqWpcOsbsa5LQ1QWKHW7t6yqhzGgFbWRsZ6xC3SyV2sbyVUWl8i2c4 +SrywWZ20G7Aw9oYXGoeh/7KqZ3SxHLu61YKs7XcTxrW6flUQj0egeHmxK4ZTDPG8D4G6d6WaBDUj +dnG2BAEFi6CsO4u1WRu7cPq6WauHCdy3C5ymBGy1BtymCNzAoEnBX/jAFszAGSy1w7VSevs/N0S7 +GoWVQrVTZQaO1zc+lWHCC9BoGNRV7MpSKxy8J2xnx0u3hBtXW6i/2iWzsbbDXwKtkcOnCYoRw1MQ +xXO8cvbBaqezJTVpJRsBtwOclPa9VIvBG3zBWczBMTwRLXUQIly9qUsD6NsQe6kQpYEtQjw3RBy0 +WPwQaQxOxotmhOst/nsRa6y2d3y+4JRBxOR+lquxkUZGQqrDKhecVoS6Xf8ET4vIhE71mSK6xZEl +yZrbxVE7wZTMppnsJm+8yZHsySArp0CLyaAsvKUcp6d8FKRspgacx2fMX87lOqTUXa88v4dsSins +HrFEv/yVto3UyXPmatHCy9gTSosXW5/0lYGsPE4sahHgc237x6mswDihzGLlQTjAXs5qyKxEzB14 +yxxRGvBaw5tUZ97yXjoVvJmKEp/7m7l8mbWMOukSzRaBTgzBvJHWTTWQx5wsyg1hUcWLw3m6MJUh +gg1BqEJl0Aj9yzvxxTZMxzcFzi7WxsHldvFcK1A8Equ8pqssV+mMny36tYiDUtCUxKvpwwvBz4EM +GiMkwtI8Epnrsc7shS7/ptDGujCe9hC5a8uJeFWL5ZRTu9HTLNSsDMzT/NNHjcodDMFGndSm7NRu +C9XnJtUQYcBRon4VuB2mhhAy1ps0hmNlWxA94ssG8ShBtlwquwA+F72+u9QxYVz6m1yQg9Z9utXu +cXy54tO8htIXg9fjhagrKz1sfbAk4S3yddXd+3PC19e+m9d1Jh9E980GHR/YRV0KEdjWsZUm67ub +rcU4cRhb2SNAlGM7Jr/oKtjK29Y9MpAcYdaJDYhpd6/SY8fkus4oYdh1CdqqrQJqLAJEJ9epdsNs +kwdv+c3fcwABzK9r19kDwdyfbMkLMX+PqmSLnMMuW5IJMawgYp5p99E2/9ZdxZpRCLyADJgFZNbC +Fzq3oJeZfLYFfnaxGjrLDLHTA8HeeeLefwa4WJbRrigSTEwQ0j2D1I2be3bf7y0d3iI3z8dA8U1L +e2O6ZxzeWNSB+AEDREe0OWG4BbFpMcLaC6vfojophdZK3G1F3u2aoujSHzYS/x3FmjZFzUbeY0bO +cdRUJX4QhRWi9yxHh0vhVGDhPFzJTw27TU3VWlvkQ0vURu6zSH7AQH3JTS7VSm5uU77kbmzlmgzd +NdRu7+ZwRzdvEhe4nqhRI1dyCfGhzZs3OACAYy5yMsc8QFdwfwK6TD4TLZcFL0cAMWfmo6eW3UNv +n/TNORcYTgB1e5xNov8o6Pta6GA3dcJ9xSvRI+WzcF3+cGnD5Q1n6cGXbyjId0G+EDmGH53uCBAH +6Ajh3Gp74RkJFJIeO5xrKg2nKsdH6Zn+5eNj6hyhA6cjH5c4AIfH5wKB6oqt6i+dEq3+UARX6z5n +uoR1VjLKEBjQ5mUOumi+Tuesv7lCsquu5S7lkuAHxmDLOMXn1zy5zRaLgWbEzwc07m1drDR95TKx +4EwltyT8juE+EFKUiNXT4I+ZEI5NEPnOVK+Z1cx3EhfdkkBqzPHh7QovEAmYPmE2kPxOOoXWIx0r +wkkn0VysEwefY4bF3hFLawkv3+COPqqISzF96xZeyDPmJQZo8MLsQQz/T/L+/tfBLsU6TsVcye7i +Ve40+44+EiwB9uSXvR4neDzLCcspaT5pnreprRAxijZAWHNiKJduHRNhOIYnXY/WxJ3Pqh/4AakQ +4YjQh6lm4xdUIPaZUYWPKsBFHBK1oe31Uh5ckIRzf/SY2YbmXRF01xeiroT2KY7f7K3fLPfUzKuV +YfgF0fftTZ4Xg4RIj45w/GBGqlFaUJqT+nbAjs0Ta9ufkviJndaQ34hpUPbujcuQrPRSuGTVFyqy +jRDStK5YVUdjWvu2f/u4n/u6v/u83/u+//vAH/y56M9EjuWdExKqiO4LOu+T0p40DwA0iR0pC+0r +qeMjXP2pp+rCvu00/5H8p+e5PpmFMEsQ0R+xt9XM5+55i4cmaLP92R76hM0Rzu/g/0ujeMGkPQkp +eFF/qh9CTQ8QAAQOFDgAR4AAHggKPCAB4UOECqQUGJghSAAXLxYC6MFDgQwHG0WOJAkAYUmTAVCu +ZNnS5UuYMWWiPDnT5k2cOXXu5NlzY02fIw0q2MFSx4IZN1YeUBGjhsgoSxJwAbMAYZIwOA1i1DgS +woOHSdSE9ArWadCRQNH2HFpUZBwYSdoQiWgmx8KjCuwKJHBnSYAGDEZiCLCBYk6mZ/Eu8HEYwNcE +HEpSmBAg6VqfajEDSPx044AvEaikWYEwwRzHALaePuwkD4wACAyQHP+gBTYKFi6ZCpnNV0PCyZUD +KKDChCSB30Q3D9T8U+Vy6NGjN5de3fp17DCp9zwhosOPlRlCBGi8csQC3ijdRIAY8U0Rl1/bt488 +kPL84e8JMv0u8ihuzLbLTqTu+itpAC/wS4ANsgYiDCK97troPvwUgum89F6CTDKCjsqQoK0yGnAl +AXXCsDeSsOgCvzPEWGgAC+hD7cUY8ZNDQpuQA44gHRVkcKCtyluIqY8a7KnElPBTckkmm3TySSij +lHJKKqu08koss9RySy679PJLMMMUc0wyyzTzTDTTVHNNNtt0M0uanhtxTjqdq/NOPPPUCUk9+/Rz +Jj7/FHRQQQMl9ND/QZE0FFFG42z0UUg3WzRSSgectFJMM33pUk07zUzOtED1VFNORzWV0FJPVRVQ +UVd1VdVUX5U1VEdnhTRWW3OdrlVde3UJV1+DvQ5YYWHllSBiiw3wWGWblZRZZ4tNNlpqc5q2WkoV +hRZb667l9tuUwG3W2+Xa2giKKoajogkACPiCMcdaiKAEEzb6Sjnf2usgC3Z1kpfelf6t178FjEhk +AREPJVdcVLddmOFft4V4YpEepvhPi3nqyECR5C2SIIu4Kgld8lJz4wkjVTtISJbcXWDBlBdyGWaU +mAJwoI4+LlTii0l1mOeeeco46FyHJrpOo492Nmmlh/256eWYhtpU/6mnrq5qq4sGOuuGa+X6yK2/ +HjdssXeGVDydH3sA34EISKGww+RVjKDu6svXsJ2AiOAIJDZs+Te8QVyZInlvTpTssvPUNvGdsGa8 +UccfFxpx7DYGTyTCKrhgo4bsPu5tEmLeqDuAV+qRSc0X8mMFiVL7DIeP9TbcbMkfXbx2myLHnfbd +Iae8d2V1B37T34c3/njkk1d+eeabd/556KOXfnrqq7f+euw3E2B77rv3/nvwwxd/fPLLN/989NNX +f332va+4eNyFzz4o+auvf37r3Md/rQD0X4hPCi0pbQCwQmmYlIAnEEReEXGLQM7zkNK16zcI+QAI +8sWkwAxEPk2a3f8Gl5Q6EsEPJqdb0uxIxqTWKZA9w2kgAB6IkAieroIC8aCSZGMf4TApYTQEC+o2 +R5KGxAZFlhIhSgKopAEWsEkIJIgNaPCQywikOxAJHQ5hODAAHBE/gSMhEkGykBNWCDr3K0kNlbRD +AhpwSUxs29sQMjfxQGSGPHxIFbOYQyVxcYIo/CJDHNKkGwrKfy7pIn5m57Im8a2ND4HjeB4yR7XV +kSxmnE8g7+ikHQYRkEPknEMs2bhBMkdiWpxPhk73yYE48SEgBMAUA+AUN57lgfR6ISQl2KTARRKJ +e1kIJdtjS5JUrZDzERKFMrgRtz3Ec60UwRtrEMunzNIEtbSgBnv/qKRjCoSUypxRL6+pJEgOU0kW +uloRg9MkU+4RlQJRJUJYGUcWLlA5riSBKyOoTTxWEkXivEpWeLTHDIFmhQFgJVrISBJfQsRAp+Qk +O5/ozh860CqWaWdS4FlBRwbAjvhkkiX5GQCsrOQoEekjoUL5NycJyYO5VOFDyOnCic6goje4KAgy +ulFdYlMwVlQSa1Ay0uGUtG17dNJLZdK/7r1vJRRaJkuUQBplcmEsJXFlAJr6IIgik6j4yaYHjYpI +hKSHAH1IA2weYoQt9Cti1TldQVfiGrpEhAptgA9Vm2kaDjkIIm7NqQ1RxNS8CiSMJWsXWc2KELSq +tWaebKjTNgNY/5g8VY1TmSpJ4IkQo2rSqoHl6ZL0uMqICkSJCOFYYatiGi4YZ1eD8mpkoYraypLk +hQQNLYwgYlSOMumzWSXIaANgoI4w0jOPOqnp9sjXkoz1tFdpg2plO1HagqhGmBVJQh9iScgSZLDl +Ca4zYxLEdeIEqdxTqv3Mub85HTR66kUvZtr3XvjGV77zpW99wVdelOzhsA8ZAxpKwpTwvggH2dyI +iuajSA19sz3INQiBF2Lg9iA4hHnS73z6+18VBFhwDiYIhCEi4ZZYl8ED3mlJ2jk3xZ13JFD4y3xa +tBCsRhgJn0kQfRK4nz+2J4UuifF8mrofFWyWJCcebtRUHBQWs//IRQTp8UNAzJkcQ2giJDkKS3UT +5fmQU7MQYWNn50OGMnQNLRXWsX4GsmVl3hhI05UxbUgsE9t+MLRnznBjAdDkhyjAzPx72k8XECG+ ++AUwJR6SBDS8Zg7fcZ2U+bFLanOb3IgERommzKIn0Oj/HfkmeeFlX/6SaCgfuiAWoPQELI1pljw6 +ALOTLqgBgLYWngeY6dX0i0IzGgP69EAHQeNXOCwf3F5SXc5tCZ6VmdejsMxvC4E1QWRdzWUNSqC4 +Nk033SyykVCIOMTeCGGs3BI0tyfYA/lPpL2sLxm4Tk8Wi8pUlhtSP7OaIB4Ui+hG7eoDsXk+yG1I +gL2t7lHDjX7/fUZJjwFtLwWD9p895axvnTxjR+v7ITeS2VaPvRCHI+TJway1TQzOS28qqaDibGrG +A7DxfCuJ4gtXUF7PE8WNxBHmIxqahyHyYmseMLCDNY2ab+kjew9G52V8wDJfrhSRyBzpAx+UzR+C +czqukUMk/xFBtrkjcGNZ3BdcEjmvbtWqY6zjAFjPfPRc1593/dzuQTvX6cPZlMs55/gpqLF/m4W2 +M70kb+J73/3+d8AHXvCDJ3zhDX94xCde8YtnfJi8hhLXmBWtef+MBUQtEAzg20GaR2jCFT6Qp8Y1 +AEOYAsAB4ITXyoXyHO+TEviwwiHEdjCcV43l7Szdy4/ENctF/yuONnKFFoOUrgiX+52SBvywDH8j +u59o70fSl7hOhdsj0RuqRxLu277INnKVvczcOPNnHQr5zF196B9CetNDH7XTL+xr96XYrDNp3AKp +Pmd9qXqFjV0121dX99tvwPcbiSsoq/MrvYKjPcwZOr4gKwDklwTUsbnyPT57PJFQJZaho3Hrt9tD +NEITClLrwPjwPJrBsLSptIaiDBSjlTuRl9LCp0abNBAUCQ1cCkPbwJcIka4gCCUQvSSIC3+aNxEM +O6TRP4HYwbDwwVTjtRz0NRC8lwZCEJ1ZtiuTPx75AwNSgECIAJAjCL2JojjCKYMiwpwwwqtAwqVQ +gbRhQoRjm/+RKLeXwD6XAhIviMKisz/PsyqfE7u1IAArjIgs3EIqWwB5i7okMEDa+MCZsDshC0RW ++zcP1Kigyx2CKwk48CdVQ7kzq8GVgMFNRMSYgJEAVA06KI0d2gpMJIjgGgLVggvCmjA8GYA8kJAo +wIMI2DFJ88TFurwZjImj6DKSCK6pqKsroAsJA0UHFEVSzMEhxAxg5AJhJEaIE4hezMOkuwgjQBkA +iIoA+JCysD4Z1ESU0BuQmqoBGMUd644UHIjuYMNPEZRmfMaTi0ZTjEbLskZs1EZuJJIpu4ldhAkp +5CEHm0X2uMB16zhxrDdktEV9ND0ckgtZpMUBarUYZAlHJMH/fSyJity/0zpFa5lE6WGv9ooJkHSe +kQxJsDHJMKTA9RJDlEzJlnTJlzyVkkye2yEJgVnDFsKxy+PElkimWRuht4GkuqkDQUOI2EsZM3K+ +ljgon4Q2HErH2qO9fnS2BaiAF3gN0soC9kuurQpFqrRKrLy7rby3iaSThVElMNSRmSugDKGMglJD +b8K3zoCJhtAcgwAYiwCYzJmzTAywpNwCCWxHQVGiqbgLdGlBkWhKa/q1B8imLvLKKxO1OPIA11uh +yVsIE9TBJbBFPQwKRCpEimBLGwSAm7wb19GRb+ORoHRKlOBJlHCZ8tAR3MrIhVCl+buJmnwJkiFI +nRxN1wSj/3SBupkgGeEUifO4sIq4iIQZAEeYPv64HJXUkwJCTA5kiamsiPEAM1T0CKEqiZNJmSBx +jDjSTpzhTtH5zRSTDpfhxmybALcqEOhUmYgEAL1hzzeUAOTSq/y8zoJoTs5RAercE5aUiWRitZwp +KeJcMpKAT8FJm+8UsFa0TnC0qw7QAyORHXPLTGa7iJ80vlpTJTSizwgwnJkRwpgbjws8CjRK0JtA +z578jdkUuIWoMPLUO9Yzr5i0nQFFr5nMUVbxUQGNzufpUSBFlh3dHyIt0rVSUkkUUhxaJ7jspJ3E +RZaoz9EEQs6L0uuTgB+jjA410jvRUCydSP4sCSv1QAREuP80XYjSVE18ebaC9EzAUTcxlcYF0E63 +rK0Ywa2viCC96YB0WyTeBCL8vAB5SRh5aYy9fM3VHNNuOVKYCK6VEwh5sU/vC4AvHYgzFbrUXAna +7MREcyJ21FG0+NNA5Yu3GVTVxFRoW9SF2ygtTUQZtckIgMpum9WFIB0sOsm9+x2muKdCm9I1Vcul +mwmlQ4ljfbXxMKovjESBSNJf3dVgvdKhsoxirU6eSNaCSBAjqIOSOLoThUQPtY6jyNQ7cqvzQNcF +mKN1zEkAsM0ry0/Mi64OW5FJdQlt5dU+ydd2eZuCMrB7fVFr5VSGxEhcBdWJZMH4BKNFKFiaq7V2 +3Qh4rdf/AAhYuhGBptLV8BgP8DPYTh2IwjE3VKXXOztYhkBDd20cj1xJJj2clhUvSH1ZfZXZJb1R +6klSJcXZ49FZmrWTnq1ZFaTVdKwbuPMjYZ3IWJWJpM1VEQDWkoW5pV3KmB0JuSkyKcLYog01agXI +slzMrlXTr1WbNJUXixoPMDTLD6WBUZ3MmAuC1slTkDHblGkIxaja0cHaeL2AEGAbg3AKV8UnUdNY +GBtYG9UTYmXTCLi8Oi0LV/vUYjPZEGvMEkumEPUdOSVckE3chtIbvvlHmAImGGEbJ7zUj6URzkNB +q3UiAnPcfmVVmAxaoBTXbzzaC1lX1pQJOGUmpyWMjt2I/9ztVUJJprM12q2dV3nVT76Mid99LqG8 +KyVxWiKyDnmZI+uKQ2WV3Uy01UUa3i1lJabYqL+1LLm92t3F3JnNk86BO9vCLTuAxpgIXyaDXE+V +389Yg5ehRoEImcpllIVJ38oDjo/ireWtPbaBXyjzRmw9RKyLX1ZiXcUsXPyaHp710QkGngr+2XDB +YJbIzY+cWg2O4A920hBOzxG2WdhNuvFAo+DCqRoKMBJaUxHdX8YNW5LQmx06ERUaRJ+tk3UUKr25 +pxcuyxa2s8WNCdR02DhiGcpVxqglYZ2IIxXmAexdiPU4g7/ALRzOXFY7CuT0uAAYBBpgNXkZArp4 +qYb4AP8wGCAnGoNEINk2+gg3sN0J/BPCCNFyhTZYzLutmLksptQRFVksaIO5RdmXYN0U6QIUQAT3 +nLOQ8UXQI4LSfdgSNmEQJonxG70pINotpV1GNd+Aa49ITibkSqaOLeIi3uE7UbW7a4J0TV4Xnd3i +nVgoaw/Okxe7OeKKo9+RPd5HDYpLJj1NzqIKNRLZxExTO8FjBtyGEtw4g4hcIgxyeiDFWF8cA6Ep +KmA3BlfsnOIg9ZOQwakBsF9bJZmNM+VkFokC4szam49n1uWvqFF8KqiGgF7+9eCbXVnoueCX1Of4 +sedJ3mB/7mARZh5+RsmClpyDftmEFhsOlsEgU8UipAv/SyUAOIANUVOCT5vIP80CCcHoVRPZlWji +TcQBSxLpgSbXBdgX+ODD0hhUj9Y8irbo2zMw0GwXOMDf45hTlqBpA6RonH5pGsYOYjkKlW6XPhxU +J6BFXY5pIaJLFYjkTAyrhgKqunsIgtwK6kKmtwmEFaBnwfSTVOyXpK7FkoIR6ROIKKiKFkzFVYSN +C8TlmzDkF0mQwizCLXCdrdgX57qC04Lq7Fjor2no+oUuWibTCT1EUFsPBBPIAOjiZn6ISF5hexNc +lpBsV7yT9l2S8HplKW0ouAaSg4giNNO8kJmjzy6I0L5WsuzMm8hsvyJYGsy9AV5nUD6MuvyhoxgC +GJij//CFZtTuAEOIgCqiZqrkYzmOtj9RETZStWE+ZGx7UmTW3vzl0Gp6bIRo50gu4qNQDLq1WlL9 +Z1SuZOOcqKmAPyAUudAiObjj6+YDTCNmwAIEuJB9Tfg2SkME6Dy5LId8PovDq5CjO76MgtS7b5cw +P8Ry75EQcAOq6VxuOSe2Cf1ug8Bcu6yeu31L77eR4aw73t5e4P+1EHT07m3u3Y4kFAXPSvP+Ojc+ +vdRTvoUw8ABQykJWQCDRgujjggkHPQJkrrEcV/DOtJNWHsBG0oC+5x/3kyHPGsHeCDKDiC526J18 +s8TUgYF6CHhmCRGLKAKg8i8LswdbkTbDbzzZ8ipHiP8r3zAaBrDGUkRdZjkHn1fdSg2ni8c4zYkk +czEF9SMFwenVaQ8NqzKH3VIqvL4g+7FwJuytE+oiP/Lw/vEl75A/6zRBA7UyNd0YXI1uirymnglV +MxxMbw2sDCRzRmD1+nSB0PTNplJCzT1zyQnkm0/QHtVRz1pF14lpey1dKwk3zDmlZOnnHly/7qRB +B4BkcwzPLcLggwiI/utFZ3QwdfYMpmShgxBAjLoLd/O3ky4ZCXQaUTkJtO5c7y01ejipzRNwt7Zq +fXMLX7A5Y1Avxo9uJRDvWFh0HneNo8dlzIk5DwDhDOCXOnQdu8jcyrL7HPbqqsOFYEUlKc5ygnY8 +SXL/q9GWxpt4iq94i794jM94jd94ju94j//4Kgny0wvLy8y33Mu8rq1Mo/S/kL7DFVf50fO/LL9s +PIH5ozxAGoaRQ7tk/HsJfvIcNs+lmfdxh4/2QeF5F6/HFT/1Fl+9Gg8+DRd2zeYk9bOq1OLCPyZ0 +Hc53n7Duwt4Ixrb6rbR5mXd5Xn7xNBA99JM0LXg9FE+u71NtCG702nwiggS2TfZNVfdjxGQ0Wic+ +Hws7hZ2QS8srXxpBkYeOwTfmF9x7WCYJMgQpMySk/j67cIyAWTt8E6W1on/WZi+JyO9BeKtXw4Fb +6CZ8xWgn/HjymOgIYE3a0QWZi+jBAO0Tqflm0XGC/+VKgEII98W3usJfd2XafKeG9UsiDvOmvwjw +wvGdY2kXiUosiO3jyEqXSKGIRbSGSIHvxFAsx2QEEezPRu1PDWPsF+//9ecfEFh8yFrcfuuP7cZ6 +R4EYRjp/3LUHAPofRBVVRhrp/lEEiAAuXgAoaPAgwoQKFzJMGCBAw4gSJ1KsaPEixowaNx58yPGj +xB48AiTgUqTgFSIBjiCJSGFChQsIRQYYwqRgHBgBfBRAqGNBhywnCfxZoUCGg4sHVKBg0TBDkABG +niSNsiSAEAMLD0hAoBUkWIkewyocgONo0oVQAyigchNAFDALEjw5OCBPjoJR8ERQIKWnwQEWgjYp +OP+AzgqBBCmaXdmyIQENbacAvnK1qcETImLUWKhZwQ6yHSE2fGj6NOrUqlezbu36NezYsmfTrm37 +Nu7cunfz7u37N/DgwocTL278OPLkypczb+78OeqIY0VTr2497PTr2rdz7+59Yvbv4seTFx2+PPr0 +6tdLJ83+PXzy5xHOP9giQgkTCSE8AL2161cTEZBCAB+A0JATfNEF0k8z3MCQYA0woNBLXiVUYYAM +1UfegAUeiNBLnJVlgYQTcWUhQjbQEAAJaRkUWQAOUgTjaYSluGKLCMEoIwAYXjgBiu9tSNZSIhp0 +X3779RcaACqy6GJBOz5YEBRVsEVFYQR8sQBPFY3/sEAFL+ShUwBBvWWQjyACmaFhONREBFryuRcf +QlYkVlJeVXbwg45bdgmjB2oGieaaBWUQQgAeKMFHBA8ZscVJHzU45UIYBLABYAottScQEWRFp4Zz +cldkZ3XeyUWeVez5IoEG/mgkAPyh9mheIDmZI0MEwAGDX5na5eYQcCLF3ZAAFLtQlTv5itCJbBqU +7BliNAQBI7UetJR/F63VpUQRTqjQl58atBRmYokKKgB2rrqQtyYCOOOW4lLkBlUINcbtQlouIG9B +4WZIrlPxHatRp/xKlCy++cab4X1xGrTWQBQdGgAZZRwkksMA+HstUwEb9FPEBnVarncDo9chyQVh +/zxsvhokmtDG43Z8kGYd6AHlyB5LHFXCDVmKaUTNohsqdwU7GyWBKQOwMpQJqctnYI6cKfO6FNmp +wBuR5ktHGAk1xmNBIC9WUM7aFWvy0Gl/hLbabbtd8rlvyz33aHTbfTd7bOO993hnx8034HUHPjjh +5hZ+uHp6I7744Ioz/rhFfrtUKEL8lajpuxUhqZ9PC1TcI0wyfSRSkhJtPq4ECXDwo6vtwQcj0IIe +3a5EQlf+wOUHwb5sri7HvpDl3+rue6bBv+04R522XlCaBxkP+qAFPQ9Apx3IkGmHPedKINgU2c6u +mzyJ3R3y6Sn/oaFRGVHHQSpW3bxB0zObOUhr4f/6FM+831vA+G6XT3AElgc9Z01vdyZSwRjQEKsH +qO4jp+vc514Sk4X8JCsAI9/fDIK8pZQOc9Gzixekwj6LSFB0GLkghEK4PoZMLFAHmdj9iOa2nwjQ +LiQSXkO+1y03xVAjX4IV+J4kkYl1bz3/q0j/KsJBzuVQBR38DJPatyIXSqRDITOIk6g4vw/KjGRl +284RvZNEhPywVPaJQAOb2MGE6BAjZskYRfiTrS567ItqC+NExnjANTKkjNNi4OoqMgAVjrAiJfTa +WVjGNDBmsCB4hBx6HgnJSX5HkpS8pCUvqclINnKTnlyI5D55vE6KspRwMyUqXZfKVYIqk6zEWyj/ +XykwUsqylhpxZUQOBceFfOmKDNEMyaSEkPtw0SLyYwj8wrYvrahol9XBpXZ0ybIFzhFplwLMfYBY +EM2kMSE/491GgKkzkUWAJfzp5q+UBYD7KG1o0PSMCFIWIjMWREWX61ARNQYmEx5zIyKhC6BmRDxm +qWBVVhybdWJpSyPScqEOBU9DR8eDqrEwfxIxGubQaRgLvMwiA1jDXOpyEcF09CDjWyQj5SYSih7E +UhOcn0YT0qEeGuSbH8Gojlzmmpe2KU52vGNEN4JTe3FUizUNAE8XoiI+8nIBNVzIS1wTUzamLpB0 +BADEEPrMTr7zoRD1KlhvGdSwEq6rZF2oWc+a/zeujlWta2urW9EK17jaLa10TaVd79o3tuqVWHPt +K17/CligDrawCsmrYc3G18SaR7CM1SRiH3udyEqWcZStLFgUilmxbvahl+0sSD4LWsCJdrQX0axp +KVLa1M6StXNbrWvlBtvYyrC2tFXlbUs529yC0rHlgYrDBAPHxuBqYr6kyf0MyBEstKFp2IoiAJjr +XBVUc2k8yBhK07Zb3mpwsdzt7Xc/ud3wOtK33mkmdA1COiYWxA4qKaJlTDOEKXDTqgy5TzcthZpi +Xu0vEekvOD+2gCRcxZeEJe9acYvg7i4Yk+Zt8FshzMrxche1CKawhMmC4e9uOMOn9PBeFdzgDv+D +eCMkzi2J9cua3xFAB41CTQLY0LQ9kOk0Ccwpa6bqPRWQxL4A4IpqFnSQn6ZPMQcu8YdtO+IHI1lI +TG7yV+f2xvQaJCdJaINK2GIGaylTAVuO0h2ukjuFxNeZDPkJvs7pY4X8pJ0HiWo+tftkKIO3NHNO +7InprNo76/mwfCZLzaCWwiDLGCEqfoiXuVyQQ59mhR9R8/BcQ8UKOqsxBqZTnlnrN+hwutOe/jSo +Qy3qUZO61KY+NapTrepVsxo4fX41rGMt61nTuta2vjWuc63rXfO6177+NbCDLexhE3s7Ajg2spOt +7GUzu9nOfja0oy3taVO72ta+NraVXextc7v/27XMNrjDLe5xk7vc5ma2n1ut7nWzu93ufje84y3v +eY9a2fS+93G07ZA/DzbTuPa3awE+bH1721gEF1xDoqqaR00tIUpIQ2IeUhI1NG1iDxGgkx6S1Psg +mkk0Yk3uZLUaWilppya0s3g+npohtEFrCXFCHrJ8pZYnxOIekqJpNv7ibImcNUFSuGrmy7ueryap +/uM36Ea+hYYj5OERJwkXKA6zBTxkjR2SuH0zHqMpAX01sVM5amyEoDxcxTRJ6Jpf20b0GmVB6gtx +umkm3jQAaMY0MeT4Q7R49QAYqeuq+bpOVSP2a0ngNcWEz8EFyhqWu1xHfZCL2dvA9Lo/5O4v/y4p +APZupLWn5ucTWDxl5mf4o5Us8eWViMLTqKsaX24tpnlUT1Z/Gh7ZnEdafwiPKD/Hjxu95HkPzBcu +z1OR63jPKQ/8SxN0eRR1yjRBqZUSyv4QWNV+Srff+jZF0PH4PcA0RqXQ53tsEKucRovEX7O7AnD4 +SiI99YGU/UNaH5XXbyH2u5o9pb40/VLtff+GQhTuUYr7RQTvmVBOxJ19/YTZhR4AJIgMYJDadd/v +FUT0nQbQuJ6j1F/m3Z9pgI3uRRHebV+/UB3fmdEAQgbyGWCNFV9maF8Ato3pVVEKFoTymQaK0IR8 +FUYD8oVpzNEHHsnlsUUU6V8Jcp/3oV74df8T+R1hRFAe9jEEkK1fRgRADB7LCRLF04nIx3GR1r3U +x2GKyJFAxjmIyFUT2KXG73BeavCLGj6E9QTYvh1fzomOE0DeCyrcmLEKAr5I4IGhBIrhimxdGUJX +G8YfDvmdaiRMIb5h0BSeFEKgdlxhUZiGFgYeFwYiUpmQwnkFjRgIgZTgx3UPIp5GkJxhalRN/62G +wWxVBDIhACiBzPnHFh5NF/KTBJZIVOUHx/mHwgHRKNpggJhi2AnaQjRf5c0dusQgAc5gA9oh9vXc +75yRK4ocLn6eLjYKL4YfEBViAIzZL56G9gzZ5dEUVakf6ZlYFZLSKE7GshChM7kjdO2dILj/YI5k +XBKQSXUVYET0XKA0BqJNU0TgXR7WmXcIY0noYAuaxqU5YffIIz0mhT3iY3rxIxJi3Y/x2EO42UII +JA6V4yOmXSSGH2qwIxmR4DuaZHrh3RgcwsUdyNXFAEu+4JslIfpFmsbJhAI+hC/tnQCp2EeaGNI9 +mgSmxpUpmjsC5AiKIBYFYgIYAtWVDsc1gCG8mDadYO/MIQDkpJHlyyeWCTG6jTKi4GocJELYXDvZ +HBBlXFM+JedE5VT6n/MM5ff9iEUuhWloZOZ1JUvlkCOe4y2lY0WK30TYiVSJlI505TEaoWkMpDAu +pvBQpHqNxD8mRWM+BEsY33fo48FYSWv0/4pCpOL9EN1AcqM5EopFktNdBkxlOkYjliZDbYdV/tfT +jaVhDlMQLg/YRSPziKTXAYZmYtX86eTY4KBqmFljteIESgRhtoaQJcTtrVHXfdA3PgTgYWWRKSRC ++WMA4GXahOVV3qSAbIlrXKZzYmIAQCdvfhBpet5pks3lpYx2cifmuKaGAWaGCVyt4adp6Seweaew +UWGypRu+DSiBFqiBHiiCJqiCGqi9LaiDwoZ9Shh/ytqEdlaF9tq5ZaiGbiiHdmi0+ZmHXeiriWhl +kaiumahhWdgLIcpxjUQMEV0xqdxAjiC/sNM47SPudORnBl436iiNMkwEyOfpvYdxIRRyQf8JjJKe +jPqoPtVokN7oH80ojjkmAabAUbiBU6FPa10HVyjNEh0EHEhL5wBRoElRxhzAIixLY+imz1yTR3lB +W4iAjg3IlWZpkqFLl47TlxpEmCbETwARmqqpm0Rj17GpuzyidBFUNSXTxBjqllKHpRgYDaFPonJM +NQ2AIyhaVi7AoCxpRtAOjpIi6dkUQtDYVrIiyjXEA8VldaHOI4LqTEon5UzE2pEchNwQ+MnqI+7W +qnJfqxZEG43IjCbTAFVErW6BptqQlNYTDRiJZjDVa2oHYeIJAOjJV35mq6BPP/XTi+yKZ1YEqUaE +tUoPICmEijirCEArdZzYtKJKtarKtcr/VLZChrf6V6W46QnRz0X0KvxE37cemWjoSwAkQejZySom +RK8qRAWSp7AyaUTA6qGOKr6WJ+ZpmHdFRHw9xHzV13+8Kq7+iK5+BUmhhqPqYe8BAMTuZsgaDp1k +bE3Ql5zWZLB6zcfKDsiKLEeRLBxa08mmrEF8SffAEDJyknacD0L4gVFQWZRsSXNy32jmaJXeHLAW +3mnkTrju6I3FZUwBLaVgFaKQo8WqjdEeBNL+auYxbW1G7VMt2sS2VOcFyMw2BIDdLJvZqZxVh/1A +yUctgDYZxNxSRMIGRs0SHmrkjs/yZTFdrZkqbWhdbEUgDBzGrbIyacwA68wwhtSwUUHF/yvKDu5B +VO5FCqmxBCVHQC4U6iu7eO7PLhPHiK5hZC5B7eVGzaguMe6XrG15QBPKjFN2QYuY/pIIUNQbsQwB +cA0iPeFEKG4clevDhIDZ3q6WrivpZsTuzsR1TZPvQobx2oubxBkAKG/EVhHTFhoyzerDRAXuOll1 +OImB2ZG+xNjQFoQVzAHv/Ck9Te6nqm4jJm7bFoSpfk5COe6CoSiUETCeTW/BnRYCI5mKhpcBM/AC +F3AEJ3CUUfDoitgAT3DBPXBhcTCtefBdNTCHabC3gXBfmXCsobBbibDl1sRbwCJWHI3sSWEFLisF +ipnD4qgNL1pbSN1hJEbC0IRN4IROhP9jHMbHTwTFUExiONZwDm+gTqzfDPvl6V5ZpKREDL+Q+mig +7PkSt7YSv60F7EHxqf6YBFgxSqgEv4hxvZDfwVIJZ7KgB1GxddWEDiqfmd2HERSCEEHi0IgxF9+f +L2FADyfFD6vT+UpFG18FvwhGSbxFXAAF53YsHSNEsgim0+IQFiKvO/GZEN8xX2SMI3MBJMuF8A5G +FujgAAQfIjcdDmsE+NrQI+uFKX9luA6AFpQdw6KqktHt7Uip5AruDnfuMAMP1GbEqnJFTL1E+jLY +eyhXrM6O/lLVIwbzRdyKi9CEHHDZfbDhMbfNO2kzN3sKHWPzRlXsAvHRUtwYpFmENVP/TwQwojX1 +DJ0yCfT6MbqI8xm98Rl1EEl9H3+oqx428xZV8kWyM/Nm8mG2cidbR/Vcjx4a8UBHb81ZVMPCcv/O +yLwelaM+K3uFbao2xN6uBjCj7kU/rP6OrAXubB2D7SBt5zgR6zyxLHy4l89JczG/88wCWdU6rBv0 +BVIO0rdmLAA3xJE+anUItb0StcUwxE/D0bYuiXvucjujTuEKzztjQRcIGS7rhM1AiWaQabp+NC+j +i1JXRtkVtdeEkNJEtdlGVxeU8fe+ratScadQdUKTax52sVZhGp9pNVdrgVffDENotVx/Zr0GmM+q +tGn8TiwXdlxfWiyTFNhyBAtDoROR/3Vdd8s04y9ZEFHXvrSjKUQLleXXxq8zt82kpm5OmzQ1G7RC +/LQ81xyiFFGHnOyKcnK04m1td21eZiJCyDZEN5XR3TNDVLX3uDbNiECrZtHq5pPQKlbagPZCJ5Vo +FxK47FNJ1pBhb/NGvLNCIPcCzeg/A2xYQBHFGlV3JyuOmu3hSsRjH8R6t6mhPtdkCXB2SxwXIKTv +pUZSGaR9AbhFEEAfQJx8MaBijqWPOYGBDyzNYSZ82FxRtoyC307RnVwb4rZM8ahqGBUuy5zQyVSB +P12IgzF3fPiBL8tqGhUB3EGWzbJEiHftUO1qGFUUNPjgee1b61PfYgcJC5IWgDiCk/8rc/pYi784 +KdMla2i46LHGXHKfRqlhjt/tddx4xE150i25CeGyHWJ55nH4HoJrke9ma/AUo80cex9nSEOYCi+Z +BdPHj7/5EVvwpj2ond85nue5nu85n/e5n+MbBl9YnG9bm8dVoevZoYfVZQOAqaJG1m6FCrwqDkjp +mVvmY4i5auxyYICUzsalltP0M7tYaqg19+Z0pPulTff0gIN5mB9EqlMp+BRz7v4ZFEif8xF2Qyhg +7700jNUmY6eGrJtxYiIE5eH2UhRTITI5ULZNratGtBjaamg6yoZQr09pkNXkfDp5QiDtfmXIN5I6 +ukBTo58G1rgcT1d7Qvz0SNrrUWX/+qVPxK+jBm774/dVOqJlTUqtuUJk0/3SXcxSMmcH+3g/Ma1+ +Mz75dnh/M0bs1sFPXc92NuFd4o4rXsky68TTrMCLhyuhF22jM3D9xSE1bx+jTo8vt+tObUw4bxSZ +BWe41MlFPOl98X2rzUxL0TBPT3QTHqxAs0a8M78jYfTwfLjfmTCdkRRCs3EL7sXLPMYTfGQClMvU +e0b/NkFzlr7XbaKB2SvPccA7Pcq6yaWNFNgjVFSVeB0ugHGirGDDdAWzR2MkAP3S4JjQp2fvr7PA +yODB8MmT2VU4DN6nskHoPZQSs9fLiXXY5dkFPqPgq1lQVMjrtY7KypNfZMnz5QSp/wgK1EEKrIvL +Azy8r/3eR86gP2zwUUGDwz1LWxpCRTU6H0SZISVftoYLyYqtbvIVfeNsN7R1WEVJ2GHiR0Sb6YzQ +w4iGq75H5eyFW668BBS0OypJVbzV97JGj3xBd71Ig1TTfir2p20LMhXTj2DVZ9pSaTbhh+/UPRWx +XoRHry76m68wF36Iicd9tA5pdlTOk3y/wzM/NyJPLcX9AASGABUuADB40OABCQgMIHT40OCIBR9A +QLR4EWKAABg5dvR4cYCFAB4gCiTocMCaBQmeWMwQIgAJBw4VxqjR8YSIEiY+AlDIkOPLmDMREtAQ +YEMBgxQmAH0I4UEDBj2pVrWo0f9qR4UJODwMOfKhnxUKpCiFKJEiSgsKdnhVyTIrgJBSOTLVeBev +Rq4HBSaFSCBFgLRxMWItvLGjQLwKzOSACDXv3ZMHjUbW29UgZMuXP2revPegHSKR4R78almOY4+G +Cbf2KhJvgjlmix61DPqg57yTD4qNfAQJVcWRjdSB6DsvcIeVb2N2/dwga+gIFeZNEuYjU94HoVQh +3fKhRCENCSvc/tBkwdwPNvM+HTn19IyI5dfH0sXyGTEIdZN2DqC77xwaLq/iqqpuM7BMUykvsmgD +wK7P2CCqPvmkq8+NCCJT4I0iKLMtQZIo+2KBBsvij70EcePoPcvOq01BhAjMq4P/LDysEKELH9IR +xx59/PEjHoEcksgijSRSyCOVXJLJuJJsEsoopZwyOvqovBLLIp8EIMEuvfwSzDDFHJPMMs08E800 +1VyTzTbdfBPOOOWck8467bwTzzz13JPPPv38c0+OtsySUB8HLRTRRK88VNFGHd3RykclnZRQRim9 +lMotGXUiDxg0MmKLG0GywCmOMKDLoijyWOIuUFWjqj+8eItVMvUOciKNFTRKog1RO7K0SE49DQBU +XyEKqdSHVGX10y1etejUqbKiVaPtlEhjNI2GmOLBhwDTaIYbEAXWKiX40DCAIdSg8KIMghjI1qLu +yDYBLpiwaAAthlWAinUPlCAA/5v+CgzeovrIVaMam3gsRRfjtTBSRK9gNgBejQWAgIN1DUDhVFdt +1VmOFPLLqhnzWlFGVDFSNVtit1i4UXKpynffftk1KGOEOc4CZoiUAKNEfv11iNqCPzI5tv8OuuJc +jVBgYcANqWjjWUMjdmjLnHYKb6KK1sMrWRjvUtkjG2iI0SOoyLZIbWnbhUnEg4SS6dermdSaJ4fQ +8jqzhgMImyOz0WZOo7V7ajuunAwHwGyb8C5UZo/2dmjum+XCoYMftHtYovMmx/gokg/aSmmMzHtE +hcEiWoCE9DqSKFnEj4y8SKbC/irui2AnDyPBc4dwArxEFw6pbv8CMYDFAWghgv/ML4JiEeMXtbu1 +yob3SQKUz1qg1JxQfnw95Ym/HiIduk6seIgOUEEBGSyHTlPqDRLch24h+330hXgfVXycbau3amnz +210SMCEU3caAS2nK/hQoMEHJ70j0sx978JcQ/XGEOQDEyFzcVhVaFfB91GGf+x4ChAiEyyCVyxLt +OMI85zmEKbi5z9MOsjkUGQ4qbCnKHzamgEBEoDH/OolEwpUTFLoOI+aj4QFJk0AcsbBISmhZEmBw +HY8oEWrH0wsXAhg18nkEaQQsnVwssLia3ARTB4EiRgjAQ434EIhdfAgWP5Q+GKGwbwgMIbS6tJdv +baYDemBXX6RHxqE8EYIsZJ7/6mhyQRaVsYMd+daLrGI7BkLEkhbUHlMYeRUIUmmRfGsk4NgYGEpy +sEKZXA6JSvMQoSSok1FaY1W+Rbei3UVEuHvKA7YGAPAhxGw6/Ih51POt8fDFaA4JkHKoosoKzbJH +KixKYPCIkGUGpyeTfBgyv4i+buILkhAJZlvSWCUc/fIg44TINUuSTP8dsi4L7AkhS2lHhDiTnhBB +J8Qe6BE4YEcu+goAMy3yk0u+ZnFQqRfMaBYAF7ygJyHpmFzooKuHmsYCEx1ARR0K0YP0gAfpuhcA +4uCp+q3mk0f6p0EaSlD1OZJoD1goSwV60WOF0yoS5RlLOWrTyw0UmxfJiQMf/5ITYU4JmsfKg2qi +gIcIOKgjNkSIu4j1hJlEgVXHPIgJK+avjY7lRMOUACWRyZv1QXWDGd0pRS3qUUQqCqQBqNeNrjAa +gp41rBdRKBcYWlO3osee4yskOMUXIH71zFwa+qaUkuoQribBqxVFq0/Yl9eLmLBGHhrAF5r3A4To +lKE9/as3Bzs6FYjUIFLsqIzsmS+gAfVH8SvnbFFKW9veliqNxe1unZRS3v4WuFzybXCJ29t+Fne2 +ukXucpE0XOY+t27Qla5tlTtd3srWuo+qbna5a5Xtdve23wXveF0jXvJSCrvnXaFz1dte77LXvcQ1 +b3zpO5/6cje9LoGJTwEQV/+6fe0upAQdXpQnu9YYWHcL0KpBmLfEvvXvuFMSCn/9yy7dCNgNxqGJ +CsiW4YesD8IxDTGCMZiC9rnhfJWCr+QW4GAAUDWWBpkhIiZwnpy8cH40aB9RJvzXCvdEIR8Aw46B +SYMxJMKdzkzwgpcXARfXZ76EEQh/AWA+1Q0gD8YaAA4CUE0AeHjDa4uQRhZ7kXxiBA77cYj5iPri +d7USIVIsM5S2O+XRWlmUpvECv0SAMqGcFGeB8WlIiGwaLv+3I6gUmQSevL5eGuTMB9mDp6jMz8O0 +MAKPXs9RR3lQtRR4gK6ySn9EfU95wvDUACB1yIK0YhwxT9N94zR1YMoRJzj/Fc4QuXUEct2RVQfw +1xZpHBr3iVRX9+5siH6nl62wAq1K9cGRVHVUpAXrvKFo1qYb6wW2vDV3bQ2JCszLtrqlZAUKuLzH +HhIBSFQxbgGg2UwWdrL3CIBd95q1c26nvr0VGNUVG73qvgi7S5SEd8ebgd15oUL/Y71uOZw73jks +xkgEaI8omiPNlisXAVQFHEM6sEVGm6UvwqiJ3WVb3hsj9tCN0RBP02gtInNpMWZK9ZgbeC2vuTs9 +SaiTa2sKKi9orTsiOGWLk94shY3waK7NEruTiOKSG0yOLkuBr8ypzcoB3PpGhjKgejsknvbafp6u +oPfZOSYrFTENkpMAHDXc/xfxXQ1TTXedGxdRVFV2ShbQZmt6x6WBS/q+jSdze0ZakqwED61jfanq +6p1dfBeYUcaAhpiuCOIwIhlIYy2aLksdQWNzG8YvG4FOioXTiE+njsn5zESuOEAW/zDRb7q4AThi +pCL8OItw/2EVfFw8+1ufg2+fe9PuvueKiv1gDfoYRgTwrK2HwPN9n22Q9H7DOC6+73H8EusD4HPG +NhLB5Y3JGj/sxp41dKEtsnyqsN3MyTxAqOao4P0FX4RPJjmhBEdlE7q42TjkYviD+jbs+wBA9cAo +5NbJO/QjKN5s8RBCNPhtSaqr/0br/7KIbWRKaf7sQczHp5iH/dxstS4Op/8GLjCeDKTYT/UmLQC8 +zmoi7L6aJMpm0Lpq0AbXKwd30PV48LnyywebKwiHMPmIELlw0Ajx6+qSUMVkkAnf6gmJEAmjUEuW +kArdawqvsEeAUAufIwu7EFO+EAx7cAypUAzLMN2c0CJcMC8qz3RU4O62zIwAJkHuDsAcxoK6JFnu +4zeCSg2jhAB0AF3wAgbxBQdebn0EbMwio4IsgnD8wyEyxEQmKEHIikmUiw3xwg03iMtGTsbwIzn8 +cEFKhOmIJwAaD/xIMXcQpOrcjudyTCP8DsqssEcy8S4E8LOWbjEs6xP7sJFuIwIVUEVWrspK5JQY +xDKsKFHOEA0Jgwsdgnn/ZFHoXioOT5DFKg0jxO4jJMKnik0gvKwIpeRbwDEVT8kaL6L5zM8O2Sh0 +aC78lI7TtLEJpyMa0QghphEhQIolKuN3vPHzAu0fXUMgPGCo7HF9wkUkVnHbQuCotswm4o7BTugG +pIkMC6UywJF57s6Z/JEcl6Md52kBXSIIHATadg4bJYUZmzErnnHNFoAxVIMA7oBVlCcd0+rlirEj +q6Kh9A8hzAcccS6GiFGNaNE1tkyuZsMghOVvDor00JH2UiXrTvIjTq7QMq+OLHEnNTBTiNJ8XhJn +ZDJ53GZ9FowfUQ1wglLcyC0pgWYETUVBmOehaOCYdCl/TsJsUKAOUuCF/+LO+1ovFWMsDRUFq+rl +tSoGoN5wBIFyArSnJ1tMK4XxMzBjyz6uJHEu4FTS8V4vLmophGqSf6SNct5F9qDjHVNINKWHI6Xu +0hzFbFCRjBDxKd8Gngjjl0qT0PwywQDzEonSEQPjvxaxOdpOJ64NmfCo2OSxnXJHBx6NLi3IrFQA +0cLNFTfDNZ2RN6eDdF7DEz0v8A4iNcMCrGgu/hbrljRCRKhKKh0lJTEztzQTfRYjiHapPeLlEZOG +cmBiNGdGF/EiPu4zAPLTITQuFFstS2RONoynPsUopuYzfyyjA2RAPFnLMgxklUjxFi3L8DSiP7FE +uWbEKyXpKCpIQPGiO/8972SCEX0aUenQBv74aDKiTr8CEn6uUz4ksUE6xNS6ZDtG9C5cKkHzQkUB +axgxoiS5g2IiYwh6BnJolD2hsOSYNArXs0mnZ0ovs0p9UEqv9EkfCFC61Eu/FEzDVEzHlEzL1EzP +FE3TVE3XlE3bFE7+UEvDMU6zK0vnVE7tNL7qFE/NaTU7QildZgBz0Q6jBevQpV6MrzMGSFbUI/Qs +o1SKxhKHslASS1uGxsxeDlk8DSGYBl14cuCQ52RWjlOd5jEH5CYr0AopNV0sdejmLFPbqUv4rTpk +cefcSTE6UnA8ERYPsCITpaHezma8RWMSZq10TWcsxltA1T6Ppo/GSFX/9oWEIIJlQEZJxwVK9/S9 +4NQ7h5NrGOnCPO0RE4raACtSRQw0y4YGPg45o+tKSpMiw/Vcpw1sPA3PXMMqL6JeMQh5TlVJ1shd +qY5dFrGbvpUqmKf8nLICUIeRJKJ1bHUkzAfRXqIE2CAhIYJ5wqU0t/BaCeNesYcx9YZ7eEcofudd +P7I1EnDDqvMgXEj91il6lnFjsbUnWHL1/pMSG9EzCStenaAwE6AQDtSDFFWunAgiOI8486iJ6k1S +r4RlHwItESpeaQ1w/shBBSmblPXtcBQgAclqay9qrc41mhbVPhZlpVZTHcv08kwrti0Vi0gEjshh +SaIvwU+HmtM0jwrg/2axUdqoh34oPjmCjuzukpiCqH4UF0FySJssQQoRe2h1UvR0T2m2I0Jp6Kpx +cTK2Hp/DMvP2IiwTa2LWXn3zfZqyci/pW8jHcw9nXHcOdevO5b6WzpiUM/loznJ2e3RT2ybDmHgn +7gayZgHNbqfTMqpu/7Kk2NTpIdhp9jZpAnA32kCyzDLykmQHecsJcvFUcg9ipQLKU7rTbBPtHE0T +WEcqCoAG38BJo0TL9zyVjNK3rWoLS7CMqZxqsqDWI2w3IU5rCEZKtdIzatQSAOoqABpNf/l3NE6S +dKm0KJfKIJrqqXjRi8QTfw8CBEfr/dg2/rbDd0clRmB0exzXC0E3K/8eK7LC07Tq1yLian8NoqRs +lrUAWIDZl/ASjcuMwKrsDWiezLCoALGahgL7VYRlVlv5VIg/t4ih63qxNYmPGFWZGGwPw02jWIqn +mIqr2IqvGIuzWIu3mIu72EyGOHKD2ImbeIyfuIy7a4njNHuxV4zPuArdmAbbGI7Fb47fuE9jlMJC +StkIVotET59EYARNSGV3CcKMKloNQpCJE/9W1slK1b6uxJDZJZHFpnDilY8/wl3a8lND0iMy+ZAX +OSJlmIxbQyEIWNOwoA1uJvqyr2s7N3ju4ofzZx1Zas+oAO2gkddQlIXnII7r+AbluIyz19p26fsm +OBcN51tiiXDt0df/Qo3VAFKZJ8CBFPPusjSZ1XaZvfZ+Y9MrcIBX+/guJopFvBk3qflsgRg6NE6D +FK5lMWKYUwhuVLVYMKJstc0O2blvvkcEXEaOetmXpSuNtXSNDaLsUu6WqfGcXzNef1VhOkc9DK/M +nM40BGpnmsChz21wXfeR45eiG3oBzBE27656aS0vQox5PnakBddpNTp2n8OETm8scBMhApAXxY4i +80161I53jBl0NnE9PtYrOCongSSg/7l4jbpXN5oq3K90wfdUmw35Ngj7dK+dIQKqqxqUKUuUiThR +rvozt7nlQCqqP8INbvizuCw/xbqqQZbJhs+RW7p6UvAxV/CQCQ6E/zDixloZADKQdiN09mYZRTBP +A5QRJdDar/UWqZmrqKt0oOd0sRN7SyE7toBZsoWwshE7ssf4sS87Ryj7jDebs2fWs5m4sdV4tEO7 +PVEbs1U7vE67iEtboF2btcF4tgm0tqlLtmV2jdcHtQBAtQ6WAODAU3ROCWbyXM0nszDGjQBUr1Y3 +iRYgufnWhcMHdjObSpDbRpRbVwC0uMMSg4R7KSGCqkBFKYKb0ix4k2NZhERnXRX4tq2zUcZ7C8ob +vKVSQM9DhUeqhfMzQybO3hwhoS8OB0plvG8YqwJgwdYH+UzoYDlUjnWAbDArC1Sju10Muz1EumWv +vcFIaGbiq6bbgv9K7cDHmnmMoBBmMwbvWB2n17k7zamlrWNzLsCfN72Nx5k23LoB0WRNjZQS+K8P +Kq42tMkaXIvUe6/T1ly1K7dfe8kfIsifxWAvyXxgsCSzE9UGYxxVsz6MNhc9ESo0zSjrZ8s0eUmP +BPKm6l0oNMdeKMZvvMXr450xQq37TZgydrWVGl+QMTJokptf1yJM1FHJA6Jp7scMAtAjQ+cKXcWl +5NDzosfDF6GPZc/C6ucYt1G9GyNgTG0Pws5TWI+VdnaaXLdF/bMm3Swq/evcrH4rU6OzeeykbZVB +ztE97TjffNqsL3BREnRv+iAyhJkcOAB8GgAafV45QtF1Gl+8YID/39oh7i0YC/IeuTXFcxzIVKA6 +eVrp+DVfW0Mohtogtl02vZ2rEwXcj7m6bbfbtXznyvV1+o6ZKXgB/NeVYELcQ/29WyON0305bI5I +z2+quO7f4elbqGzuDkQF2PeiEcLOsV0HgWTMDxlkZfGkhbIYnffF6F3dWUTZ1byZpNkePTjgiTeE +aTsVt6hamSgytuNH5eo/XqliqGYzhxXojMfleUWOcmZjzO6w9bTmYR6cQ3VB8fCztKBlAJgqrqVl +Sm3fS3DgZF7ny/ze8a5R8qXo3y2q/P0hcGVjkNUiruC1/LsqGozZ5YVe7MWeZ3wrfySYIP4ivJ4U +lX7q7sLmHdHp/40+UZsVIaZV6/6dVyUChOF70Zk86qF+8KsCtAt/3BGf2o04mEn93g+/SSG/8CUf +DWH7SilfsjG/GTX/vTm/CwfaFjVC2H1PwMIo8MLofIdOD5nyEOOVDwcUfq8kEAfxLhi3mxERDj0N +Co40YfQaRBPXIHY/MgLJcl6fREWRjqcjQ/1Y0oZFEy1PmXifY3x/9pPWKhrdcIy/R/0QPS2YrkF9 +Rh1F+CPDAUGiEytI+zXCewEAOQIM7S991i3CfK6n+7uZzN27Ppa/kq1J+gOg/AECgEACOiIEOIiQ +TBmBDCE8QAjxYIULDCtaFDjAQsSDCqQUsHhAwsYAHT8KzBAkgP+LFxd78FAgw8HFmTRrAjho82aA +nC0ixKhx8YSIBBxohkRgIKdFhw0YKGXqVGnOEQtW0szYdKbQEiYuYggw44ZSnFLLmr1IIAVYsRap +TpyJNWrOo0kt2qChYMfFDCECeDBLQEOADSZp3s27t+9fgVu7Wvwa9qxkyWQnSxaKggXDnj+DDi0K +4LBei3z9NnyAuGLawYVzilba2OtakCo6/ACw2qrl3ZV3+5ZKYULninezWnSZ4Elg0xVjP54tkDPQ +3zWp6p75lTBNIBEyCzygwjv18Tl7k8+JWTPD4MMZFo+6OnLbBW8FQj1/MThSpcu1VwRvG25qXYdf +ReZddOBFOiz/oIAZOQx0xxIBGHcRXWUNgINKLM203EEJcFEEdQvKd5UFFFakX10oTkDUWDsV6BuG +ASQwh0lO5AFDAPtdFJdUFlaoQgBJhMGQEnwY5J9lV0gIk0zfBTlkkUeyJlCK+bEIGoyWJVggeO0x +tGCDD+IW4YRygSckkQIZiWRrccCQRBtEcOQgYIJ1kEUTRc4pHgBWWhRci2gJlpqW5b1oKHkDfBEB +FWms4GGN/6kghIrLLbbeBDuuKKhDARixxZgE/AEpgZKNyFZN2bXWEg8HkZjoeVxq6eV0Fi3a6KOR +tiYjjTbiqKOKPGqRY5+WgddkTcFxRAUTNS1XaKw6HbrbaiQ4/1mhBJvCtcYCyU32VX1noRSAD6zC +ZaJczYnAlWyw0jSrtGfd1S66J9b0Y1k9fQDCeM7ZtG+/jLHrWEWQpSqvi7FyV+lZ1mJbU8AMhUsR +SBIIqhRV/F65478TQ8cQeN6Ra6q88SZsU0bMPffWsiMhJKjHAh18Ul/XWtTfuTmRa65Uq86lrbAo ++3YyeQwLjZFGmBocgLiG0VDvVAtsfJYdcx6BxGQhYfzkyCmVXODJRQPwFURizuTpSOKm/XKnD410 +hhiTldbzs4KNxDUAVkAaEdZljT20yhD5OmjbWdr39kZOhxRRlJKVvZERdWTbuJoX7b2R30NLBbhk +VDVsE+R0jv9pceVweYE3GxBL5QffEGleEeZ9Z82QjHVPmmzCnW9eERZdwC23TZfOJPvrtFc0QLcR +lSQZ3Tqv+PLS/wXN+2+7T/Y50hb5DvytGg0uKfLfbyQH6cBN8LJEFXe4UQKq157h7SGrkDuMYiNa +ff76U4b//v7/D0CUXS+ABCygrPpnwAQqcIFEQyADHwhBzjnQQBOMoAUbeMEMapB3A9ygB/3XwQ+K +cIRbqiAJT1i9+6FwhRYJIQtfGEEXwnCGvDEhDW/4QhnicIfwsiHgbpSjT20hRCmzwLYsooQ0zOkg +Q5jC8ypCLqcphXHp21YSlxiAJj7PCboSUhuIKEEFsomJalj/nVfuVaIjqqZMAcCTsyTDvvYdjkwS +amMW3riUxCmuYgHUYejSd5AkCQSIBwEVGC1CSCEeEnnEYlYZY6SFOmqoJhlRI7moRpqvbUhLfkyU +6EYiSABEAQ8GmREX8IhIYCkyJ5XUHivHN5J7XSENQcyiE6GYEkzicpIL7CRNPrmRUCbSkIUznE24 +k7ecXBEhWlRKFPkIAO5EzSLcMVbYfGhDmQFAYwJDHETUaBOhoBEAGLJNcKS4m7sECD0ioFBppFea +m1GLgNwkjc2wFcdxehMhlrynRbRpNyrVJJ6r89h9YmhDQ/UEdADQZj0bSrCLPDRnFksmJTMkT5uw +LVg1EUru/6qpnlj5cnMLVdFBmVYfh06tmwDYKDirpRb50aQnefNoTAQCUoTmr6QMUSkmKVqWBfnA +IRY9izjVBT9zTgCdpdGNS+pnKBXa5C7lYpWnpBcy6pUFWTdliO/6dE5oWsYl08QX/brqJ00hjT22 +qslIqdOTdXJqjknTp8XUuBqGDkQw6KRJHBGigDeAMa9CW87a9Aiz9xXwrUrhji5DQ4Oq5pE5VJXp +VVVDKo4EIgJ1MgtVXzYGNOBLqzZZEEnQKi3GSsuxLGWIE8CwAA8VgnDuiaxlH4LV75D2N+TK6EXS +loRb1sS0UH2gao8ZgcdW1qq4ZchfOSJY5Hkhd0Sl61m4Cv+xr4Y0rGY9CNg4iU3fSGwm+fLrF7z1 +hN8idiS5hU1EhXfeb2UrmcF57EyOW6CH2QupRtmtUuhVMN+ctCYAPt9L84dfia5UMuMFWHIFps3X +SOU9hQulbg9MThzAhGSbFGlC6blgBdtXOkpp8F1daRaCziuyWMXQhjVpwQTPx748efBTHpCV5+4R +MPFN72QBuTIwVeUFOTVZeJUCBzUNoJGwI69/MZKhJpuFu1oLT0h5FOXj1cQlWXzjmySrsAIOIA9j +GmUEmFciu07vpVhog0mWNCMfm+UrzQTAFfh0ZQC0+c0Skm/tLIAnPZGTDqXqMABlLJAFfZchScYI +k7UskEb/k/PR1DRIEh45AEKjOagLwFOIRrWC4mb1pYo2NHY9bMFSDzQlCmiWQKIAWz9HWsmUHi2G +Walh1AJqAnEqMymhqmrc6dqAiAZAsGsi6SXnSMp0Fu6dA2BN9RYVywGQclmoPD9rymjR45EqDz1Y +7G+Lu9sfHre5bRLuc6v7mutud5jdWm536y/d8q43Be2N7xbGO9/8ThS9+51AbwP8f/8e+LkLbvDF +7jvhDC9hww9+5IencOESbzjCKz5vimN84/rm+A4F7nFUh3zk06oeSkR9Ee5wWyAu6dNXTLUgGtME +DsGryIK+NABHmC/RC9gWhxnyc5Fv8ORdzQhUZSTPpnaY/8u+dVkgnzhWHkSbnNOlwmdaVb+nDpvY +Gv9Ny0MaEmuCJ2o2hZg0Azzg8bghAmeQEFYPsAhWyUiQRcZpd/LMbnR3neR/2zvf3f1vF48mJ6ia +ogq+hJvzCumWe9OrZVYj8yJJyNpPwtMKpg7eDQr+IlCoAkmooCcCnPd2PSlrS1Ez+OdYeDe14nwV +1lnd4S7ACIkY8gXp3XqLYO5DD+q8XCHf2rS2Z6NC3LlURL+Ang0vJwSAAww2jbwMDYEIKM87vP/u +b79jX93plrDw1PKumZA4kwHwbfIW0B4qImScyJd1iSNgegCAJwGIuLsAtT8071eErAEGgNVAJhBw +xkRTIP8URfUzshERLzV+zqUBoZVH07YgSSAhK0dA4baAFcFaFtE60TJpQRRobiFWaKEW9SE4EKEd +FNABegAxy8cfamFfLkYFz7d11tdD25d5NlhxxeYScrVqYIZcjldbvMQQdacUnRcAcZMTVhA+Nod+ +beViaBV02WdBO3gbM3VmqBWFM2GEMsU0q2cWR3MWsUcbxqJ1ZsR18gKGHKIW1lSGNrE3PJhzqFR5 +VVgtgiE9BEAHlgM/AHhs0WR/Uqh3OEiDgphwF0eI+GGIh7hCiaiINTRPjYhBkDhwjCiJDleJHkeJ +lxhGgaiJ/NOJ+ZaJn/huomhx+EeKURVxp8iJqrhuocj/ighiiq84Q64oiyAni/d2i+ZGi7m4i7kI +QrHoi5F4fcGIi8T4ccBojI6YjPXWi6poi77YjMtIbtK4P9FIjamFjNf4iDW4jNaojZPhjacYjt84 +iOSIittIjONojqO4jkLXjsf4joA4jMmojvF4X9loj8WYj7OIj/Z4P0AGkAEpkANJkAVpkAeJkAmp +kAvJkA3pkA8JkREpkRNJkRVpkReJkRmpkRvJkR3pkR8JkiEJkOgYjPW4jwxhkpqYkie5iSw5jato +jCu5jzIpidYITBGRJARRSoOjWAyxB7WEEA6oGneDN9bVX3gjZ7qFlJUWbVkYcP0Yj8/Ii1DpkvZD +lf54/5Vawhf14xAcuBr+cYEDgzFABSNk6VeCEUq28xE9gXlnWJXUIZW3SJNY+ZYHpEGbNxNvEidL +dDZM2JcEUCZqBmfVx2ltKWSGuSzhx0BzSYhxWYtZWZdwCZntqI5U+EtNE4JbY5TOpRa+RRMAlRMb +6BGhGWqjeVHJQoSLOZnf6JivyJjv+JqHGI5CwYOnkzqr80l9yTQjITkOQ5TRs1dAhikLAoTbZmhu +GZmWOI8xuZrJCY7NSY6xGZnSuX3/KJLXiZ3ZqZ3byZ3d6Z3fCZ7hKZ7jSZ7laZ7nCUgkCY3Q6Zxm +QZ04+J5VGZ9815qsOJ/XeJ9/l58zyZ7SWJ/O2J/tyf+OAuqeAcpbQZA7RodaSOckSrd/rpJRZkkd +A1B1V9c7bbA6yJJ6ANCGLPcSM1iBBsqc6jmVBPqUJvqcmqdhGwoARthqoTd6hVF6/Xd6hfJXgWYZ +vleFYlhj8Wdss1d7FNhHIpqOqVikKKpwSHoW9ah/DMF/FvF/7yKAtlSAm7kZEYAxwLQfgSGUpzFt +elOaUBeBE3icvUSkJWmkaKqkQ7qmfTeFPFCbFdETUOWUFrGFreEGT7A6avkbPDoQ8dWTRmFlD0qY +bNqmy3mP/nmma7qfJNeodHmo3IioahqpGVepMHmpyJmpAvGom+qpnwqqoSqqo0qqpWqqp4qqqaqq +q8r/qq3qqq8Kq7Eqq7NKq7Vqq7eKq7mqq7vKq73qq78KrMEqrCQnAMVqrMeKrMmqrMvKrM3qrM8K +rdEqrdNKrdVqrcg6rNmqrcl4rd3qrd8KruEqruOqrNtqrufKitjqqeqqb+jpru8Kr/Eqr/NKr/Vq +r/fqkciKr/tqkeyqj0earZ2KiYsqqv5aqQFgsJxKsAAnsJQqqg27jgl7qAh7rInajQuLohCLcRpL +jhLbphRrrBZLjxhrohwrcSarjR7LqBJbNE43Eh0gA+fyfy+DhBVBFR5yOD2BEF9yswFQLzoGERRC +fO2TlKcHZH0Fi5sDtAjRm7eiPLc5HzgrpzvJs7Hl/7OOMbQJqCIuOxJSlrUQgbRmKi1cGxEwK7NY +tBE121MigBBL81kkkXpCgRDyRLY4aRJLyxGmiUiwxV66Q7I/lj7lcxEz2z1Q1Bfqw5kQQSKlcRBU +U7cmeLe/ORLQp35VhGIBpLIBBUhNq4GuszzRBXSHi5mJixCLK7pU87X8tLXoA0hNVrkvc2sixbIJ +9bgQ0R5cBpB98rZJJ7oHIU9vKx94ayanEZAZlbqIO6CxIryvwhbkApD1s7sN2rvl5yTAyxbHy1FV +wrqANE3YG7byJxKxa2Rju73pc7uukrshtRqN2009y74DoRYH0R61+3TBCZC6JCPp017laEDYC7dO +iv++QGYsOnu1awsRUUPAhUK/ArW8AYBJrzsS4rs/mXuWAUki3BGQ10HAZMe2CIHApVQo2LspC1zA +SglkGMY4Euyes6sULsM17rsYcnsQXeqhCNEnPbsjOtsAhHAQO+LCWcI+32u0B+G2kYW8Q/ylyZso +QcxHjDsjReHEKQgxznta2ILDdaHDPJy9P0y8RNzCrMs1BBxkaZPER6nC8mgoXMwQMDwwQSlaD2rD +ISXDxvFZgGAQxsE2S6PGmju68AszWfK2CmGpD5TH64IQbyHDAUDDHBrAfeLE2rG+CaDFkEyU4rLH +FXzE6/vEO5MSB+GjBUTBHFLJTSy6guK+goyBO6n/G4/8EZE8ya08yl0cZDRxyWK8vyfRySU8WtmL +iCycE5fcszkWv5vsGQjhH5+FGIw7AzL8F6zMgECWJIX8apLEleslRHJIoobCxKGrugBgyzPhxJuC +zHqhzMwMAM68Ty9zInv8ZQdhLFkLKtjsZLxcjVcJzFYrzH+sFR3MwMMcGTf7E4f7FlcMPZb7zMiL +KwhxHT0ryUTrtxAkzW38dJpsUYmcJATcGXKbFzfbInOsLvS7KdtMToyi0GXKze6MdwoUysXUx+cs +uvvxtn0VzHKB0UCh0TvA0UXh0RVxvOsMxlnSztCW0ict1FMUvpe7Jb5sEySsfEQJTiUoLj3LLzrM +/wAdMtWlxDXCG83WDBGcm86TC6L/Ki3Lu04uo0+Q88JWe9VmYtUgQMBc09MfXb4jIbg8zdUcgVYN +7MUcZM9zPRJN3c08Mj7iIsNc8VmEsSyGbcSzDNKWIrkbYbYHDWSeaZUQfdcI0TDs89SDTcpzu75I +kTYkoMlO09iS/TKRTWCLDYQLtNI489iQvaOJs3rqhylOLNrxC9pvc9uHDE1xXdCBa3zEodpIo9ez +DI5KrSx+DRFqS9HWZdGF8VklwAYCTRGMkxdE6VsiXRPHi8o8rQhcIGgdqM9KrM2vDVig6807mVvh +LCzRPd2Ia907gN0QE9HJnT5S/FvfHd7KNt64Yf/efcvX5AtIzD3MFc3POTnMJOAGsdUigjMDfsC6 +j3XJogxIi6zdmnzGKUrIl+0+TtLc+2zMrUHAH/AIHbwYZRMDjfA2ZTXhLD0Si9wqCBF5CdTaQwlI +gQVGMR2C24TP6jLiJb7XKK7intx/9U3Lyn0Q+L1lAUxjxX3LnIPcRy617BTH2/M7KB21ZjMaTryz +beXfvJ0T0sw9WH4+U57NWqLdNOHER4c6eL067ssRWz69AYB4Rj4Tarx2JX1tP20TKYzUDx0rLV7M +ZO5VV17UhhwR8gHn/7trZo7Jo0uhgIVaPRs1TizEkmnZbeteVd47hm5NXC6/05HIpYswaeXoFI7/ +uJHu5oKq5xlU45J96e5rKnnuXR0G6nQu6vxM6oD75KZOzLQuhLTR6j5y1PYT5XfO50qBuwKMdyX4 +vtGxk767OsIrtIlT27kMZstL2SKbMGmu5tiePqLm7A7cTWIs7YALu6tr5sv+e/89t2aYVfQ8yIki +6DGevtgREVHzts/+2y/jH9qNwQfBUFT8MoZJHt5o5zOx7IA0da8rT5pM5FcCzZEL5naH2UgT8D54 +Qa9uvy2NXBl8nA7v4cMc8egewepOzIyMEHGa8VzY58UeNscu8SmvFFEgSWlbczPP6DVju17+5YBU +7ZqeylWOt3Xdkt0ey1KR0FAr5XFuuD2vXieM//JcQ/BWUfTBXToZfoP0nuxSYfPpo7ZRv+trbLU7 +3++gRPFHrPKrLhCECxGojY2Zvtdef/MREfauDfUGPPZnH0xp7/HLXj+mdRAuD0Ec//MenxNB/bmL +ZNpfMurhJ8JTfzhVv0mCr/HELu/dJvMlGrB/+5joWhOGP52bL5ee354oW4qgTxOiX5cgW6zcDrDD +ivoMN/vSyPpv6foCcI/8yvu97/u/D/zBL/zDX6/6SvzHD2Sk//mdT6q1v4zkCv3RL/3TT/3PCvsO +K6zOP4mmf6nV7/3fD/7hL63Xv57aqv0My/0Hm/6f+J8AMExD9EriiwFqxkV8EyeMf2Ppg7Tzz/9f +FVH/ABEgQJI2RQAcRJhQoUCFDR0+hBjRoZM8MAQa2WIw4gALCAxIPIihAYOITtKsEEhQI8iEEB4I +hBmzwoWHIklKJJBC4IwbLH3+BMkQ6NCDV5bAVOlQSRoiMIdMKfCQwJ2mARJwYeJwgBY+EQR2yNKE +KIaYZa1yiAgkQgK0UnUG4ElULgChc+0CNYq0oFKmTqFq5eo1AFixEQ9I2BCV6GGzMT0kpAhmwcUt +ORpSmGBWARU1Du5+9lkXdMOtFgNs7tww8uQAGC07vJLGdICniiHalMuxMcyZWjt+dEi27OY2r0dD +FO0wucMDKmhnBaCkqRDgCgnAsehRopKjIx//9uDx/GAciz5ss3Tp3Sf3AOobghcPgHwA8yyXH1/s +fAh06QGoO7wuu+oeYs89heDbb7zyzgMpvZtYKvBBiFqIwIhCAiDBM/xGu++4DIJobYuoAgzAhRcS +wgA1zwagA6X6EPqwtSc8i+Ko/xA6zLWDahzsB6DISmwoKKoQiK0JK7wwww2RC2BJ/GLEaETsSjwR +oRQ5W7FF+s7LsbIdj+rAR9Xw8CrIxSTQTqLDkgLgiukGxCzNg5yQTIEdnNyww88QLMwJMhWQQUMA +1tyrzTcT4oiwgwb4wqsXFYowNwsMxGlKORUC0ratjgrgCCTwPEjPUJuM6AQRSjChoREW+ACE/5Ze +gunShAjQICZKD8oghAAeSyhXDAVt8IFbG6LVVglh1JVXZH8NilRQfzIVVVVZdRUhl2KSFaFiYRrW +V2Vx1VVJnxwEaVuBhk3IBhpiqCHaVJ+VS9TP4hwQAN2+fchUA1ftLaFVW8VJp35ZyhQoHRbwwSUj +HVKXXXfhRUheiCOiV6F7QdL3WAAFpgkhzGIyc6jDsvXJ15ArnpXjie2SmKhiQz7osIUhMplBhyic +GQBz29OYJY7QVejaWOu1MgCYcVQBUGDxk1delF9Fd2SiSZu0Z5nbSggzgMcVtmeIfrZagpwP0rra +iFqe+Glru35IapDAZk5srD2eYGv02P4Jbv+IcrLzoH/NXrnZZ+GTwzgAKLwxIgqlXdSCXRtyiXGI +wAvzR6NtbluFMdAAQOG5tU2hbwD+nhjtwBMi3HDEp1Zo8XcjolzM4C6Xy2251GWW7AlkVbfy04ky +HSi1OpDBtpy2lAh3cWkG8VGLq5YU6LbRZL1ghx52smlnH8Ld+c5fwhdH6t+G/rLdicaM3Z+ELisB +NpZGSG+F1NZdfYmCf7Z7Bq8NP+bxJZJf1s5nPvvdrTHug1/jpKeWuADAV8v73UPwR5T+pAQGSQgD +S5qjtLXdyiWim19mNlMYy+3mLPHzAge/N7aDMLAnDgxXAvO0vQhCqCoDuWAGQbLBQD3kYyP/lIj1 +RCYBEz7uazigkgB346kaDmWCPiHAH1BymkBEwAyGe8gAkGiihwgtCX/5WvmGohsTDiwhtmuIEJ+X +uxnej4ZaWQNrzBK1/21EjALMVvpq0DizHO094YFg/O5ItzxOoIBMaiIc5VgWOpLsecOiHwD0yMey ++PFAgExgABViqkNiL5ELeSN+BpBCKSgmLwEgQxm+5oUAoIAFQcPbq0A4ETIl4AlnJKKximbJhKiF +iWtjISf3iBBPguqJKxulAkpZFE6lcpWtfCVI/LSWW9aEdmk0i5zQ+BM3RECFhKzXNL/5SQmGEjRY +6IItF6UFi3RADzIEQDfHKRXsKBNz9hqk//8Y+SBN7rCOmLom1djINHNGrKAgoZDdFLLNLOZzUHIz +n0LnEkl8DutqEQVcOcnJkoRmVHyORJRDLxpCicqFov0EVxFLmshjguSBSzteA2f1hQWoU6Dhi9zr +jsTC2wQUQLUqYgD65SsTrpSgG33IS62jE5lqi6Y2/QnOPrfLe6rpnyCxwgrs6RCKFhOpCWkpRLwK +AHXNEiFZ3epPcNe/inoNgA41zFWpmq9T6fSoZzuoYVQguYYw1DfdSpZClHoXXzVVkIA14rICqZy8 +brQ5fF2oXKmGWHwN1i6FfeEjvbYqw8JwoJ8Ma0Qwu1ShdmxRrDRCHSLCL9P6jVogmaRP1P+4vgeM +jbOZVSw8QRNaUI02ZaVFFGpVS5TYYpOXVgWpQrpJvKpSdKRfBaWTTGVWstIgsQdZbvGI8sE7/dWt +dpRe3Bw525glrbvZy2vL4KDD0nTqUxDx62S9hiDozMd7dlSUvbTERe9+JzwJks+C7NPY0613nRb5 +5fSSq8D5/re+AvZJosKyqP1WSb7XE8EhEzLd85KTt5MLz1U04ib3xg+JCWaejGhko+rQajNgzIsr +LXfciHhuwxkeZkM4/KwP4wk+Ii5KUxKsxRJHxMVUgPFRZGxNGsNXsgo5GFQhQr+8+A660XWSWgaS +GhZpdZkHiXI1KTYBgrwmCn/qYX+JgtL/uI43oFuRTJHxpD2WrKpIXCAh5GBlFjPuLCYsNMkU2QQU +AvThJH6xmZ9hAuhDD6RQA76yna2CZ4iwryx9BqpZGC3oR/+k0I2mDRhnlen2tSVX1PXXAjTcxB5/ +TQs3rA0sizi2qVTlKtBRSBTycEMdDUU4u+EpMLF26g5Pa9XHaTWetgJrUR/E0pqem6557SXz7Yat +0ysirxRdFmV9zCy9vnJDkp3rRudXW6RuzLfgzBpzjxrYUw1jEQf2bN609tcwIQ4W55xeAofb3238 +d8AFPvBxD9zgHu73wRW+8BoWnOEPNya/IT5xJyac4hfHOGMzvvErO5zjH2e4x0E+co3i/zWoJ0d5 +ylW+cpa33OUvh3nMZT5zmtfc5jfHec51vnOe99znPwd60IU+dKIX3ehHR/rJ3Uhyjouc6U9fmdOh +DnWpT93qDbf41bVeckRuPeRZ93rYow52sYu96mVHO4fInvap05ntAT/72+Vu0LnXne52xztL1573 +jbud7wj/e+B3u3fBYzzuhcf74REPWomDZA+zgcnm9Lpge+EgvJW/fBf3zGfT3jsmKD4IOs0C+q5/ +lQA6EExMnJlFy38XaZRvDuXjdkAxIwQKnCrLGcQg692YEfDPun1jdB9Z2pOGle2rPXOcE2wnZzsh +j9fMG1aiENwF4Nj7HnjwzTJ8FC3xvf/B1XTyyTicL/uEMSa8dnNO+CoTSp7ghI8I9Icj/ZA2Jq2U +HP33SdP6uXi+1PiPifsLCRNSAPrjscajGV3hr4OADwiyNEfaGXSJQNertFiCCDjYPShTtRwbnQVI +nMOJgCVbuq+arjRroQjgqwmsQGxhnQdkHYnAgjZYmg3qsMMQwfLiK3IxOJGzwWhCGr6KwRk0rxuz +suqap9PaDBFgPgV7waJZQDB7raUCFDeIQohRPKDowYXaK53CwIY4mE4SgSIsKxMcgDyYvsqDC9xC +riY0viQcGx1MNdnTOzwhiycEgIOxmzI8QyKTqQFwBH07mEtRQbkgL4sxQ4tBoqYiL+j/s8O7Kr2H +oJBVM5Vgiy/NIp/Mcwg4HAo4HCuy6Cxxg7/jiCk17EDfYzANejJckkOWeBnbKK6DUBcD0US4C8Up +MyQOrK7La8WUCqTDWDVfQgIbw8JUPIhiMSwKyRYK4QnLOkCBe8VcpEA4ZMaHuj48YkNVvEaEAEZh +7CCNoSjoKjhjVENkvMZvtMaGwkTjqiqJUJtCPB6j+gy/g0QUtKvvQbWHojw2C6l05D2YADcj0wm7 +iSRzvLuNekePesZT9CfYI8ahcB2FyKpJs4whKcLvKYt//Cqni8irmMgqqMh5lJxZ/B4DoUgx4Ubz +a0idoamB+Ius+kBYXJdhGiv0GriN/+SCjvxIYglIsxFJkaQ+61osJ5O9knS22vocTZwm0gs3hyOA +lfyiqHDJa1Qe3WIPpVTIsfAptQJKYCnE6rouR+Q6iDgYBbiiYryD7vCaStxHCtTHMWInaNqILbIw +SRqgEFrCUYEuIkuAOVAMihAQNVvDhcxGljiYG1yURqGCRtvLdbSXtzTM3wMVRomAxJyixQSJwvTB +kdQY/kGIg3mUk0RF50OIGrmKOBsIHeqVEJgl0oGXKwQKyaTMIuFLAJJLqNlM8NGrI4wr0bxDhLEN +0KS3mCic9wMV0uQC08SgHUoaE+zHJEgNdKRAazIh5uOhpelK3WiyeEFAiTilUJtEeP/Dx2tsy6us +v0pizOMxRZWsqeSjy0KiPNfciLccjLBgLcBss2uMr/PjFq9Bq/LTxgiQKD/QqmLbGODKyFp8CLUI +0AGFiP7cHwssSu+gFfcTNuLTJf9ZsBiBoAGIo0O6rdT8rCWBT5ZQ0IwS0HtsyvXUMw+CUNsjEtLz +P20ixgnlnFd5wxYdlC0UuILTUGDh0A18iCGRM4SiR+j0jT6yja4M0hfVv7liGBq4x3jcTkLTiaAM +z0tkS7iyC9aMnziSshuDLADwRFIExYNTlzAlT6HEz5SMiBP1T0H6ygFMT4Xg0o3yuIvBJlN0U8yZ +Rl/co227tNa6T6tiITwFAFMpIjT/BcsrM9Tu870f/dLciqxVswMha9KfUEudQbfG6Bef3MV/K7jn +gtPwqdQh9RnHYavx7KnsPIhStUoxzcpi3Enswyu5ENL7+ijx1NLDik7ScARcQ5oiFFLug4hV+cDm +eEyNq8kVyMk0ZULBlIsURaC90QnDBA8V8kNgLa9mZTUE1Um4RB0e+CZpfZ9SCUPZqTzdrNBhXDDc +sUO1WDJie4g6FVFv3ZDjsVZxNcFhzUCxOldEwYFxQisDnItMrcAbHRa1UFSkKjh3nUsAgNfMHNgz +hMjZ1MDrU1UmY0wAmNggilXoWz2arFWQ8Dyy1DeL5NTWAtScWVnwPNLGGM61mbW5/4nIsnhVLPuq +8ZPNRNvUIjnKzZOJ1gpOAy2XnnWMhBC97etXfNqNmAVHe22IpM29pQVUmPgWIUW+YLnLvsola0uI +boq+lfhQh/AtkQ04qY0JYkXZd0sIrP2z5PO23hPU5kO/GjPKfgxb4sQTsJ2/6YvblNUd+yPYYjTa +re2+6WyLv+W8otkNsKBYgHvExQucEZXckaPcyj2dy8XcrdPczY24EfRcK4Ta0PW6ziVdWj3d1I1c +1TW8KWVdZBvd130605Xdwavd2qXd2wUefku63vXd3wXe4BXe4SXe4jXe40Xe5FXe5WXe5g0q0NVd +KY3ewsvd6a04603d6sVe6FXW7f/VTu/NO+0F35Ed38oV3/IFK9dFX/Jd37Q73/YtSPgNvPddX3ks +iYqgjMcNKdnDDQLpC4GINQr631BbR10zjXEaWqJd3Y1Sgq4A4Oe8jczjCMq7AgcGVygy2vVriAoW +jGS1En7M3Ng1S04BC21NKhBJz1q7M23V2Tnq1YeyPlyUVYGY0wluQaANWtQVuO4ctIRYCma7JxWe +NBOuWsPVp7olDS3AvSdU3NPAkoMTufZyYghGiNWgjJM9CCWIMxXhCyAeI8cpo7lFCPgIH//Lt9JR +Xy2Mj/54yWK0FDaMlODg4i5Dnp+4Ei7TEu8ZJYnMYhGxTZYRYbk4GMfVGSmqY0j/QctK+cuHEL2n +1Bk4YE8jqxVWbeS/uI5Ijo5EBtXYJTIjmBEAoJMF4FaOnSLfg5JP5pE2fggdSMfza+ODoeG5JRFH +8slmDDgo8WMSecI7zhIXOY9TXjH/GJBPtQuDRQh5ooI+cQQ4qcs5qRMCXcrY5ZM5QTNBIZQRO5Re +igBClsyK5GX98uW82VUAWck4FaJNEYiblV72xbAwrVMXlApS48eMAQ16/sF6XNEXLtOvolfLGsRM +3DxHwkOPGgpiFssq3Bt51ucQdpJpnEktChPM8L36TDV4nGFcnZ4KeAQVUKhVIQGyMCN4BmgQXud/ +o59Gpat9WYCJrkKDrp2UJDIr/wUn0prTA3USlxZVstWVkPnOTaorjBGBdMxYpKGOWinjWM1RdS3p +sOSqZu7GZ30rfnzIz5hqI4TmfAZk05tkmzmpccbQqYlEGXaZrZaIsP5ikh47JxFJlz4YZ5Lo1kLp +71lYBwIRmY6bmaAQ/qIQ8wBpMb7SkV7opQ631EmI1SFSyYnrnDo3pGZXNhxF2HLq6hplho3d4dGu +i2bMqSwa3ysWuwbBubZEn8EBd3KAYjlqXppJ22XnhtAfWWMrYx7qpGbO2llOQaEQEwrZtf2zchWc +r6KQj8QMnspYvzqexn0nT+vZAlyJ4m4M0jbSTb5pnXjJYhkYdBLBt/5jWIrSHv8dot64LVOJi76G +aj07IN4224CrIBxKTuX8pp58ABDaNuUeRtGsvsagULr0PigW4SiaIgWoorKkzSQi3KwUx9ycbTuS +N9PqJv4ybXVsqBBV7QW2mDjajUbSVQlmJcNsYcbeY8OMpC8U63CFcJxFqlLdDZIZbrlyaT58If08 +F9eLka1Z8UQk09j+HY8TUBMKkg8RQOx+au2+6mmE1bKQ0X45mCGAga0Rb/EaTAbEJB0Ot2T6slPK +bYvJ8MzUTD2LUlwBEbuJ0eowWJGkwZmGjGre0dhFJ5tqL+d+CHliTpcucK24cgvdT16VCPCQsgYH +KF7SDc/+3tWOKgAl6L8GL9f/k1ZM9rSnimRyxGp2jOzuFbjjCcoUz5bj8SOCvBv1sHSufvS2osXf +OdN3SWCr5SOcegA0FXJU7JfjSZwl59pV1B1Y/4nzncbHtg5FP1JTB+0sR8l2pYFb+dSu+ulPX5Kx +KitodtDZ4exaWaxDjx7Xa+L/G0DUHvZ65V5M1dHxDiOg2ePU+oxuH64nnSepkoiylfArG+jnDsyG +oBDDRE+//olVKaB2x/J3t8+OC+T9G3G6YWmWLiktUmqrqmlYnVNjBtFPjPBwM3edURkUao1wdwiK +Rgh6jXgg7XXH1gk7XCsyjywjxjrpEgHq2viv3ebLxrCx8SpwtwsbX+zTxpwx/4fyfZYIA2tMBLtU +bMRSrTixm3/NnX8bJPJkzwhlEZSwwqDjRoT0jSpDM/uTN11LVHQk9QOw/kB6awpgEjNMqeePpqh6 +lp9cEY5BUzqKSG1qUwaRoAeAVCYagD9wTJWAgXf1yEJxC8ivo3/YRb2yH+MCbJYzIlNnulaxtGex +7rv6pvBgbT9oQubvb6IyMEFXf3M4LXPOXr6/MCPRbc4Cg+hmdPV7nhdntNbz7guZdTNVyGXqeWWN +q8gzvM3hxT4grBl1I479z1m2O9O3T5siAp71fB8KonI0LG5Z1q+3hoiCRnPkofhhf6Q2hyh+QWu2 +AX99fAcVRHXi5x+zFKaKFf8W97Z3e7hX4KHtM0PL/QD+3IGrfQB+/tm3juwf4i5WfizeTSROiCvY +4mSutm9b/jN/lub/iglzN4AIIHAgQQ8ADiJUAmZBAAVU1DhAeBDCA4IWAyTgIHHjxgEWLhKscIEj +QgIaAhjciOGiwzY5SMKMKfOgwJk1Z+LMqXMnz54+f8q8CXQo0aJGjyJNqnSj0KVOn0KNCrWp1KpW +r2LNmpOq1q5ev/LkyjQA2LJmbZI9q3YtW6Vi28KNm/St3Lp273Kki3cvXwB6/abtK3jo38GGDwMt +jHhxWcWMH0MOGzgy5a5/QWLOrHkz586eP4MOLXo06dKmT6NOrXo169auX8P/ji17Nu3atm/jzq17 +N+/UaCtXdgx8OF/hxI8TNY58+WDlzJ/HvDwZevHp1K+3dY59O2Du3vtq/75cuni74cujT2w9ffnz +7N8jdQ//MXmce2BcHING5gEVCAzgNAAODTAA00ogJfBETxRlJhJCDGLmIEJYdHHREUjoJJ9S9+W3 +X0z9/WcgZgnGJCCBQEEIkoQAHGghhjDZQINAMdQgl4YwEaBDBBeRUcZMOjC0IkIDeHERiRtxaJEC +bxTB0wESCERCRBudIIJAK3oEkgJSFLBRihcJOdd6bEGxBEhniCFRlixxqdKICsYE5AZd+tQighpx +ZGKBJa7BEEhJhGHemEYl/0nQkk0O+RGbdErkxo6GtinRlxaFKZOdRuKJkB1EWHSiRJcayqRU9cWU +QQgBuPCCRD3wEICUklY0UIgkmUSQpxy5UQdH/d2aE0W9wvTrnjKNsIAQACLUQgQosLDVoFqZiqqq +CLHq6pQTxSrQrLjquhGvwwJQ60DA7iQsTnCkuRGQNNKaggIyuLHAByDEdSNHVb57LQBARFCCCTBR +iAIiE4RZZQc/SBRjvgitlKq68tKr05MfgLEwQjGOkUgAWOaB6JA4BDDDDbCSO+qzZj3JrLcq+Dtk +xx2BLHKj3Ur07UYUTEDQnD+ttPNM4gpUMgAZBIERnBspQYTP9Z4MVMPTIv8E5Lwue3yQgCGPfFC0 +PjBKQArSkgyu0wEsXSLIPc7UM6MIcejwU6TCpCy7VIqQEUxPbluiBUIH+wDfJJk7U+AxVdmymzL/ +ppbcNdJtN0l4I6vT4B3tLXa5flsuOeYkKStytK9m17RPXmPNUbFhEr1lATgL+bm+ADw5d62IJxtB +3jM9KVIICuzwMY0rVcoRznlPbpW9TuE898U0/H3Q8JHHVPynZK+9k9o8eVQy6W4fdnxJJ9F+kLK3 +k/Q8QsVOraYFvIdt1PUyKdw7Tu9vRHr6S8HNeb//evkA+49LgHx5qpxOnICHCBzpchYxwhZe0r8F +NvBmEyCf+RJ3FmUZDlb//9tVAKEnEwMi8GgDbF70siUQBjrwZ1+73/LmVjj+scV7B7FfxCSSPMYd +xAorOJbzCDaSB22uf7ciwBcYkoQpdEmHPNxJ7i4goJYRrWXA+2FMYmQtWEEwhW8THVh0iBEuvAQK +VTgYTqwIOpiAMIEkoR9P2BggAt5LBBnsHhd7QkQjIhEASvQgScw4pVqVLVwnWdqkUFgn6s3kdC/I +A34C0IEsMIEjblweSrZowTgtQAFmcCAB7mAmoUHujc0DWgK4ULWfDEAL+FFZiVQZAFYCoII2nIDj +glLHqgBJk5z0ZABA2cGfnUQgpTyl+kiok1SusllmA9tGTLVBAKCvhmqR/6HVQJaAOdDJCYwMwKwE +REaEsI6KAJAeg1JykCgsoZQLEQigetJEAMQIBXVIwTenyB8VWKyVyZzKLbsygC9EgAppWIEwsYk7 +fMrgdd8byDAthchDZqaWxcycLOkIFXSq00/tPGg+AVm9WgXPaq6EZU5ARRC71eqRTUgIp0g6Sat9 +JJBHyV9MrmAmgQxhClWSaM1+OZPsZa6KMgLdmnRWPY6QLqQl+ZqEKtpDAY4FLjYdSE53milv+VQn +fiQJULmqKKOqcGPiLEkR1SiRYoXPdTHsJ/Zc6cgsNOF0I6EI2mYpJHIGkWhXHFKflPekTg3rnQCo +UkPkxyKxwkSMAbjQTv+SOtb4sBUr/GIhAPywgmdKRLGM1epQFXqQl4JqWy/VW8meNEfDUFOvZwTA +APqKw41o9kULDaRHwyqhog5kaaOd4SCPGk2GPZQj8bOkLYFCutX2FKoT7Yk9i/LbRELsIC+UZOku +KZfjehZ2WdVJcylnTJ48l68LMKtECJuZ0zYmskOJkeEmBZKUqLWnc3sST1n7EXPiRLCwU8EZu6sp +Tm0WvNF1CjWPkiX8AjdMm1qsbK2H2DUGt40RFmXm9Mo91KqXPxKo74E5suAAbyS8MMUsTESctgmb +bsCzFC2Kw7VCaYrJujpRLNc+tF2YdJUjEGCEFg/SHxKXyBGRXNk3WSv/5F2poMjQNBb0+kPS6GTY +KjQ+KkJCqWMeIxnI9v1uR45MZIQhRLFokokzDRtiFZulwDDRoZJhEk66KVlAFrPihfe1LGXmRL8Q +FpIODyWTAXi5ZkkGM4GjHBXSPZlV+eyzqKKH5ZVp+bAyLWmLSRtUvZIXAJua9DQN3UcZ1ZlfJGU0 +MSWytbUBiXuAHrKg23xiTiMkWnU9iKITClyZcmjW+DuZYi6lS8CZMCTiBJpFaulegYx5J7gliBy0 +uOyBNJsjXrQIiIvLFl9vEtgRouKxA5Dshd5J2V+1SLSBqBnHoTVrHIlW+MCi5mVfk8rC8yFHFFts +ER7EUSxptMQkoNTD/64IZ5q57biZ3WO3eDoqFDpTuno48B92+9vgzNl7JRzRTBH7pFc9SJkyM4SV +1kXN+lYSv2NJ8W2T1U8DUZ36MFNuB19cIpZ1kZsw88hSx9ja8zmLmneenp77HC9ADzrRu1P069D0 +6FcZutKRnvCmVwfqUi8K06f+laRbvdBZ3zpNns51uFT969sJu9irIp3eoD3tal8729vu9rfDPe5y +nzvd6273u+O9NTIu+0y9znfmkP3vJhO84ANPeITv/fA/MbziweP3xmuF8ZCPjOQnr57EW95ZmZ9P +5Te/+Md7fjygDz3idT4TbTaSgThPlHI/JbRuP9hXwRb2RpwwUHa2gf+YsP931+GC+hNuYfUwVW4U +8nDTABiSI8U/fvJ5sntuz34gwSNddcE++hny8q2sJnPRpn8HTn1x+xL5PfKD75O/Kk8i1BeSwDGD +YADYnqABSELuB38XZArEIRBBah9u/1aQK5/xDUTz3Y0EwJpDxVxCpAH4BUBOyds55QEDMhAAhtz1 +sZZb6V92SQS/1NdBKARDZCBMRMEBCRMXiN8bPdxGTBXuEROotMTBaZ3p3Y0KNOCQJU0ALFH9wAF+ +tB4AKMEnBZX0+IQQbkS1DMGQxQF+1BgQcVleWKA70eAReiCn5KD67SA38dFnNWAeAUAS4iD0rIQD +HoQXViFOEGH77IT/shhBIexV6DzF1RjBE0SEEyyEq0nEtKFO0cRhRKDTFwpaDU6hHzIRlAiiRADJ +lYiTU5GEESKhEj4g1T0hURghyIFQPnlEKQ1ZFNQhoWmhGHYhfpThQYBQpb3aI35WCA4AHRDUEn6M +9iHEFazTAabXU0yiKB5QPsFWFQjTxtnZzbEWQLUZvzySA/3gK+EZheGEXjFQlxDAFV4Y/aTSTVVb +6UHZTEzXmbHQl0AVsb1eEBHFGWrNqSBYfI2TN/pE55WXHMHQ+aCZNmahUFXSTFjR+8kEOGILl8UI +jVyjGy4FOUqXOnIVDhzMm53VAoTJc+0jO1KWhlXAI6gACxULCfiX/yI2kzhWZBtSI1zUVk914Jn1 +IDzJCIK1n0DIooiUJExUSa8oix1y3CKYoruB3kZW2YbxIgAAiQ9QBE9ZFd1kkPT415/BkUw4VYfd +GpX9mK3FYDUK5QTxERFaGVB2YxP2TfPQFy/izP3YowyChSI65Y3NBL+EIkeA5TtOZVChIU54zf+Y +GM+BnvTI5EEACdoQJEzFI6wYDleaI+742wUoi9soC9dMJFPqZX1dJYxBll0Iowx0zdewIo68GE6M +ZUzslkOdpP5k0HAtRoEl5mIGQGPul36UI0/9ZK2AjjLSDEiypFeRULW8HAAoSxWOVkLmnFLCo2eW +UwF+ZI7pWPQlAP8baKC2GYlvThwFTYDyHFtv/iZCoCMl2WZF0KN29aC4lBIM8lYJUmc98qZwmltw +KhS/II4/sqVTkE4ZghQVBQyezWU5kgtF/I8VNWdd5tdeLpnIVInMBCbDrRgf3RBx1QUB/IH8KUAg +REC24QSQPBm4TWcp8sy51WSVIdS1xM5rYRhU+CeACiiBDokXWExOXtVbClL1wd86YUQhxBv2FByl +iNMNshMMbNT0cFqWIFffYZ54YYYv5WZQ5kS1ENWJyqKOToki7qdM+ChOLCeNgoSNkiVHFOM0Io2Z +BNiz9WirxGgRSqm+VEn6yWaaXd/MYcbOpE6k9NBd5WU5blBrqRz/YAGXRWyLYAHJEMBA+vwkSfBL +BgFpcUroYdYFhRwJ/nWAHmjgwtUZTCxpg7mJTEEpo0wmVxXJk0UoYxSYnsIJn/rpQfALiHGo+vVW +/YCPujnKZo3gjoCmjxHiuAyLbpaIhkbKCuraaMFocn7ejM6EsiykqN6oVFJkT1RQVc7brErQRxZp +rEYArz5lTjiWbT2WT9xqfsbaqWQGr3pF4LEX/8DeQKQEUdrlOsZNsBqmjUnIeEZOnCJVpmoXYU6A +syZHJAJFlmJmLjIYTxQrhFVmob5kymXaulrUUqgrDbBPxqnID43mSYDOWi7OMeEoSYAn6dBObAJk +UsJEePQHes1k/62apcGeSrv5BLtlTbSM46lMqalVrLrRZl08LLYmV5KGK4jSyqYWBcbOBMseRLqt +G8e66tKhayt27MQdpEGO1VquDMRy67EmGNCm4wZp7EXe7LnWBb6Y2UHM40YsXGvqxOyArIvOK3Wd +JJEg32lyxEpyImy5ZAU6hdIKV0hip07WzcbtY7Gkn/ggUIOO0MQOzcfWD1NR0Uv92NLOZsOKDhwE +ygXiB5NGrMluWeZ4hEpZjSoyU04ULlwdLkFdGCOOoSMmiuGyFuIGKkn86kHwrUj9LaFilQDlJBeA +HP5xT+iOritdLo5ZAOWmouNCzeKOruVCzZXe6T9GWuRdHxa0Af+dTFWmzVseIp8cAkAfluHm+m27 +Ool8SmbsPUnyaWImISWttYoUfmJnVu051uxP8Mv87V/rspyP4ROY9k0pnS5+pK6kXS/V/hTIAC67 +OgQAKgEf7Ei84u5TbG8SdK8qfu/48qIwZkGT/FMEKJleOUQmLoTvqibcAkC1NBQAXAGANRg0asE6 +ta9RYN2ZlSAFPlC/YuqIdGj/yd8Wpu8MgTBVcSFHxB8L8p//ifBOZO6SZXAJoZxEXAELe6IK2vAJ +N1YJ45QOk3AOr02ZEcsCrO3VXZ95OYQPL6X3gR8mkkSxxPBP6Bl1CYk2iSjlkkQKz1/9RcULk0QU ++B8WT1wKviL/EJfPyVnEc4pIAk5rBypBGjTSFp+g9UUFGMufGJdQR35gQzxEdsGinxCg4p4o7Q2J +FjDgDaepoVCBSxgPr2Xv1Hkx6VnGI0vy5VXy0UXyJRtdyGqy3nayd2TyJ4fyJ88iKa/FBZPyKJvy +rq0yP7Yye6gy6Z1d3tFyLdvyLeNyLuvyLvNyL/vyLwOzaMBqJ8fyK1swJRuzJyczehSz56GyKCPz +MmNFM8tyNEvzKVvzMj8zMWfzNXdxN0szNXtzRo6z2TlyAW1T+QmffX0ki5TWqIJEO2NLg/zQX2XG +7Wgx/a2zRERy/D7KEOyfpRiTR0DVSF6EGp+sByvpOoXgBnMw/zY7BfmpXo62ynPmMxeLYDrj4vwI +hMWCpEDgF/rV7vodK/V5NJ7aBf7xcUCrHw/j8fj5nz5ncR6IaCBTWgIabPcJbfFJ4BZoMNOU8zSf +80EBog9SYRY2Iw+abDFKpYDIs3oqsNlsC+RWr2cq81oAiS9WqPWSBFPDbVJjoZsJJlF4qJwK8P/+ +ogB3bVaGZ1L0R1HfYFjOUBGBNEdQtRd6JtYmqA9uQfq2SF6DTF3PpECE4iHGnkSoIRseLdLWRS3C +3y1G7yWa4DltIpUWNV6vzZPItAMftYTRrx7JX6VczSOx2h+TopYGNc3CapaKmDviSDAFTVQvT2oC +m1TONqEVrf/HYuRVn4WJkSM3mqVrn/FTv/ZpD9bZ8uQ6sjVqIwVro5mDHstJbCx8xm0bjqz7oASQ +nJGplAAb3FdPNeRDSlNExmk+1kCWorRGiutMdmRBbktuL+tux6xxq+8xCeQPpKdrqnVMQMHX2gg4 +v/Iz4yWSIqNOsIrPlpBtLzAPzJGuSpC59p5alDVFmqqNFfRYD0VZu0mYkOa1LHcpH8WAi403+Wmt +IJiDz1L62OtQrIQHpKWtec3BWKt2iURfTstfFsBouov88OwxI6YAK+ZScbVM0BB7W2W5bmvCdJaD +VWZc+kh6rnhzAHgrP7N7Vs9tApDEGjiDk6wZZudvHji21mn/ETshW3DtvHVghePmOxr0QEgcWsJ2 +qHiMh0rtdhabdkI0Ulj5A+GXo7iNifeqftop22aGrnG0QQjxCLDPjL9TutXnyPykd2aszDJsXGx1 +Q1zodRriApDUmNduK54vhOH0eeKsODVqZk75Km+zmdZoUA2r6hpTlh7qTAwpSWSppxNpqh/EgmGG +AKl5lgvuBu7PYNsK3OpV+tC5ygppla6VUrD6ke4Jq6gRoCurBM2NIq4L48y6FlarQBpCBLwKoytv +m75pxPgX7aYjghOGrnMEpHKuI00qwFRIneE6TDgKLm47+nLf/pqckJw6Yoiz5W1zTMhqkr96AuME +ehMFRaI3/4pPHIRvsl1gF8LHJ3FruPN547/K97wRt/1VRcE7HIOKKrmmz/g05ZgurzntuX3Bp2B5 +a9DGd7Mm+bon7cIqOZDFFgCR/Lb2mfgy+SNOq2BHuWAE/OQN/OOwTJfTquD+uqAd6MrK7co8fXVP +92JHfF1ITZI3/ecGO0KIrXMRMQ7tZLorvW6f9LOi63UTuXRfZNVPicJEL9u2N3UhtLj/W3fBrNHO +rAuz+9DibdNKxNNeJ3yH4247SgcE+dh8dpiO1Zknln8DdWqb8zADgPHiXwUf/Nve09QLMuvKLpJx +/oJftuTmelsMQB440Kfyu3dFdeY3bwQN70JstEN54gMb4/9G+C8AAyMnwm7jJm6nLYXlu1IFV+f7 +3TXpV1PwzuFChD7dA2XLK6+ISAi627oI3C72/jj3RoT3gumP+fwiTm8jDjlcjhe+Leji9/tjKdb7 +JoT80rcRS/7ka+UT+wn5yvBDV2e4IfadFQUB8DBABBgypQAAgwcBtIiAggVChwidpFkRIECSNkUe +ZjRIUWNHjx9BAsgQgmLFNjk0EtBQkmWABBwcQnjQsmSFCxDzgFlAsUOWJiEfKklDpKSRLSg1KtEZ +QAEVNQ4eEugjseTAgkCxZs3IUevHETtdcvkJVGUADxojTjSJMeMALUTDIs2KwazHARbqHjwgwaZH +un1HKtj/4fFrjBpdO3JFvFhrFKoBeo5FSGECTZZ9IT62yPZgWcslzwKl+9klzI6UMWcUCqOkRSaM +YWNVHJt2bdu3cefeGODjbN2/gQfP6lt4cePHkSMnnpx5c+ewlz+XPp16dYTRrWfXDhz77u3fn3cH +P578dvHl0afXeF59e/fS2b+Xn108afv38efXv59/f///AQxQwAEJLNDAAxFMUMEFGWzQwQchjFDC +CSms0MILMaSwN97m63A4Dj0MUcTF4hvRxONKPFHFFR1KkcUXoQNxPRlh9NDFGnE0j8YcebTtxh6B +JO/HIIkEoL4dixQSySSZDG/JJqFs8ckoqaRuyCpfPBJL//Cu3NLLkLr8UsUwxSyzKzLNnE9LkPZg +raUx0PDoABUQMACkAXBogIGUdIiApgTYgAormUjDbC/76jyI0M9SS2zK5gjokyYyyugITz1DmjPR +juyAqyRMsfLMspce6rQlUNvKc8/xyIzUz5Yo9UiHBTa4Sk467XxoNNJqBerQAEgQFKETRKCo0dFK +MCGjrygK7SGFKJrhBhQfpa5NmhR4gzMA7rJMASlsPQiLLmg6AgmHRP3TtJB2HXVdgwZYA6ySenUo +3nlbSiKM8tBM8701OxopABdeQKgHHoAVFoBFKdo0qpU+XdVeCxSQQWE8Ex70AVS7AiICghXdWOIz +q0WO2P+KFfY4WYTS5TimmUpy2F4cAoiVsbLqtYtmmztqeWQdYzvZYoRUVnayyugNFyGGA5AZpAyC +QNlXCT4AQ+qDbKBhjEQCODaAQWhgyCGFhiDKWYSyRqEOkoI1rl/d6AIZoVk/AOGgAfLYlluapUXo +KyFyNUghsTtbKefF6Dq8o1nh/Ahql55QjQjFtXvbX/UA1kghwx4iltSM9nK6LQtcNkgmwdBNIQDK +O5KpdKC+ktt0kRmz/GbV+3boq0bvJv1njUIPHG0aUI8NZ6Ufyrp4rO563bouCcB9Wt0X4P2gxJF/ +KHisAht6aptCWB5Pw/666XqziOXcoDmlxetsg6JHndj/lYuz3baycj9IIdEfoszh+Y2GELrk73ix +wd5HoheA/KVEdbJTU8kuN6ZHiUch9FvaA5bnkO19pHm/MwgUqsAUKvyEAF9YgA+y1zqYFeUoIZnV +Ahe2QooYRS4gsR9iEli3/k1AfRNzngYlwL/dvSAPburJa7KSLsj45CFDLCJPsoBEjXRQSbDJod0c +QpkeOuSAH9ngnXCQwUzx5QJ4WhnUVlY+AdZlTjo8WN269b6ERCB3X9GhcG5YmxLuJAkEAYAVVgA4 +kGQtYwbxn/AMOQGHKTEyXeliRzxXhzssoSpPGZYILNihPEbwO5nTyKwUYAakEGCSAXDeFy3lu47E +AQYW/4FLKGuIGLewhnCfXAAM26IFWjbEhhA0DsYSMIerOOGJ/KMiSFAJv5U00iBKIEotEXMFSl6t +LMwEgDMDAE2EHJNLvpwizYI5zGIi8nysAyL/HoInMY6xL2mrQwo68AODqPF8oVEIwWggyDg6JH2H +MYjA2hacTdImCktIABeWUpF9eVEFV0uk6CjzOY1IkyneY5d9PkcZgfgRAE7QydUOKaKBcpI+E4Qg +RSkyEM+9CyHJHN3rDpZJAJgqd91qiTk7ozrrASCBuOyZTs3nkZFqZZZQbMLugrpNVSIziOQsIPXu ++KuIgUQhn3uq3xZwRx968HnetJQujYpUjTyyIy5NHv/xBpNOvNz0KnvBDLGYklYA0HOeeQEAs9S3 +z4MERq4GASAevYqcxwUUXvLaIkJAGABz7RCiiiTnsyLwOZuyJGdkzUhI+YlJo+1FpvIZKkmtZNLF +JJCw53zsVjNCV71IQKKMsSMWEfI4FGrltb1UT9Y6C6+lerGpy8oqbA+CWcb81SC1zaJjX8rV6uQR +twHU1epS2NLeeuRg8VyMW4M6J8Kqli5n04EF9VpcfNFEq7r5bFf20lrd2vUgplpsRoi7Rp9mNrdj +he5H4hsyUD3OgZ4NLGj9uyHEJHa2wJuuXXaLEIU4VCRBGFjBQjIAR0hRLyqwrkNkm0IJU3h9Fpan +bdH/A8gLJ3eM/BMYzwBwMAZ7xA1PUNjeAlBgkZAExSq2qFJ/GNrfiPjD9sXpatFpkOr2GL1k9EvX +ktpdBNu1nxkB6Itvc16tELK/HoMmILOltyYuQJAVhmaLX4wxGYPEsr5t3F4dLLvHJSBypZpcdHUM +4Bx50r4sgWVGmHaZpCqxJK0dgBdGFSjmrZUmcojljGMc3cm2xNBAkfKdCE2RcD7sM+rNc02SCgA/ +qIUl7xXNZ4xQh4xsulznYhnE1AW02CzaJcK8LNJo8r5LGyvTxBoxYrB7ZK/JUal54SskRbBOH/0X +OW54lZ21dTT7NAqQpeYiqEU9F4y+y1QtYXNGoEDJ/88MQTLdlPOcRftttxFb3Fh6dLmTc250B0nd +6+ZOuN1tXnLHm0ntpvdv7H3vLM1b38uFd79pk2+Ap0fgA49NwQ0eIoQn/EMbytDDIR5xiU+c4hW3 ++MUxnnGNb5zjHff4xxMkYIbXjt8j37fJH4jyby9c5UL9d8vBVHKYj4jlM3eUzTlZc5wfhM47f4jO +fT7uoLNK5kNnEdB33vOMENNNRtHyxIIswBwrgQ+vGoIltTJrWjuE6lbH+kPSQpHNyKbot+l6Sr8+ +1hz3jn/tssyPT00aibqdJooL+1q8bRuU4h3sOQELDe2iBW0/uKwSgLuB7cPrg3hMvQcRCqcPehL4 +lP/d6CdCOs6V3lIVCASJ2OwyuuDAmqhfk5LOm1VPMEKAP0xkzCBxnXIPcvospH71iTYYwoaARFba +HsTZkT3tWZ89JZQe9jwNfdNOW1YVHF6Z973u8m11MM4bZPetjzNsHmeUghDg+A7cy9gBcAWifP4g +xm7KWJzgiMc6AQ9+Yr72DgyUxJYGww4+qFxWw950U77yNOd//0lG5ICts4xrdlgCnXzGt8oL0Urr +I17PK34Lw9hGUATmfZ6s96qjAP9pAguHJX6IaUZvbCKA/BDIcODMIxTi8ypQAgupq2hDuNZL8WKL +JHIGYxrw1SjrBA0sBOfmhGRCvVSrpADQSy7P5jL/76HI6QFBJ/6mKMGaj3Jg0AFpp2dMkLFyJb1Y +CgAoYwG34v9wqAqPy5iccAeT7yE8hgs94qqy4gyBCwt3CA2dhDakr9H0ZwTL0CAIKaB6anqwosxK +7A4rrHF+kKW+QptccAjNzQsRMeYEUCMIqfUIRfHMCrUg69YSqfFUKNCERSEsUQsnIKOQ67gOqwu1 +gxOJ7BKzkFvGcAl5EADYUCv4jCmSzSNe8WgaaxQnzzawSexaaaE4iGZkh5A+48xSy/m0Qqosw1n+ +7GoG8SGMjSWMQvKmowgXUeiqsTmOsLDGa6pYERC5ySGqzTI2hdWMUSOkj7DCkSY2JQo9ERelZDvS +/7ElxHDt1ocJNUID6/FUiu9x4PCuIjAMyUmL/OkQYWMZwcUgUArFnDECGEwJNU/Y5qocz0ceA2cS +Fy8CPC2GMBF+pqLq+qzNsFERr5HgRHIkSdHlGEMh4NAie4ceWUZ1brAr2DF1CskNj6sfea4k9Qgm +oUwVXZIlxQsnu8IhoQq4VqvxttAop5HfLvAlFYgPEQLLDtIhsqZ01LCcdLAb0xDVCiXT7nEB3BGw +TLJJqBHmslH56gsAgNIni88h6EYpu0Jg5iv2/hHRLJADG5E83rIJf9Ie3XIB+os2CmMgezAwN1D/ +mpIgF0MuoZKngMohjK0DZCCFEqi/CEnx/JCpWv/xZVqLALTg0OpwM6NMJ8eyk0izNI3k5TQCDhaq +qDIS/kLwG7cpD5AiCtrvW7Kyd5hpAOhgIhwIb2rzNqfyIKQv96iPNazvJLMDOA3CNhlyONWqL6Nu +Vgzz06wCIZ+Jl/6yOoUM93QPOXOTWuQQYQ6KLcRPsUzNIGbl2kDi93hq9VYMK3HNL13vAToTYobg +IuDnDoiCGJmjLFFzNAO0flTTtyRNLDLRMholFulvr0hC7KSxK6TiMTYKeQQGQkHzIO4O/BhROy7U +JDKUQS1NhvTMKbkTKITCUwAvKhoIwj5iQ/XTNG3DLTzlOuMu8R7iCpbi/HAwGbMCGWPNI5oxR9P/ +wE1EKO1CckDZ7TRL8yyTjkmVFN+gFDUBNEpjxEqlNC8BsEqx9OemtEm/tEvFU0wF1OVA7kzRNE3V +dE3ZtE3d9E3hNE7ldE7/Q0v7j0vJ1DvyFDfwdE8x0E9JpEArr0/JlFBNzlABVTkTFTGcFPPCdFHJ +DlIP7lEltTYQdeAa1QgptVJRklMZdVM9NVBDNVI79SOu5U3iRPliU1X45NhKQiHrsys7Q1JgpVIu +SFbtVDpcZVJsNVV+Elc0Itss4wzEIIm40trWhe7YKmRwVTFHtUPLQ1hpglg/YlaQ7CHGxdlGjdMa +BhBXC1GE58/+BCT5y0XvJoxuTEZ1gxw9cGR2/9XaBG1WXZUiFFLrrvXTLOM1gZQicNMRaYAiwrJM +b84jBMaBzlFhQPC0ErBzgu3GiiYriBK+GjZlIiCTIrbhskNoKDaTFhbPZIh/9kKb5iQtKe39HgJq +HOpi8+5ZHQ1UeUtkVaC+xgUFEGECeOdvhGdwtLPDOkAPepI2PEZ2bI3IlMeiZoX8howkm+Ngauku +GMwGBUVjiaZinUtltQIOivUvt+gAFkFpMIZy4kcG3KAu3y1X63AUV4oMIc0qpWfLdkojrBZ+2pZ6 +UiNu/1RX5xardko21XaHDqsq27IDTXYGG3IK0eNSE44aBZIqaaB0UBZcUCOp8quu8mdzCBM3Yv/H +RROzHrfIynhpTgxxZY+DWKDpdPrKMe9rD902qOwWNlqXp8BQwejoBjZX3sxWcKj2IUy3bxGMbQOA +CxcXKPJsReX2d5UyeGOoJYj3bp/jivz2cnVLOk+r2e4PAECoE7eyJaxJZ9ZpeFtIXVkWWsmDerkA +Ja73FP8okHIlcm0xIEOxAs8uAJyONl4IKi82YucknjyGBKsIOeZkFBOLR/eowJxXFAfSezMUFlUH +J7kPBvqVcdVncnPjLEFJlPaT+Hg3lV4HmFyto8aJMYqqacGpg5kO+b5ql8SXOjhYnETvsfhWK9vi +CyKACh5j0mCDouLzXCHSXsAqdHMxfFMYPAb/QIZpWC1sGF5w4NbYN7hC8Wg+h1BWVPV801y1on5f +pnQi8SGk7ynd47z+F3qP05X41YLPtdVY2ISnqId3tiswhjs1SoQ4bMYyCB/5VFBzdPBUSgQ2ci1f +GF7AaomOqnrMhxzhLoEapagAWazS8DFv1zkQOTIUmRJ5i39q8SA2bXmAlB6rKhUBQHlOF4EY2VmB +eEbQo5IN4pLTSiYUcomR0Apnx3Hxku74R3Wv+HdUdi0r5zQtNyNiyrlmiigW6JF9IpIZ6F4jkiIz +Yo/YMyQKWLwWqHYFlpRxiCczmC8DF2togGSxgo4ZV5uDEi7fMT2ay5r/UK30r67eFiskOMV4/wB7 +IVAo92+UmXc53acY+8JeQcOvNOu5cqd2r/JpHCw5a3cvcBGXhbA49ve0glAtWYuTsdmb/RGe7UVe +lhkrbBIA4Io0IPpTGzlYQyg56zE2V1EjeCwrNkx7POwjSvpuJgyl3Tmcy2OlSUwznUp1tMnGftYZ +XWxmeO/2XvqkNSilc1meOxpvs2mNcdojWFm8yA90d9bWfHZqfThgAjq6hnab0LUnDVqUcyOhO2LB +bqxcPUKmuaWlg/qlsS2EqLVn6MAXy7ifw+eTvzlLS/XI7IyMX4ZR9uxY++xdWO2IgYJdA4AOe8fa +OriwLYOwixo5/vqwO9Bd8lpBkypbpzVr8f+VJkJNYtFasBWbq4k6J9ODsltirZXaZr2y2VriNblF +XlrigbmHJED6IOaPJSratP6lJHGWgwDtT+J1vWjbsVXxMzpbCqet+TTxIL5ivhjTdut6CBE3Sp8b +U132s6WZukG7ubd0ulk2ugGOuxPVu+MtU2cOvMHUuhXVvD1bno+ETtm7vd37veE7vuV7vum7vu1b +vM1Su5+VvOmNv/PUv8sNv1sOwK+RwNHNwLEUwQFMwFVOwZ1bv+8UwtHbwUmqUUtYfrfg6ZQqyFK0 +KjjKIaIgDwZveccIXNUO9mBUw8/bOuL36nJ6nlzyLoKMlLTtiCSUr/saXUppieJYQzUjRlX/bUYj +jSZc5sLnN5l33MY1wjkPtMex4go88qiX7sf15mEzwnPHND32jkM7QvoUL8UDb/BOFIhMfAkVB8tB +RwWm2t9+Q7AponS2HMi5LspdXHdJtETJYirUYnu3SQuinM+t3AwXYo2HraPnZPquafweq4HRWFea +wpJ4M/jWyEZ3j39lCQdEZ/hMiauK8zt7Grunwz2l+NMdD4PT8PiMiWaMYKc9agHQumRPEGNWHSpa +3RI7/ThJ/fqMQwdQ5dCNM9EDgPxkndV1whI9pieQQtPXPCOytY+2Dw5AsjsRvfrCJanRjPCyfDyy +bwuenTWqc4+aRYu9E9etz/xGyCDSz1vB/0h02M/9kCd/0der+SVMeV1itr3bsV09XX323lPS9eua +U+mgkCgKiv0U92JFCwoyiMza/ynNqDiaV5y+fDmigSths4JY6PEyaSNrbq1jZxAx8RLUnwMfE9Pj +I7tbTzbk9XmjYVciWbAB42sFPz4m49A4EqjAJNi4aje+LnahF4dsnYwk7rIFEU1uGN4aySMKw0vz +AGclhn7oCQtqf4PjT/GNKYJ1rJ2W5505bt5WlL6e53rmheV1F+MrQtCQk6pgIezoJ9iOW7mWq/kj +KmjiBd3Ss6KXNdiDLpqJ4Xnh/nkm+9i24R5dYrcEXf6CrBIM9z6RJDrbgWOwhIUdlfBin/8q+6IN +D2ng1WU3YOsRKSeAC4/WAJw6SctjDmsoBREJT3rWAcrifRbfE+9I63ED7zsiM8WsANQpXYkuOSD/ +9gb79O3wCZFHuMheQhcYnH0afQEg9EdfLEUem0k9i2E4UxpK91s+LsaTZF+YHZF3YK3DFHcIEwNf +ukQngUiwLNKZ8L1lFlH3/FcCM7ifh8C45oOj96EfEmciNMwfkdA/qVodIAIESFAowZwCABIqXMiQ +QAqBECN20ONAIYUJCAwwBHAxRo2NAA6oEOjiBciTKFOeFKiypcuXKJUQgZgERpIwG91EKJmQgIYA +HhhezLix40cANmhEXDoGDUyQPXiUMKH/EkOADQhPZggSoGaHH0/Dik3JcqzYrQFIVNwok6ZNnAtb +RPhadEICDgohPFgqMAGbtWYB6FiAggXKiwEUUGmSUiRJk4FflkU5GeWANQv4CmzA4OQBCURbDvAS +oLBLJUsCHEGicIAFvlhPnhAxVaVrziCHahQ6wWPLypGDJ7QzU3OA0Axvd275GTlDPyuMX836eSnu +lGg/gFgIXXpsjhh3LzQqvDwA4OYVZgiRFnBrzMavJ+xu/DsAnasTRsETIUBThdVFdJ1P0yWHQwAz +3JCQbnX5tpFjAWiXHkzoTRjcaApIkdUVqQVARhkJRZXAEwsRGNR44TV4lF7yAaiCAjsk/+QabFlt +NFttVRWY0mCmWehjQhX6uF57G2GoYUIcCvThQsRJ5xxUPBAJwIxL2ccQFl0EwFNLTvA3omcjRbjd +jwsFqZCZLcklIUjNiXcSAV8s8CVMDgVQwQVj3UiVbRa0CKAEd9W1JlkBkJlenWqBpJxLbT6VFI6R +sbhcSo/uGRKgePE2qKGSFUrmkInCpOaYlNIA6QgLbJqQXA6qVKeVC6Z4aaCakqrQYCUBEUGPnDKE +Zq8qgeoeAHUmCJ50fWX6Ga0orpmUn8T+BKtLerpk1bQMNQpseb+WJ+xG35b4kLEpITpsbrI+BUUV +qrH2lFzM3rpArrsaxumv3YIJ6YOguf+ZHGlG1CEWgeQ+JRKvKS0KLnsnqsdeqIRuG9lgqrbW56SN +9QvTAAdCHBiqrZ7EsZQADNlwQuFKHPGPHCsgw7mNqbCvyB0DBvJRcUUQb0pyIUzsQ3eizDBDKU+J +g8trRYW0yvmqvNCQBfcENJ5v/nRyyUM//fBadW6pUFJAiXWwvS1dW6NnGjsdWNOBtfwySFArKK6d +VKNEsa1asRd1S1gGIEcOY5HX2tFvA6B04T/i66lKcMA1gBYwtJvxkzIemF9KeiXABWNTQq4lZAar +4LNlF58UVQBDMJFQHJH7cDZli6utaB6AA7BfBBm+vpDCKmm7ERZtbJjanDBZNcQUG87/5DPwwg9E +IkOnp75667rLfmbs6bkNs0KNy+j55Qsxj+Twz6vHlWKq2w6GnOUzOpL0ALTlteFRws96AK4vNLaB +n0vMtuyn01wRkDQT8IHERBuJXvrul7+FDKYDWRggAf6wgqWFbnQoMVvv0ma9sPxPLNpDSQC5MEAA +XKGA7pIR7fTDn9ztzgIQ5NwA6BCd+fXuRUcqlwYUg7zxlYZsIREdEI3Wv8RhbyP5QlVfNocSvRgn +aAlxonTidYU0REcgx6temurlqp9oZmcAcIIVBZKENpTQJR/k1JDI2IbabYRAX8xUXvaiGSgmZDYC +4aEWW6KENBQnAEbYghsXgsfEUKGH/ygR4xXLeMYOIvGIwkmKBVGixIEwUTYiyOMh92jC9QkkkIN8 +ShTG2BVEbkSRbGykYBYgBH/JC4M+SqPaHvfHLLYEgSBBZVfMiJIreFIxnAtLz4aILuNc7U+Uc6RK +ZPkSSSLOMlqopSkdRpM2vqkPpETdNF2CGOnY0XZ5+CMoGTKYVp6ER8TkFiTLtE5lutORzHynPOdJ +T1+1s574zGdk4qnPfvrTnfz8p0DfqbiBGlSdB02oQu91z4U6VJ4BfahEJwo7ilpUmYpDlkY3ytGO +evSjIA2pSEdK0pKa9KQoTalKV8rSlrr0pTCNqUxnStOa2vSmOM2pTnfK04z29KdADf+qUIdK1KIa +9ahITapSl8rUpjr1qchaZkMvmtCIUvWq9bQqVrfaKa569atAmipYx9rVlZH1oFo9q1pjKda1uvWR +b42rQdMqV4sWtK76pCte9/qbtvL1rHr9q2DFEtjBzrWh+dpD5JjiFJSIJJkAsIpmDAiSwdDNYBJA +FnIkyxfKAqBvS/HsSvwKLALooD9LWRLNoMUmFUAWCh2SCEWeAsc4LgS2fJnIsKRYx7oBlLRh4Wx9 +zqZYvvyHIcVl7EaSGxEFvEGVL6EPRCAbxGQe7ly6giVC9SlczdjHtKiNiF+GxVyIHBdM1CUdsuRD +pc6mkH6TVEh20wlR4D6luzRaSHn/BXLennjRtmAaiBzLZhzROjAz30SLDeH7zAndFSVDmt/pPMbb +47gyIXAQw0YGE7LwdQEFiJjANyOjK69leMMLCBmqzKmQYaLRvmSaTXx1ta/aBoC1UaSjQJKJKoRl +B2861BElCQPEHy9EUgItbLCCYMEIg45+UnLyQiYMGKvY8G6h061KKgxZBYPOywxd6FYs6Jr4jixU +UlYIlY+sYwtPKCq8GoAjQrlK54AZZVxZMD2VjB0mFy7NIYoSxAiELZF5QTEiACNKTkzOFOPsSh8O +8YgBMN+FVNpQDz4Jqx59x0QPWH8cdAmSicZkDV1k0mNBlZ4ZMmoAVIshVtkbSPhM/9txyW0hqEI1 +7ybnSknGiGhZcwmhOenrhYVtjjjeM4wjs55JbtpGnl5VBDrs6mhHC0G3lnZ6GfJszKa3nBpx5vbS +Q2shhWCSeoFRQx7ynW4T0tr82vZTZqNdFFEO3EihQXzzWe6FOXvanK42s4b9El2tJnOfFkurzZe7 +U/vWRXTp2pONKFWVyGVmAEj3r+N94Tc9RFVWWAGLHS6cwcj6jR8nFYN4I+9+CzvlKlJU6ZgT6oSA +zWPXPvkB/yuQGDLk5sMi2K0rDEhB4tPlg1N3zjCucWkz/QFKJ1acSomQkLPYJSZTAh9QG0jognrb +IoHgCupN7mVbr2UbV8i6DMkYOP8toIEAuLil5hj1bNU8MCKhNltSY+CwZ2Hs9M2q2ceCdm5H4OlR +t3EAfL6RddEl4w9QNJ1gvhCr74bkijrQEIiwb4qb1W4LUIAZakeAO6QGx76zzYHmx7HHxwrVTzF5 +tmlWxFhR7iKSZ+c8R2aQrDghD5FL5q4de/cgdgUu8du6kMWSpEk65iYK0Xp/Ct25yJHdaUg3Wt3l +JXrSm/7GkxpM93vy/RZFYQma8+Txn+LEcRKLgrW3u7ydqHfPD7TwIGFdGYsz/gP3v/SnhzFf13Fh +kXcBx2Y0oQbjRn8HyG+DFxb412j/V34CyBDNhziDAXcI1zar92StBxYWIWIPVyL/P7F9mIZYbZUk +WDQFsyF5qfcmcUI8OaZaIfhN7QUR2FIss/dGMdg+tudKK/d57/Q4ixVDuTaCUzJzG0Rdt/NJghRs +AQIRydZiOvNpTVh0ORBsKFEnsCc7SFdsvRRbx9OCn6aC2kSGeEYyU4IZrRKFm7EcCyc0aohMBJgQ +IpEAiMBFwJJ9kQGG0CMVcwcATbI3ZjiG8CZ/F4ZfkOVuLiF3rYWHevhPX6hvabcRhciCh6hpVRgt +/QV5uVcuPchqD0CDr4eE2kcFMNB5bFVxY2EuaJNel8E+IEF0mnFMLYEWcKcomCGD74ZxsbaDcPVP +lSIySshr7xIBFSMWr8YzyAhk/yCBKsloPS4XFa73Eq5YLg8RKsuScDNii3CzNQ0hLdXzgo3GE9fV +K3xoFtQIghthFZO2ja6SjdtDjmGhK1f3Et2IYubIA6qobNuyjmFxjSlRLYrXW/i4iz6YYxt1Nftz +ZyfIimGxdrmIiCexdmegYWGBeWGBi3tkkRg5ZPe4P331TyFXjclRjMQnbz0RJ/fYEm7wBMMyMhPZ +ECzpJnKWPvqjAiaJUQ/oEgCpLuwykwwhkTUCNjZ0adQiAlomX5FIkZk3SQ5pf/30kyAhF/EVlY0X +lHtEjzBhjwRoBQeBYiETQmm4avUFLFT5EkS5EC8ZkwcilHP0iUPJLhcpFhopL//zg5RSOWti1V39 +J4pPVDe0KF4JhyJdCGHsAZeQhyzxEnLuVVbydIMDEZbhaBw7M5iX9SdLAX3BZRwBwy+biXwWYxx/ +I3i9Mhs72Y5L8ZcL4ZejBxI6wRfO5XUJAx/NlUNzFJgQx44Hdn1r05Ocgpq8qSikwRfjBWur+Zob +gZmH+YysVIfdtJrPlZOpiU79VG7CSWDNpZyt6ZkCs2WRV5iz2GbGKZ6luDtvqTsi0Y/CkWmGBU/A ++Z7yeR7xOZ8KlY72+Vf4mZ/SiIL82Z//GaCQKaBjtZ8E6lYGeqDo6J8Kuof12aAI+qAQ6o8TWqFC +aKES5VNQtaEc2qEe+qEgGqL/IjqiJFqiJnqiEAGRGOpgErqiXpWgLsqiMRqjMDqj+8SgNtqeLZqj +F1WjPPqbP1qhPhqkFIKjREpYO3qkDjWkSjqgTfqfTPqko6WiUjqSVYpXfIZfVUIdmeUkuyGZ1iGA +RKhJCigWfSRNWlRFi6VNZ2Nk4JJnE1d2/aSlEQErV6g5OMkQv7dYXbdB1Kde0jGFuhIva5ZA/Nhg +81RYYCogFWiGjHQS0odFZQqYuqmOUWKLj6N8i5cFwZQQNBaITOmbSEqlV1pRpSpX+ykSf1o5KqkD +8hE9nNMluIOoGaQYZTpD0ZGLrsF4A/AF/ZGLeslg46ajDqWqNaIrEFQ7qPFD/zmJOunTFi2ZELK6 +fOXhqhWYEGsnYKQWf5TWlEeXpDsiH2gRSAhBAHAQOfPzQBH0frl6NnEYHG4nEMf0Ge53fovHm+do +Ptwqpxd6qsHorxEqO3IRrRuRFKm5bviTFQQHanLZErMxhVS4MzJWOMG6igo1sOLxru5INcuoENBo +K9FJrZFRJ0KZgRu4ET1mL1j5rU5DsjUShDLyGg3zscBGMu+KdyrQSlZjjVOjNUWUr3v5rwDLl0Mb +sE6jK9E4ZYB4i1zhMcgqAzXissHhiEuWsEWSnrgSpxZ7UEhrK+P6nTZHA64HszmGYxrkLU17LiLx +Hyf7IDr5A2TpT9mHFh5zOv+lSYUstrD2lrEPALH4iAO6hUstkZby0koi+ZD9WrT0qbhqxYddO7hL +W7U4x655FAgRwJ04249SlATb1GiJQatbO1CPe0rqRxC9txBgM5FO5I1nGxx0G5OHVjhte7UCIaq/ +JTGvCxJtQUZvYXg7iXtyNJjHCRM6sSWCW0zAFDOP4aCkyrhRyrhkkn00qxIdmzdz+FldMCdjupSX +EqaGxqy3dK4uVFmZcb1B20/TyxD44S5N2F+xGB/XGlkiK79L0WXgaGkRYECzyz8BgHF5Ba4+O7lG +0jweAiIK0STGsW2FCqaxISLtc7yJ5CUJaYdhkrT8aqrQez0ZXKAAjGup4oz/DFG933i9IuyHdBKK +jqIUx+Q2Kxu6/pS+HlwxjKiJ0di6ZlE016ZRIzY2QHudHYw114vDOhiP5stydRiCGtWw8JJwWVux +FuKe0Pu8GyyjwJK1zCFEokE4MCNjlZhvx4aPAAO27Ad1lXi4TkzF/2TFzkltS3xD/psQNgxCWgwT ++5sQatzCFGooceuze8OFpigvFiyHOidsO/sSglM5FtTDT2ykGSzFU2we/abGMXN9e8wQutIVt0pD +45vFkqMSF1FGtXM78SXJFMyexJrG86K1aYg++rE+vNg91dfJJxHHT1HJ4LkzlWydPswptqxmUSJA +BCTLU7JCttNCuJmEvEpD//tKW4WsED6hRz6EMIdbOcu8XRi8wY78yKdMJhK3Rdcnbi0xSlfEeHRM +nksRL4+jfuRMzUI5MmYZHNksNdVsgernfgxRSZrTqbxhTGEBzmMcL2E3nC5iyvBpKP6cMNEEEbZU +s2xEZz2BTVfEpsIBwfoRThBhz3b8nOdEZOere48cz9oMpCHthT880qZp0tsCxc5b0ijNvC3tPyz9 +0jwp02GWuEUL0jRtpTmNuDv9ojE90hqKokI91ERd1EZ91Eid1Eq91CbavIqL0z09pVHd0VM9UVDd +pCr91D9d1fC81SZ91VxdpGFtzVI9xWAd1meN1V491lTN1k4qtI281m4t1v9z3dV1bdVyjc2MHMV5 +fdc27dc6DdhV1dd87dQ3TdiCbU+JPaqLjVaIrdWGPbRpXdWTfaSVLdiXnaNZfdiNfZad/daf7YCh +/deL+9GP3diZ/aOpfderTaN7vdKjXdCxTdqzLdu17dHXHNe3rTatbaO97da/jaGbLdmnvdjB7aLH +jdbFDbDDzdzLjdnPTdy7zbLTHVaR7dzVDdPZjdvbPdPZ3dz+mtxAHd3Y3d23+90oyNTqvd7s3d7u +/d7wHd/ynVTXHd7kzdr3fariTdn5LaXgrd/9DdwBXqX7PdUFrqD/XaoHbtYD7t8N3tkLTqAJfqUR +rtvmHc90ioOvc6dckKf/C7GnTghdBQkRDfvheVDPRndKJ16+GA1lkyus/7vdE07gD87VFX6gl22s +TJmsCbGs0vw+zzoT96i3ZvEZj2pCQu4mRs5LSB4A94iVZ+zZ1T3jDm7eNd3dlY2xyFaBG9tpGJe+ +RJ4eQ7KqY/46KVuWqpyoNR6kVP6kNw7bF77mo5uGn/k1YsuOZAt58hHm5gF0KuHn2fK2vXzSU/7a +kG3l0bvmll3jc/7hpVsQlBm2VouADTPis3khHah61Twy4Jtkis6jba7WiJ7oVn7WMKwQ68tC/eG+ +tskXEOum9BsR1KUTBE3roEtE/QuqMY7e9Q3go97Wsw3Wp54Qwz7DVdmM/y1xsy0Rcpt8Esx+zG5b +GIos2rxO277+64tc6gNOyh7MxpsYM298z44WFjrRAVCrEuV+7juSymguiZ+u2YbO2diOxjIe4Nz+ +NOdDBekTBa7sg7A8ppRlPIh0Qp3uEoPBi+SL8Fe7b7q864Xe6wr+7jv95gIK0t3cEr7E4iku7kuk +zwtxphe98dbIc7XoXxp1IgENJgTdQRSfn6GupC0v3XE+77wt8TP68otO8xdc7zrPNDbv2hBP4T8v +0zHPn0U/3jxPKPO99Ezf9E7/9FAf9VK/oUFP4z1P1tV+9Qua9Lld2Fp/o9r+9Vuf9WWt12Iv0lg+ +9ALO9WVv4WfP2Gk/p/8aZaf8sUQerhAgXnQiTvKESWLfbuIoHkqF+ocrD6BkT7Sm/fZjcfT2meMq +YB/ImgXKmho/7qw9nuQkOL+Bka07s+QlRPBPDqeW7K2EPt04T6SMH/Fhf7ERcHUam5kiDObimB4m +G55Yxx6wcuYlI/pyq/bCHe8yr/hPkfryOdmN/rWoe+chSDmtxudjsbZOUccgAejUCbdz7O5sj/gM +Lvwe5PvIzejITrrla7qR7sWquxeVzveJMZ0bE7trIf38s2qcbrve/fDWrvrcT9dxb1DDfh/5CxBI +AACIgidCgDFoBg4csGZBAIgRITZgsNCixQxBAnwAsRCDRIgIDAwEEuH/iMCFEB4k4HDRpZsICmQ4 +cLlwAA6IJUzU5NnT50+gFiEGJVrU6FGkSZUuZQp0qM+nTaVOpVo1aVSrWbVu5drV60KsX8WOJVsW +QFizRkcs4FhzbduLLSLEqAFULlyfKikGJaAB5N8AFS64tLJCgZQCPg+oQMGiBw+ZNNMeRTvZ8mXM +NSsLDZDZ8+eLm0GPJl06qGjTqVVf7bx6oY4FLl7wXEvXpVyWPxfrDFq77lKVuV9G6CAjsU/Ysgdm +DKDcNWrX0aWDbd0T+nTsRK9n596d6Xbv4TODx5x8Nk/mCqgwGRgFzIIETy7CCcNQC4wAJy9+HDLl ++BUiAmisqeBasgi29/iAuimyi2AbcDXyxJNwLOginBA7Cy/U0LsMN/Swqg7JIiCF5s776Yr3IDJi +ixzceiiABLhooicl0ghQRRanKtCivgCTyIOBFuvgB54WYzC1ED9UEqkKq1tSvCSflNKzKKe00jon +r9Rywiq3vLJJL7PrMkwyrRqzTCnPRHPNrtRk88ImfZRzTjrrtPNOPPPUc08++/TzT0ADFXRQQgs1 +9FBEE1V0UUYbdfRRSCOVdFJKKz30pyzfLC1TTTtt01NQB+I0VFIpLJXNUU9VdVVWW3X1VVhjlXVW +Wmu19VZcc9V1V1579fVXYIMVdlhiizX2WGSTVVbTgAAAOw== + + +--=_related 005C1243C12580DD_= +Content-Transfer-Encoding: base64 +Content-Type: image/gif +Content-ID: <_1_0B4E44A80B15F6FC005C1243C12580DD> + +R0lGODlh6wOiAOcAAP///wAAAPj48CAAAPjIiKjg+OD4+MiIQAAAYPD4+AAAQPj4yAAgiIggAMj4 ++IjI8Pj44PjgqPj46AAAGABYqBgAAFgAAAAAKLhwMOCoYAAAIEAAAAAASAAAMBhwuHAYAFio4Pjw +uCCIyAAYeNj4+FgYAKhYIHC46Ljw+IjI6PC4eKhgKAAYaABAmAAAUJjY8AAYWNjw+Pj40AgAAPjY +mLjY8JhAGBhYiPjguAAACBhgqGAYALjg+MiISPjwyPjw2ABAcABAgECIyHhAGNiYUGCo4HBAGLDI +4OCoaPjw0EB4uECY0IhYKIiIiIiosKiwyMjg+Pj42IhAGJhwQPDYuDgAAFiIoODIsOj4+PDQoABA +iMjw+AAAOHi44Ii42JDQ8JiouLioiMDw+ODIoPjgyCiAwKiIWNDw+BAAAKiooKioqMDIyND4+PDI +iAgwSEBwmEBwqFiIqLCYcAAISIjI4KDI4PjQkAAAEAAIMAAogEAIAEig2FAAAJA4EKjY8NCYYCBA +WDhoaEAIaEBAKEBYgFAwGFBQSFhYaGBIMGgQSGhoQGh4iHCYkHhYWIgoMIhwYJiAcKjgyLCIkODg +4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAA6wOiAEAI/wABCBxI +sKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bN +mzhz6tzJs6fPnAQGBKBgAMCCBgEQFCAY4kOAFiSMIkUgpwJUADL6dGBkIQADBwmjmEhaB0MABSkI +0tgQII8fhQscnSAY4UMeMWOVApBgVi8AsQFGoGg6tCiACHwCeEjAUMCBsw+w2jhbBEvCJCsCaNY8 +p4vAo4HlDNAAwjFkgZg3c/YsMMIO1QEmKDG8cG3btwjtVHkaFQBhqK5hyzYQoevmrwBSq+4sEMLY +C4OWN9GjusWZg6YVRP7Jvbv37+DDi/8fTx5k0MJSA3Cx0qR9k0KadRQFrVRAD805RBzuirygACIB +3CFEQbbd9VdmAcBghRppTLGbAifQIMhSCDmXFIWEKWBFGkaoNxcAKggFhBNyUJcHCun55d9j2gEg +QAZoBHDBG2CoIQd8d5SBBQRmdRDHGlcw4WF6/bnIYmQ8BuAjkEJyMVddCTqxxhpmDJBDGQnQR2FB +USCoIIMOnvWhi/dpxsEXrTkFg5RUWomlaRcUMUkCSS4Z5JAW+lUcegBkEABp2B1Z3qCEFmrooYgm +quiijDbq6KOQRirppJRWaumlmGaq6aacdurpp6CGKuqopJZq6qmopqrqqqy26uqrsMb/CmkAsrJE +a60p3YorSrrualKvvo4EbLAiDSvQrTJMttiKvBGURQksUBhUkQAEpeJA1m5pmmoXWHEEqLpuu1m3 +3zaUrGKMCZStQeuuaiyxH70Lb0fyzqtRvfZm9G69AvxRQbQMTQsWQSr8u+VhO3CQ1kBjeJHuQBBk +Jl+nujb8cHMS0wbAsxPAEcNCBQM8kGsKt4pvvhedjHJFKq8sUcsuR7RvzB7BTHNDNt/MUM46K8Rz +zwf9DLRBMw+dstEWCY30sUuz3PRESi9d9LnLEmTaVQM9K7LABLXb9QB+8RWACFTIwVaUH3sa7mPc +eusQ1Q97jS3YB6Pa63mq3fCExgn9/xcYil/Dpjffqp4srmbkHoT3ZoMXJLe6dJOqK2iqrQlFQ665 +8ILVjxHFrOfuDnS4jG4TBDezWBsJW+KvFo1QvwYHPAC1IMY+csILC9TUBUtc3MYGJXNascMFRRzA +xFmX0HHaCYV8MMm5Fz6yE8wPhITtqAkJBG4JRUC9QdeLHPpCFhef8fTVCxT+wc7ThXupt0IgSQ0G +uRbnQb+Lb5DYyKtfgRZbMBnDiEcQ4/UPO/7SHwDKV8Dzscp1T4NI1Iw2QQpG8GUXlGAGNRg0/1xh +CoiLA/0YIoH70E4gPwhDCTQDBDCkz0KwUQ2ghCc6tsXwNAdxzrUIQrkbntBUFRxaEP+BNkSdFdGI +CLmV3xRomiLhYAjBq9bsBga5HUpRcwkpIbo+tbYbLq97FrDiZ5ASQwUU4WKpOuLN1EgzNrrMjW9M +IkFwAAbDfPAsrFkI1wjiAykE4AYjHEOHDoixCQgBjWobiJ8aB4A7RbF+Yaxbc0zAOgioMAAAFOAG +HQLHlXUyX58EpRw3iTNS7syUp0Slz1SZkFDay5WsjKUsZ0nLWtrylrjMpS53mZLzeK6HsMmBDq6T +Hs2MQAwDIYxmfkgQJMSoLcgsCA6EFMMg8IAgYtlDQcR2IYJQARKDUAAhCCgQAYyhEXoAhBVG2JDs +bAcCPRAKbJhTEXeaZJo3tGZ47Mn/y376858d8eV8kLIe97xHSUUY44X8RAG+TGAPe2ImDRLTAjYI +JAMzuBIiBSKBK8hhhRoNQSLQ5KIMaGAJk+wmaPrjzvPoR6HM5BwO/UOFMHQImn66oVccsFIq2jOn +PgSLCqizGTy84QgbJaFHQYolo/Rhp02ZAEpBRFTNGBWpqmtRn3S60zxRaE+g89MMmaVVgJr1rGiF +14sqeqi1WvQiEngMW9NK17ra9a54zate98rXvvr1r4ANrGAHS9jCGjY8sIRXYoO1WMbmsrG7gmxk +R1m7R2pRMAh5IgeaMMWCtG8ga3mkaUA3qi6StkJqeGFmUlc7/YU2eml8rGxvKVlc/0EQAGQwm2Ys +Z5aXHmWYjuvs3Kz4uIOspayaOtlxt2OQJAhJn8ElbuTGR9vZ2rK2tbotLbEbK+5217q19C6stDtL +8brKvOcF73bVOxBdFcyy98HsQTTLWdp9ViCvLYj9eie5GvIpIRBIrfmaNZD7AiC/D/yaGAsyBu5Z +rwJYVLAkW9eYzhGOXdNViIERXNqBHGWsEuljFPlHG79lMsHltDDIKgDfv8n0tN/tIEFyezbejm2M +wP0atYrbrg+DYH9mqVpyGbJchDg3ANCVMIYX3N+FnOulBoGdAvJorslAWXoUKbKTrTxcSRY3kQrx +m0Q3EOEX8220F4YfkTeAXNzqNv9KUOhtQ7RM3YKgV5PXZW95cXlnFBNNz7Hsc53Dy2dA30psQtbd +BzowpgbGaY8clTNBEJ1U0QGIkJgybZp5SEbNLNjHky20qPM8ajszJFmMVihXNfPS4rRZivLdZpAr +nWmGgPogxWEyQr6s5lITurq+bi+gWSloLAOb1Mc+rLKXzexmO/vZ0I62tKdN7Wpb+9rYzra2t40r +gaaIfbu5Sg81kNCLqiam+9mMRunSFesMxAeTOVOBqZUEG2hAKH4hzJru5CSBhCgHervkiSZiIReQ +dC9EmMEdptqTPblbIPAOgLwvwk9uW/zin/I2MFXTASFYJkWR6EO/C8aAiFLRIBj/lephnGKgrN1U +NethJxFI24YqeMAAXiXSwFoqFCj3tMI4TMIUZiCcGxCPMMiruUZBI5u02RPphlE6lrISmGhG4BCG +KDdDsvDyzcS8nPe5wFz8pjmqH7M1WE8oP6EuEKnT6Tnlts0IluI3EPv31RjPu95bovGpHMyeWmqK +C9KwAcGY/CDn0ilazP3QgvT0AFWD4Q1FIDa/AEYwhAEdYra4EHtunrXuVAEa7O5hpBTJnqIn/UHI +EAYmEJ21CPFT4zm9U4HoRqpy7c2MW/96EvAz9T/OYV6+2pWw/in4ZGXu3pfP/JP0PYYaCIQTiPnt +wyRGL4cnEFvmaukArHsvY3hE/3TwQAgnXI5HDBd+NwfyzUGQn5wuOmcV3LDO0q8/+d6EhCEGMAFA +LAKrA5FCiDADbvAG3PNzKTZTAkiABlgQ7TcD0Td9CsVkEhB+41d+l+N4TyUgDghOECh91AcBcoAI +bgAHvbGABcg9OZduxqd6Fdd8MBiDTRMFasBOhUKDNkgRe5IUmyODPviDQBiEQjiERFiERniESJiE +SriETNiETviEUBiFUjiFVFiFVniFWHgTxRZbyfZrXbhnwcY0YRhow0ZsY0iGMoYaILQ6/KUQ11N7 +0jQE1XRNMqV4ypcpXWSHEDMWMTQcBvFEc5heZ2iGXwiGfyYZKidrN7ZNPTAckP/mG4vWaOaWOmjW +a6oDYw/hNU2RagXhJ7B3KltoN2WISqEIipQVHEBQB+ynW6ATMfczNzuWYXODdwNxR4ZEa5NSL7Z4 +SArhGreoZMFFi01WiLJUipaIbKZWG4UHOBs3eYrGiQThibqXEJsoibW2ENX4h89FhwaRjZ1IYMaG +jF44juQobCNjHJuRig7xiALxLIEYjToFA3TARYoUj/MYOFxFLe4IG0k2aOs1iKRoaKNoSsZ4jOVY +jAIJkAQ5kAtJjGh4iA6pSgU5jOJoiBUphmoYQ7yDi294QoDIj9zIYCukGrpGKXl4Q2Ulearhh3H4 +jn4mRVx1ZUAFkhgWk3jWNzb/VEbKtzgxdGUA8JGq0Y+iMjmdFkP9oZLQh3z+djabwZJ+NjqqgVxC +p5Ft6F96+JIEgSw2kIiTJmmT1oiz8YjeCI+psxZl1mEJiInrmGFjWY+fCETAKBG31mWhFmYqpkey +eBBtOYnTCC6lp3oN0RSPVDCxNklcaWyVmBDJcpiRtohpuWlYaY4IEwDqKBBlwxatuAKvCDmxKF1a +BRqWU04qsEIntim6CEK/2D07kJpV5GUDIIxoiRA0hkkBBGCZUZoJMZu4yYURsYu0ppu1KUWeeYf0 +WCE2JXGwpV87cJaXeGaPgW5DqRC+eTuUqYqWyYqQOZ2RiZEJsRby1Yw9+YzW/yiNjZlozUlD2BiJ +2ohkIckU6vmNb2mQB0FpxdMDFTBlEkGf/vgQezmfsyaeKAeOoXIyhAk4BZE/E1Y7hQkAzsGYopie +0NidyxiY77mfANArO5iO1ik7J7SPQdmeDGqfwjEbYLZVNySPwbVq+jiSHyqI6aaRcaAx4LkZZZWh +3BKjLpoQM1k593iON3QBOFoQHroZQjmgKXVDN5CBnoU9r+MvIwqZw7ijm4Gi+oWOLLSh8HiiPbqd +F8qQmzSRsXmRDymmYBqdESmRXrpBZWqkaSimhHimAQmnDQmRxgMDxPMDZlABm3kQ+0g7ffRHgTRI +UGo9gFkpmuYQ5tQhn9YAhf/KpWN6kI/6j4c4l/4FY9cDXI/oasQZFAvKiJyHnuf5ELmWoJQaY3JK +SmtanMTYK2PAojHkOSXklFLUma7JnAOhnyWKEJdloFVakgXxp+Zpigo5p5AaqdyZQ5kRrMFFLWLj +k7gKMSvAmqraPBDWg5Dkq10poA96ql86rKhKWZCoGRPwBnuTicJVECk0ki2UPgKxmLwYplSQBtQE +Zwcxo9QiAFdwSZrBSDdZrG/qr2japgBLrANLsBYJqak6rZLqpv+6sAWbhRAbsRI7sRRbsRZ7sRib +sRq7sRzbsR77sSAbsiI7siRrVs8HG+RXR/anGaQVBZOxTCeHa07xfcUTBo3/EB1uQAgqWxBXAIC3 +OglAi4saUXH46oF4IH1KShEvOBKWdLMBkLM7Cx5LW7JUe0HPV1DtESYaoE3FJHEHpxvHEbMDphmL +V0BmkQOA4AQ2Ah/gGAEjdaC7cX9tUFWxoQQfV0JEtxn01Bhj0B4jhARC8SXySnQIYK0SYU5+WxJJ +grZqeyOaEZ8QMbUhgbhNkINVe7lL83zX8nOg4QKKsEV8cQeBwB9iG40QaAUsF02Q45j+ZgiHsDB8 +IWQv0jHDpz4z8IpQQhQWMnf+VgGNeneRgYACgQONYAhxkC6WNID0x049FQaIUBqC0hzOS4D1x0cj +OAPi5AUfJzusCyKumwL2/xEbDFd5S+ED15u9H/eCyUu97JQnTzAFo0EIqngFjTB/cUB9+Ie5+pu5 +QvFLfheAPYAGHVBu9JEGfIB9YZQGpAtGvOFMNBtxsQEIjPAENbC9+DUht4oBTpJzlxdNpqEUm1c1 +oKGW+PcfeesGiwAGa6AxJgyka3BJhZse93Z89tTCPwLDmyM2dtIk1ngQENx/E1zBPPRUfhEUUqXD +P8JvJ2CjX2HDL7xCMQxDCsIh+JG2HzVTMgWb+7vF+XKyMWSn6aIlGCBVfuMB2WcQgCFvgFG2EHMF +TdB1AcACbxExDFdvUVy7CMhzjim8ODlT+CoHiiBPmjHAUjR74QoVoCE+9v9kxFx7yCTgst4HCHFw +BBbsEBDgxnAsx7a3G4sByVAByWg7yRbMT4ycTE4BFSsIVoYhVkoJvFz8yjejuQcTcQaiJboxAmvQ +AGdyxlYDIJTpHlMQIy3XndTBAGygAi2HlKohAoDRH+S7eWVgyv/Vx7B5LmcipZuhFML7U1zlF6w3 +gJtByBVBA8VsUeF7JgVTZt+ctwiVVduBzZ5WAKlcfKt8fIGCxbCcz/Miy3w0GXqhJWKhAYZgFSTA +y6DFlDG0bmDbjyrAyXExJviqBhLNIB2iAIzwLUhwu+UWHLpbuy8yemoHtHNyzy2yAE+1t77xVIZn +Ad+XBO3hBFiwzYJSHC3//dJYkAVpZ38VJQAivVELHZINrRgfZ9KUaQQcuDE5rVA7Hb003VTJYdPz +zCesTNLEqc9W3W39O1BcBQQUoiW1IyNPssAFYc0H166TUbb4FENccEYZALkrSFUrabfN0QPsHAD0 +5NVRFr3wJMhN+QbEFAJyyHFLYBkyjUOADRsdMNguArjVhEx4vZ5qfUYEAbZP8VYCwNj8GE2iB7O+ +EdjhrNhR3YKtnIBafNWmHYQRgMGHktoJGrn3MXGnHduyDTFyIAhUNigiaNtwNQlDJSBCO9vAHdyW +4mryK9zGfdzIndzKvdzM3dzO/dzQHd3SPd3UXd3Wfd3Ynd3avd3c3d3e//3d4B3e4j3e5F3e5n3e +6J3e6r3e7I1Yq/be8B3f8j3f9F3f9n3f+J3f+r3f/N3f/v3fAB7gAj7gBF7gBn7gCJ7gCr7gDN7g +Dv7gEB7hqgGuD6umaWrh3IrhEMmwcZrhGZSwFJOQHh5BIB7i3qrhZOpBawikljufJlS66cpCLpTX +XFXakXKSOmk1+TqSrHMQMU6ZM56jFY7iDlvkGFmnd5qne2oQfRqzfwpIAiFIx8PCdxmbiQlgJmDR +I0QGSq51EOdHUL5AgtqvRo6QI07io/SskBih0Ppo57oXXlmeD3PlZhqqElEwKtKsiqis8nmwZd6w +ZX4rpWrn/oOpb66pGP8Wa3TOpoT+EH4Ta4geXJ0KlydO5H5+6V3qIgDCRM9JRZqVO4/IYwNQZlAZ +Gx5ToqX+RQtxPY8k6rZK6Wf+NCVumiK+QK4KG7AKlhoT6nl5RYbr4i4GqroaX7zakrvp6r8urLHe +NLM+ZGN4Mqj2ITO6zK1hAa/GqcVer4w62pdyMoOeHNuIa9a+qQMw6X1u5suONM3u7BuOrJ+6a2+u +59nK5wRTrSauYfY+R3KYpFkU53D+7tvK4R0+5B8OrnRkRyCEnxzq5GAeqFMOj4zkSMl5jVsV8ULy +SL5Iogvx5A6Pacou8AaL7ikuzbFBroMKizCur+t6EPE6r6E5rS0/peb/V5P5GLM/vvJC/ueALvII +e+EXtO546PNo/uxCL+tFb/Tpru5JJOFM3/RO//RQH/VSP/VUX/VWf/VYn/Vav/VcH98UrvMDT/A/ +X+kFL7BgH/I8f/bfSvRkP/RJb0FvL0QUjq8rLkINoUU/dPNBjlprSJuonpOwgVz4qq89bhB6z668 +CZM65ZMxv6/lSvPO6KhWiZI7ydew4ZMAcPjKPu1HyYc6RXpUkKcl/wS/XeelTrZ3SPch1OKnj88B +n5XQmiBJrqdezuQj6acNH+Vj7lkbMK7l8gOS0NqGWqlQ6hxaLhBcTvu/mvti/vAvyWvROK6kz6CX +REjQL/mPKTu+yvG6/+/8sfntD4EEIPY7QPoxIrgBS86bi24QSM4YeKr8ZlaXyajm/cmgmlkEjyjv +GfypxkPvoAoQAg4EoGAAwEGECRUqVFEBQQGEEjAEEKFQYgAPCRZu5NjR40eQIUWO9BggIYEBD0km +DPFBAwiFKFWupFnT5k2cC01+FEjQ4EeZED1erJjwYsacSZUu7bgTwIIGL20KIBJAx08ALRU8UNiy +wwmmYcWOPei0Z8GhE5Gy/PA14VmsZOXOVepU4U6oUhXCVYikgo4zAFAycJAwgoWtC1GOQHGQaoAW +JOhOppzQ7EC0NB8zRng4ccwBnCuPJm03qE0aG9yeTCmU9GvYZUHyBf/a+qNnrqBFx+Zt02lemDQl +9MCoEWGGAIT3Dlzb23nSyz49Al9IG4D159nD2rXsuCoL144HKj+IYwiHFAgHF1ZvG7SLFwdl2AhQ +3759FvG170cY/X79CeCIASS/0GNtJtbg429BkUwb4L/6gPADpAh2mEAI49qDMAAJGfQQJO426gnC +AAdkbcMO20OwPQU/ZPC3BjZUoIgMNxquuLcwi+u6gSJz8cfuxNuwRIQeA2+55NjjcUgBgXRSto3s +GqOEDetDa7gJlIhrvQPDOwilFqlTqMIJlngSthAtIm63hcwLQIstQFvxywFaPNPDNBVqQzWwOIJg +IgNF2nO1O/G06Ub/NjkatE/B3EtQv0J5yxMhH6TA0Ua1alwysyJ7lCzSBSc9CNHGEJqySumGWrNU +UPnLU1T5bFgNKlTtKwo3xUIrdT69cky1VblgfSqq4BRKgokAguBhI1x1YxXY54TFzrE/KlCgi5Wm +hVbSm8T0iLZmWUt0W7qEPW2hozQ9CDnyOr2U3N6E9baj+Qidjlh4o+UIVghWeJcjLiOaqCiBL30M +ToXmoyhfsYRtyM7yhgjgBig6IsqiTBnm9qOWylTozwBgoKOmjs3UODZhO3oY0o5KLpjgUTM+OdiP +LvLx4xUuVPcgrXJDyCtGZx7N4Qog3qjff1UummWhKXs1IRzA+OmK/ykCuDakgCm19IYaDhrDCKt2 +9OuCOAYUQIUSdG46J6eQu+GJqZEN9CAytQSp0om7BuDrsNceujMLYHCiYgDIMKMCtQ9CWlkKAx/8 +IMMRx9DvyoR1G+6DrpA7PcAFJzzyxA/Cm2uvwb6K8u0UN+ECK45QPAwqEcY59I32JHtACOTY4IIi +UHf6uIkxB0DzAOYuT+rMq75aocvjLp5z3+d6+ucPAHxDeKwHaDehH2CPEAwTN7ri8AAmeMP16Guy +i4o0kK3P81xr3R6A7qnkEPz0y+VeDfIDYB39hNAKVZ85yA/4V4H6/C9/+gMJ+9wXssctxID9UyBH +6ve98C3wJma5gv/36vO2HcWKdh2hAvnM94SdaRA6CXGgfeC3kJZYD3sLaeH7IqjChu0Lh0JL2Q7v +1EMfngmIQXTSEInoIiMe8UPTU+K2kthEV0HRiVKE1hOpqK8rgupVteJiF734RTCGUYxjJGMZzXhG +NKZRjWtkYxvd+EY4xlGOc6RjHe14RzzmUY975GMf/XgfHWYxUlYUJMoKWShCHvI1iVRk5Rr5JCY+ +EomS/BEjKSm9S04yky/apKGi1ElOgnI/lhTlUkhZyhWiEouqdE4kk1C1/1xgCSlEiF+S1CaJ/Ydx +CIGACWrVKyj6R0Y+G9MO5oQQAW5ofpc8JSt948xWQnNj0kRTIAH/0BDjkYoj5uFAE7SnpIM05EgI +SY3xOlIpcyoxOpzqSDIDcMyDzMuZzaTmSOhZz5DcE58l2WdpAjkfj2FsYWrKkgGylpW2BG1dkPlU +yz6QTnW6i52Ng+ewgDnPfv4to7/bKAM7islPAkBhzRHSzQ6ShRKM86Dn6pJHKmS0YLrrPhXsyGEq +6k4IEq6U+vxokHpKFp7+NKhCtWaFOFQHhFBBd6nqF+9Ysz2WtoeAC3kp06QoKqqVb3LMskBFFwKB +MIANopQcak/L+tGzbjStarUm5Jaa04HFswGAAQ1UHaUiL5FzAzC9KkhSM1XDdDWv36rKMsn6U5oh +dixr7SdjG9tW/46kRjQ43VBRgLYQ5Jg0IXsaZyGFdVmuepUjDRnXYRWbw9OmLrWmXC1TIlmdanW2 +Iwe9ZgVkWyGIcnawVHTKGLygKaSdLrSDhYAk9GaYHThVlI7dJ3Px6VxqQje6bT3Mf4CA1OwtE6UQ +2iVDbLtb3gJvQyJbCGXr065eVoliqJSuNNsLzfeyMr7yhWxrN2jfVOIXJ/NVJX93ql+21RfAJPHv +cgd83wOrL8E0KbCBQ7pgAkM4whK2J4UrbGEQYTif+/pjhz38YRCHWMQjJnGJTXxiFKdYxStmcYu9 +qGEYx1jGM6ZxjW18YxznWMc75nGPffxjIAdZyEMmcpGNTK6AAAA7 +--=_related 005C1243C12580DD_=-- +--=_mixed 005C1243C12580DD_= +Content-Type: application/octet-stream; name="Move To Eight ZWEP6227F.pdf" +Content-Disposition: attachment; filename="Move To Eight ZWEP6227F.pdf" +Content-Transfer-Encoding: base64 + +JVBERi0xLjQKJcfsj6IKNSAwIG9iago8PC9MZW5ndGggNiAwIFIvRmlsdGVyIC9GbGF0ZURlY29k +ZT4+CnN0cmVhbQp4nM1cW48dx3FGLJLyLgWSSx9J3siUjyTLniNnx32/5CobzkvgFxv7JuVBkBTL +gUlbtA0nvyx/L1/1THdVn+mzu1QcJBJADGf6Uvf6qroPv96rWZu9ov/rw+fPz3/yq7j/9R/Oy+v9 +y1+ff32eZkv/lRfy+fPn+59dY3zaazVHF/T++t/O1Zxztk6XEXqvNWaYffSGtrh+fj791eH63zFJ +KznLejdrbfdXIWJ82F9/cf4JRl6l2Sdv3PStw5WeXQppeu2gZ5uSz9O9g59TNsFN9w/GhFlF/6/X +/0JLG7m0sbO33oMaLDre3c/e2OCWIZ/QcrPPOsTpAZ609zpNrx/s7KLS+ubNNDYLKdeVwEGcdXTJ +ggOvwpxsWqd1BOAxm2hWGu8Tjf98ff7L86/3TrlFkiHvfbL7AH7nEBdFabf/+e9o2K0q0n6vwaV1 +iXWEVRYdRTVDQyrNIZGGiGwHSn0ocgffOeHxtcOVmXNU0ULyeo5KmQBSrzIUl8Dgg/JoUnQQFvaK +Wbvp24crBXIhwLPDlZ+t89qL6Z++KN8DSX96iNdBWRWnN0jbWUGQ06cvaYSLJmpLq6XZKW3i9OgA +YWa8psF5DjZaXRYOGTKeHtMsHW2Awp6QEmKIRjcesPWDYlGgQk8XB9BggtdyA0HkSoKOIctp9w5X +sAOTzfQUZpI1vk/fqe/0tDuQLQSfpjfppbMparGW90SYmpWN0RWhtJn3aQ/YONg/w8o2WXC0ijfD +BZh3QQ2tnGYD2h2oqLQ/wFCLRcP0FhPxdpFYSnh77wBXnWMuxmxA2f76F+fXH32ysmSMnb6LxQwe +rVShUPZl47NJz2HdkZkfxYZidwF/+iUy3F99E7YKPSZleU523RxnZx0WW/3rAz17Z6Z3SJzwTa/8 +9D0IBrLNQU/PyJt9tqTdMGsXgwF59d0DsghjtQ7TuzCDlAL8t37Pbvo+XEHZpJMc+VZxa0SIRGK3 +s/FgWiw//k5WTc+vJB2EGrd6JcTrZuuzC9AEJGRjKkboZwMFrlFL2eJUiAGO7HEJWyY58bTETQfi +HtLA7HRxZCJJg9lmAm+Q79tkUjEuGKdKnozvSsOmbC6hGFsGuPkjogJagLgfN9LIIutbSSaEEIPz +Mrw/PJBoTbZrxI3GwDsgAOUCtHmxrplgljB4+HLM5GoYEByCB3ztCiMwL62MEP1vkrwMQhcFH1rL +ZmM77uumAyEKjna0O7Rphl8lGfcXjuC6CJzwphRMXh0v6Yx3xe2il/OllNYs551rYkxHYizEK836 +Ij/4xQ38PiB5W6udpO4Ed+07gl+cW/ytQ8WsTvXVHh4jM8JtbJlUXx6TTJS+TTncIqBL4dUUD0pY +M4hkcAv4McIQxBiNi72U25zLZndPmHkx9I0DkkDWNmJkMyxhY1W3GhElkNlby/oW44SOJPWLCSWF +QLFKVA2d6h0a56z2eczw98jpgDiyF5bKUhAquGQ2F0xETsPeJfRy2Wzp9ZIKlba+2gWyLW/+jFaP +2vjUsyl2r2sufoq4K1Yf2KSMRbzPk0H4ekj0OBX1iHLdsdh0+i5ZfAJ8YE1xmLsYehB/f9RCmvwu +Ip2QhtCusB4WzDcTewu+605ItyJGSOsSapeCL+6mh3b2fcpWzjnrhbSFZ5yIYJuNSOKsBWGyUmj/ +x1Z3HA5oOn9/Mhr5FGKGscXQLTmKC52ghiRVjsT8JQSgOBn5hFDNvkl2LzNU9YlhTBN7v0crhRST +CFVi9ZvN4n9h7/cRY32Cex2zjb//aPnjLvDOed9Azx5B0ALqOuRRO6u0wKv6JDDZdwefQSPKT41K +R4CzR2TuETAxmgVSaQvOeshGZVwRBuxWZ3D7fqknXELZJyat4E7bJYZEwu9JbHWGz8Ga5KcPEL6c +CTF32I/FoD0EYXWtGz8A14DU2Kwk9aicL/jRUzWqDKATZK883PAHBH91xmYfFg4CZbAP28sftqcf +3QVzmhjnJOR/d0jubF5h/P8bnf2ANvLZq1RLA59ilErjpT4ga4/K+1P6cQZeFKp+Pp1KfaFVJtwC +Kg3Vc3AZCNsBOFyU8ghBA1/hMI7M5iHRkBLyOUrKA3zKGhRVpYTGUjaAeNbbR+3px1B1zLa483Bg +0/rfCK3fRdeZIoFQ3Csom3oqa/0lPUNWYFztLAJ32WVRd52RvtYOwaqDC8oIIRTUV8uvN5aC3Snp +dh9CeDo5F4Io1LryjIwpoa6obpeaWtMe+ZVAleiD5NqrionYktyVBk4wDtaIR0B6pRV1RVCzOkOx +7zWCC/DPtR0QnS0FvKKa2pT0Aptwcp3XCyLSSPdgySFegmf5/ax+L5WcIxiO3PNweesDxYFgPe20 +KvkmdRlP9b9gCWQOGmCj0tOpDHN9NcMAbG5RgAvzN5tzsw4XPzUKrP2Qig1QmAnP5dnC2LtinCct +8bTI+q4FNNxlzoG5oCR4ayHdYALnyAtOgoxc9rLMqmhpJ8Biy4yMMhiAto/fKdWrow3PagklMu2u +DdwzwpAVcwUgAkjxfsPaYaU2awlaOhTH5aGorJneBhh5o/aZIayo1sXjWtdUqE0yW4UPn10ZcyaL +nm9faNFsXwJnbdN2AqxoTw4sCjVerr6YkDEwcs67rJy1HEle0rY7O8aStCYL81i3N9DW1lylXvrZ +7eV7hwTOo2p2gDJh2m1UGXKHOrk1zotelfmGYsz7ByTWCJplEcqEEqbwKZVQWiwKgWwmwVtlkg5j +HQkxvF1aApRCkd0wFI/GE9Ej3a2m6q3uyuVKteCagfyuirJ0Skp7xdlWh5As5PPqhdpXNK8p+XfN ++6uq/asVI5MJPGafFtXOjotxER5Er2tl2fnIjvAMc6CY7I46J2shyy58W9nDMqiz9dgbz9gYqpdV +yvteSOvsXdaAs5Y8Pokm2E9AAtJShHZZSyK8VQ5E/S38/OK4HqLZ49ixKbVXM6s+eFfL4MabDict +Q8aVI2HTsmz9l0uIIIDkUw0RO2HyW2YoCnS+P1bNwPvZ/ZD1DZkl8PPa0vOdyhTCZlAR+VIj3uQc +gp06oipTYh+hFo5CInQw9SIq80uOLNK3DVHng1MyFi+V31WV2tVaA5Lormiq8pSquFLcxKJSR1IT +jNxN5l3uVI67YJzB2dw4d7J8hbfJRiOr6vJYVZ2xi3q39TE5B8u2yMWoVbRtHZijLNwIHrbH60Zv +ARqGbEzXzH1yV8pF/BUOI3QrDIqjNnsOZ4AN6WQECwSINvWf25LfWj0Lxh3bseuTm/ovzrhRo4r8 +WYKZatpMqfR8JpCbQmKhnfASXlRokdcXAef4tHgABIrZ2ZGzOpFgxwvBf4KLsofG44SvSpywDbbc +/adN940NjrBi/gaq9WCLeWMyJSCo41ZvJ1y/+HNWIOMdrIjQlcJxKl5tQcYL4QF8ijEvko+nD7LY +OY/wCCXn3XF4LB6yZGotZotwPYwXwkJXkOR0Gg/lBNwA8sk2ZVKtwU1s14gJLL1GTOX6iDk4TOO0 +KijrwkHttLOyWiQ7wm6DVCJk1Sxqx6FMGKr015mWSlG7YRBpy9tTqb7Ei4AltOFrGm1/D7wcIjUb +OPLUQyiafzFG3gPsup58IYncDCw3OLhKUngP0yLCBbsUJ9WRI0ER1ANMLWrT4qFcEgg5hy7Ybuqk +3t9ZOYufwP2yiIAnENcAUDxq4WZ7NkJA+8eke5dDdL0aq+i6SzQ9RtKQSYUmfNRYonJXgcqQsZqD +RO+7YS/7KaU4n3RXVrfQKt5V5WmBr7myP/Z+eZ48SLJ62uST/uSiQ63iaHgL+3ej2DFuC1Tf5g1f +5SBdFAnjM/9x/ByesQwT5wahbByp2k0kW9fBRCPObqUjChtZj6NNl84frxU+/Dm2xq0ICuzqwtg3 +qIuIYgfqZNkeT95KqIk4VV6kM+84FHQLDGuSLcQRRD8eND0kp11BX7JnnG4BaxuNHndPmu4YTcgt +OSgtR23BSjSx67BgHSl5q8RtOh2ljN9AnBI+CiOZwsudmgI11tSKZTEUGU1EMBnfUBl0B0UIuZNj +tUbbtlHiRvcTtsVP/3lwwpdkhBgfZT8Z9B3rCZ+WrUEB5fryrwRmt7Zl401d9pxm4/bQQrnoSa1i +T4QCBNMZlpkjwCWRDJfB5nCZL8p9OB8R1X5DI52DiP5AuQaa1HH6nB9/x0P/VBd9we/+iMc8G0SX +dXkLP5drEkNkVuLzH/nxK17pS34UY59Tz9tbpNfP+Pt/LOTBAMVWz6nVbaxGqm2EindizZu4pzU/ +58eO+/Z4G/+/l1ytpLwspzdJqW7kiyH/f6YjLnidm35bZpWG0H8eTEYkUIWVdU9Bnlj/i+H2S31I +tVOL3e3rF53s18Wl6NdxQjJflf0iecVvyM+ysw7W/KIO/XK0ZPu6EB5g31UaCu6/qMsQaF239E3A +oZoNDfySp78swa6Y6v6A+Ik4YEr0wWegZuqX0FnJwvBqbsk1u6bHP9MhiAH2ki6ycI9k/xkPfLHy +7EgbUFH2wfZzirkp66S1Cmf6SlqeFNrICoQ/ij0+61W+sr51Hho7HiCs87crEYglGyXXWauShYnM +vAMdTHttA/n3XQ+QjPdFIfUAqbtOMezRyDtN23dZJI36NLyOd+KGzvCi2d+Wa9TKZOUE/Lxfmczd +XXPUkRYlNiW6WCrt6b/W870ox7kZ6cys3RkIbHBsqOkWQrLVQe9+rsbF7LBJPMTAknF5ZtAWPdHh +q4D4G3X4RJ3D2HnXJ/aaGpeWgc8hSwK4T9edCw5+2TCEdvx5mM0lRq0QUe5YAdcGSBC2+ju69+5d +tF1R21fQ3DprJCnCzfHoSGiIwCGoEscdkJVqZsJF5olO/KixNyD/tkbUsE2/OSE5OiDc7YXBMTyv +EFZgclk/VooFjufG34kjkf7woAL0UychhS2LCtvSAbyW+L3rBG+bgF1FVDHv5uy1YOKKhFd9SSg8 +brkPuuutkySAqAgMbQb7zW0B66pFLFNurPwFI9b/7Ir78d3s7bH/iQP7b1KZ78atydo24Fvmg/O+ +Ww7sj8vHbu6eoxrTyMx0B0vHLVM49k5Y8TAIfcMuQZ3uyyUvpcNx66/a/InWn2h8ts7fgjnpVzJB +9Auqnwx6gAHwdUTUsG/KA1sHdXegC0V0oytRCqcraDG267Slv9tgCkAOgkJDKU6ZWk8pT/WUBlpZ +yym6JhNNKIGP3DIsMRBulE0m7LN+3lEWBhqizenqUoALvgsqQQ/SNT/NECyin7aDJ0MX8wm65gSc ++fd0MUpDnHH6iB//gR/NgXAo3a1/VMInGdvjwnnQkfrwYA5hBHLlkU/LxSpffgPl5xChYjmQ6VwY +84YOquDWKEBLx9MBj9Mv0IQILtvIe9gGmSMYOXI+GEcB34gdHxZkH5QqVw4q7U/aQu/iO5XLWYvp +C0XU9d4VmFpyyEKwUVEooJCRtMttH0OJPJRUUH8FF7z35Zdpdeyq39QtKkSzmLROVLFXi95Ijub8 +I8XBpLwU8WWjfRWcLb9Sq3vDWTPdfDOSin8q/Wmdyw0NUgHUJhZ60p6qCKPvWScNZOWrNLMWIiST +o19GhOnjorQYndiFZVnoUZl+rfcxxTF4krVim/cO9SeNZ8icBnbnxYqvEREwEh86ZisR95YVtU+S +XCZj0ZQOiX49+fFIU/cORmMDF6Sqnx1KxjGLnVid4Uw8mw3heKPVJC4EfXXSyLi6SZ++XM2Drl02 ++xgzyFoQLx+JxZ4eKGHk8stMfrvIDZmUxRpPZPmj2ivR7cA9aKbYRsXXXyjji4qN6y9xfDi8KCHg +fH+7r0KY7kRv25MTN95u/THVK4CMlqMvNwlcnPw1Km46TFRdJbM5TPQlKN56F2ybVO9ynNgA76aq +W4/mFjzJcJwLCIl6bqTo1E2dpTyh9JS4PDlqcofSBGtaFZBANrnFmfngdo+s8gYgqGvbD470T5xv +HFvI0fHkDV30WoJUhXTYSSKe7WFJh+KamrrTfjYuuqdsjq4Zljmx1HdLt5AP9XMVhQm1owKsenzu +t+pLXhXYnF+vZ/3blvrQ3tZWtnd26C7DS7LdQe+J+HDj7d/mvtyjEJP3ox9Tio26mpRLs/6iYJK3 +qu4UpEjwJ21wXfGUDQ5u8952cY/Pdvufgo6tcbBBd22RL70Wv9Z0gN6uC4zNkgv/Zgx3v75KRjSq +yPuGw+imEdPadZjG3QFBZVdj1Xtbx7XfUUvj8agCEo93Ona74RrnuO565bu4q7Zk00Ecqw1/jnZz +7+6Gm9fHCXTHP9d+Vuw0pcC/gjYncmh/qUnEudP3YOUNjeHF/ZtZuhw1DMTsoapH+VAU6He4rrq9 +BHaHk+DtddvRSfC439XdkRB+UNzaJ2igXcctJXSwZP2d4w5Ndbjv0OqFWEbdxVMNisGPBoYn6ePe +JV++qXv/tPxTHd4FqfDLDowMUvRucL7uVOwA1pEl0OfOIcu/P/PL8/8Gx+VcimVuZHN0cmVhbQpl +bmRvYmoKNiAwIG9iago0ODIzCmVuZG9iagoyNSAwIG9iago8PC9MZW5ndGggMjYgMCBSL0ZpbHRl +ciAvRmxhdGVEZWNvZGU+PgpzdHJlYW0KeJztPGuPJcdVivFCdhx5Z5KbrEe2lUvwknsdptP1rkow +UYwTEpN8AK3EB5tPgQQhHGTz4/h7nFOvc6rr9Mzs7qyEBbtf7lR3n6o671fVl8d1Ufq44v/243df +XPz4H8PxD/91kYePX/3h4suLuBj8lwf47999cfz4Obwfj2pdgvXq+Pz3F+uSUjJW5TfUUSn4Qh+D +0zjF8y8uTt84P/93+Eit/Cvj7KKUOd74AO/74/N/ufgM3ryJi4tO29Mb5xu12Ojj6U/OajExunR6 +8+yWmLS3p0dnrf2yBvfPzz9F0JqD1mZxxjlYDQCFz4XZ3eK08ba88hmCW1xSPpz+FH4p51Q8/dnZ +LDasSt0+mYLJfEwNEuwgLCrYaGAHbvVLNLF+NiwAfiYddF3jI1zjL55f/MPFl0e72oJJn44umqOH +/S4+FEIpe/zkP/G1O0k0Trel0eoWbY9BuyV5pNFnp7dg49roZADLN/A0JHc6XJ3XRa/Wr+70+Vdn +wMEaXTx953wDw956bWDlmWJAH0Ad4MKYNQDqAAmAOuMqZlfT6OksEg9eDN660/s4VVAagJZZ4wqY +p6UA6eFzr6z8WJxcfMxm/zb+DD6EdEpnBawV4PlV//U2TqQ8THo6sN/fOSPF1JrwBeVhqsQnvSZE +/Qj4BqDnfTau4hh7TK9WTMeod94te7E6MXG43C7Vp2F+EheCyR6/cU6Lj8HEEfkoWM74QRKQb7WO +y2oadxeZ0PFee0OQcU2NDNppjnvC+AEgwG9byKjtAmJjZtbIaCKE0AIINdcd5iUtZJg+LRaA4+z9 ++YFvoIh/SArmdwsIj2e44ZN3mNeMhzpMtvgnW3JHUC8VlHIc4QV5KoZQiJRQ93zvfONhc2pX+d1U +Ct0ou4DmyGRqaIbvC1CTtKmUj6vALUFrLmGXG26GwUCSzASANt+fLohNs1oA81gSKsYCjzmR6ufs +cV1vABKxtUlvjrwkEnNfzyARDghApdVzyh5o/QRp1Ihd/i63W0GCEr8QDzHVKDOWJFY0/YuplKxm +QRFUUbYrMEpssozLRzpapZlOYfu/U64E7cKmX1BjxqAsh/kAyg0Ngo6jCN5Xu4l0lmci7DH1RBxB +MN8mNA5SzUW0Yh5lVFVX51vnG7AdEdRBR6+q6M3SOrB3XhX4RRJ/e2d3+Ru2YNegSGieorgbZer6 +bWdiFE3S7u+g1gnahtPf4DKB94LtnxBYvpi3ORzYp4ePmaYY5Lrb4mJV1+T557Sta0FBHAjzovn8 +/vlGL9ZaELBjp9ZR5FAG/hLotThnODX/HCEBM4EN+BjZzieDWrB6c4m7VzcqgMsJpAVtDJNnn+6/ +q98Z+IsWvD6jq98JyxJcU5xpjd3k/rBRrCoBrQcPp2CFI42eXk6mZ3SfDrJKr5ggy0OwmRP4vTPQ +OIHxke0B2ZU+CWNS7q2BHCZAt+/8xdw24o/HXMY7/1xv9RZ+ZICNU/LecCH/OazHqQR74NzZ5J5b +2c4eH/dPSBccPj/jC2512jFtwgWB+JNt+PAj1Ps22VUxaDf4AoACh+QHZ+CgCL7/6V0ctKBFuDX4 +RtHgBtZmXGMNMgvV6IIy8XveUsfE06xCV3i8u5em7t48A1+vPg0OzYHB+gFqByAuKHlmgzsoJkzX +guY8HPgGWeTXdDitnyOYgxK2yoCyVV+Rc9V0qIJVbBV1RTBX1NekkyvbKsuR9LakQAG1bvEQFw5R +yA1IjwIuNhxxA71bYDTwONNSAruTLDFXk+OLwdpx3Tos0pikJUTNLJiWOg0McnXLfpJ1rEvW3L0l +H4D7VURLwi2RWnTw6JPPT5k/Vm25C0Ubpyk5T7tzhPhNO86IfEnwuwRG4Mf1sH/wIRr8QebboiaZ +B5so8AD8YiKxJ+klIpDDomq5vYmC8hycuutt1IbCKVOBLVSCRBjjSRs5ehtCmIxLHsKQvnZoht0K +WwbbHsErSdGc/vZ8Y2HNyWr46ZcE+ryj1kDE8En+KAHL/wI2p9YQUHk3C6PhE7CxwXOBeNIMX4/8 +NDwErjJgfpj7QvLWX/z4fAP7dtY7Brp4CjegUSDiVGxzJdsDZt8dAW8QXBnK0KSa+zkGIMkRKLLU +9My30dxCWIWOLS4zGXS/2q8DbhIk2GRNCcjUK4jrezRKH30TdZANPgd87c1H+FOD04S8AgEfqGyU +9psssLDBZxmStd6Da2iWFYhp0T8KS3Q+ZGbBPJhBrxZ+oPC8eZbSXps8VN6liyljBrf5TaSrAcL5 +7msrTqRqWxRzK5gqpgj3Sf+4hTn4daW/H3QevVrNHVpG9hHReykzhWiYO8pki9QjC4IPpNRvCSQG +r4d5WTwbJVnovg6ae5ujWWVnn0GmLBsbfNJXOGNwTBTd7cXcodFanDhoipZ8ckrNWdrqwzg3+jB3 +u2FinC8F4uTeyk6GBIjr5jkk92uajS5+xkzk1cb+4lRDwkQwXWx9d4TxzDMiRc3TFeiKA5V5vuI4 +sQF6c/Q5pdRYdovlzvrYNTlgt/hfleDc/yJ+liMgluNt0s8GK/GNDuzzSybyTSNw2eiCM0riRglN +fr+UPyPpZ7IlxLXqFNAVUh4zQ2TnZE+KFNXgHPafbKoexDrCSgA5VTAD8MfpJ1mXhBAUWyozpGyC +w+hUtuQcRxzD18CWQtLoieSTHGT9gl6zCmn0mkUF8QK+06055V0F0+JR9n3ndrTCqwKHC9zZCIOr +AkPbvYiSpSBmz+Uedf+a262G1ASPeQcX7BJjLrpRSanX9cD+Hy14M1hNUmtcj8bp41f/evH7Cw9z +WXAvypN1xSJeefJleRYsOsXHLy4UuCD9z/+of3q7lj8LnPbXv1380/GPsEX8/+pbDLlWBU4MULg4 +Cz8FfIPFQyqxmhVLflOUwiTiSPHckH4ie9/UxPUZiL6YpDq5sPAGWw4DQpIeEIJ/dhSUl18TRsCk +Ld4ylDCiA2uBfujkdt4TtVXQqpPbxsCpXZ713enVBba78iftrgB6PbsDx3SBFXOCz9HHpqD3eJPG +GwPdsYqwkUQk7bBb2LyCBbLN5z/7bje4eODNW7/EfdJmvDtliIChkvaBkW9Bc+nJNec68Sijt+O1 +a5+y6MqPr3XRBqOqPSWotfNMLCKJhdagX0gsIheL8ow4wxku9OVP4owC6DVxRnC3iAUZu0spSwb2 +GRa32I1KG7aDuwPW47vDP2l342YfdndmNbfwfUFs5/v4GlioYrfzvcxCyTNOfo3LuJ2ToyGBcmti +nAz+HnGyGcx5edZpbbTmCr78SbQugF4Tra3dcjJz26QsH9P0jKkPB8onvnU2uBVjB/4eNol7DmnY +M/7ZN7lBwQPvOWKeZZe/M7obf2e6PTBjNZwzvf5DKgl2lJJHzn3+q20ut5S2iRAsKJ71P5C1Iz0e +Kz/Kg4k8TvBTVRsHx9zObxc/p46inxObOmeeaqRR59nbNB41wQ40akhYUMTquDF2nWHLo3mLVUqZ +tSmbmcfLsoXxvMA6Hmi8TDq//zDeNsThOjbZBNcqYhqJPGSW5yIPXAzOh4AKSyPJI8Ng8Amg1IlH +ViVZNaX0efla5RpfSOn0V/3XR6X1zqvEompYAoSxagGAip4/O0NIpnAHbPCDDgk+sjAGnmQDGpyH +mfrP759VgtXmrB3gT4NftFPAqBEx+D5cKApPRIHt6+DM9tu3q3sfZbbfvl29niizfR3fsH17e8v2 +07pxMxpNFQ4CNfmy5/GyQGE8L6WOBxovk87vPwiD22Rz8+n/YgZ/xn69GoN/JDH4M+LqZw/M4Fqb +mcHr4Mzg27cLg9fRicG3bxcG729vGLyObxi8vb1l8GnduJnVh8aAni97Hi8LFMbzUup4oPEy6fz+ +wzB4sNWF/Bow+OvW4A/N4Cu4cROD18GZwbdvFwavoxODb98uDN7f3jB4Hd8weHt7y+DTumEzJq1d +w/LhmGZhmAdh421w2rgAuYxvoWSEtNEtQgQoZXwLJSOKoIyIalACg5LH6/sjAjuUDQKFtZTx7Vrk +0VcVbCyaWheqZ1YiiFow+c3F8w93qqgk3kyoh/qHUHQcSoObSrk2m9IgwRcKCbeVBuHNKWG/KaNS +8+FdqumuliYqC7a0PYN0ENsnt03Yduj0bFvYqa4e5iLRVKybW9mf8LLy3C3T4ZgTb3eqOxr6oUvr +b4Dvek+h1KLMgrupPLXpq6SCzC9zzcoazzswKV7nlRXW8wYco7X3rArVWYIjg/XU/B2i0K+6KGy5 +BVpoHD4IuBGjXMoR806gnRZrKn6OB2FepjN76LcpZkbztrnSRuOi59uqpXmqt7H2fSy1bpuPC+15 +d02TyzU0uQz6nnJ5L6eBjP19qmhZ2jqBXloah6mpLi11frEu/FHZ1Z7VKdOBsF+tb7k6Q86ozeGT +BklkfAaJdsS9kyuxACyVUeWczqOqHyDOt72O2tV6tAwUK9OKBXAmORLOB/6vTOXEvlBep2VAu8vG +VMgvscxqVsd71KghjCFy26ewbQA/DMsTeuh4jlHok2DrFD+S1euOaai8Hrn+zQ1xGjbdmBeec6F/ +46zXJXpLDVFeNUPgFTNYtyiKwgS8+YIVU+X2CcGn+BXz5+dfH5K7zhuspzamO075TWdOhsNBau5p +HLyJwUPJvBTG5iUQVasdhSFczvvYxGib801sYZzTuvAIrV/suMX2ROMm2TowXFxWFXaOKe2y222n +j3i7fGm0SOBQdgUhKYUXyRSTARwaK6l2dfsRyV/1Dn8W3H1UIkKQCpao2x7cuGkb2bZjotvMrCJr ++i6aI6xhcPCu6AUSh6nFJz8ns/KT6sZodiyiRZX9BEk+nZAX9o50gsSAjGolnCBRi1bGUrxgQmsT +KId9TdDLOmQCkkPiuyUBGxWd7QE9GfugM3VE63Kj8OhSQjQAFECvzW2nKVk0Aw52Y3KDMLK0sdj6 +3b+4IjhvYUAS3GoCg1NdtnIiSC9AYoMwEYVAe/RoLIiXAXN72d98hJ22TjmlOPhr+nlJ89P3bHpa +qUNiqKCwO/wNEP2ovS7toqASkw/9UHCWZJsl3bUFGKD2UwQAbLjCtPQCBwC/gZiquUnBmty+3jBe +1mJzRxyi1Ngkv/h+juewswjwYxJ8pew9umsNPDKaEb6wOsiAhk9CZjWMIV+Y1dhhJYSQ+jn6qX6H ++ns2HMNZWaYBuArhUdlR+o4mkI+UMneN+5HiGYre+839VPn4OJkOshLs6MN0ugC/mQ7ZovEVu+Ke +CsU4qSn1Ls9G7ISTSqoiSFn/7nol2U6w6KFvop5asrAAumuhWH0fVVfJHuUFD92AVtcPyY4/RWJE +HfXQvTmeQWUdYpTfENhNPngpeik7hzSJUO/lwDflo9zTIYHiepFVYgdFWzNnvJdV6j93zVJN7XSz +JBqjup7/4xqCUipyy+3OsdumK2SJmk5E6mR3O25Z2CFnIJgAS/GXeBpJjBl5gN0OAPLub4J+pDMz +N/Np6x3Ps8xu7ZiWy5rCwQy+H6oifTUeP5QufhDPyLUXGcr5gbMcMCk/7O2K6e+XQPJO9kjUotO5 +BBDsrhMD6ML/F78+wfYQwFb3NjkbDqQKIZfchM9mP/Amlpc6nCqbTnY6tVnm4XRslaNdpmnfi3cd +jGf1OgeKGCCRrqxGuv6hzS9LGbPqwnjQolP41/nanGTT3rKl0xW/nm8nYS8m6WDN0AneBuX7E0is +eZZux2DfW7YGK83yK3fJFn2n7AvKVkkzzHfiPIBhO0xXK+RXyddh+JbPjAhH8QYqTX7yuhUTngTe +WgvpnNbPe1JAPKA+JlpnwzDcUTJ/zu9fKof2I6iucJyuUJLuP5HKFJLBo0mkS2a2RS5rBm2ya5fZ +mbGmWmSmEMs5DvOz0eLB6z8iKFiU5a+SvSQc0C9R292B4MMcS1Rkc7l8iTOl7IyIJMriobKXqAnI +l6KwN2nTBGjn9rUnW09uyCvyckhLScuXVN11cmLrX41XPg03pk3VORhtscZYyXvdUccr1LumOjRT +hw9T8OLKXrgV6M6r8RjOP83nuJ3KmYaxNsa4eyclIPAFDU5HpcZAQPSAn/U07Yf9V8/NhtNfsnta +5nzCX6BAIMns6bvgO8QI+OHooWamDxjw9uuvhbbNcPq4Rhlx0TXIaBmxAMjSmmeFvy6c1z5nlQMq +ZPwYox23Dkb2KV0oJNzXyKW2nszmuml7S2StulBKjB3QalfYyT63cHSWjgnvXlWxk+xq7FNPBIZs +2ltl/CDWGO6ukIj+vyQwkjHmJp11wRX+A5sXu0PAmtI+nDhZg5T0x3eKCd6JgS72tzC/lADjTEoM +wflAkMsPuJRsayYBplDp6ygdrcbyyoqZORFiRwA/bpUVLwjdO2cL4Q+GNMOBaiG8nehpR3Li9SjK +hB2lx1Qd1cUa/7C7ScgVuyPteJ+7SZRX9X5fPEISAIsevMzv5sUkPVw08hi1EBAxjrePzNeY8NtD +8liy7Wm5vQIfrkqzx+9mgQXhClitAsJ4RMS7uQoERI7s+/f5R+3xe3SzSX7uAXqmtTLGhRe4xUTh +yRr/0reY3OFxUgVh4j5c8aBj2IUDfUIa5QkwFo4J1xxIgdddeRhWMcnZNZ229wPMZfSpSdAJl6Ct +Zueysb2MTvF+xivGmvCQcr5HEofK5D3/KuWIBtNDHWg1BFRY3mtaj7SOGOmUKBis4e3lh7HBju1z +5xoSslfMRRPb2sTb8Aj+lE3DjZINFJEn38fLr/fbbxMqF801l2YvrSddNNchvTAbBOO6U+sVd1B2 +7/isNOZtdiwBRu76fOOh5210xfqsSbMxVrUZHRRB1Gn/c6iFlpBJkXQtkBhWkLgxRTPVE9bhWi76 +hl1BIpwMGBpdm0oRs8ikA/mlxA0Fn2TbEXzk6Y9b76YuQt2y8eP1NrfefHsQSyl0aQvryhxuOSnF +UERv0wTXUiqJZt9evrzpwxVLCUOeR+iJ5dCBVWtNmzXZtV18ii6EdkP1hOTkiaQ40Oe2yQEB/x5m +gSjLhBGZNcst4m9izO0tdJK4Xg1UmbFFeoOU5uF6yHbM4CtTwUe/yY6Cr9eYDr1ymYw8zfQzJExY +SV2UptiWMh1C8/a4sbRiV0vWinwKO3Vb5nQKl3OLRnIj4FWKhrBOKIOTfyCJOos3ucPSQsqhWVa8 +JZiDp22wTjhsavPwvZDUqBEddjtKl4iv+RK+YIYWvCNdQEWYeTLhyKdN32iPHadloryQb76p+peu +OQe4TqK0S/K40WpgTP0Z6zPaWsXFkPeiNkmgm7FnVYKNKRL0n2WdGeNoVqVMqyR7PJKSZO+3+Ng7 +p3mtlRGTYL4HSPRaj0p6c92UUOoVCfJbYBGnwL5zief9LnSrcUPiyN7TvTD/A6GO0ZNlbmRzdHJl +YW0KZW5kb2JqCjI2IDAgb2JqCjU0OTgKZW5kb2JqCjMxIDAgb2JqCjw8L0xlbmd0aCAzMiAwIFIv +RmlsdGVyIC9GbGF0ZURlY29kZT4+CnN0cmVhbQp4nK1cW48lxZGWYTDuxmK68QF7NMY+a3uYczBd +U3nPtC1b9sILxpZA8wZ+8k1aiV3B/n9pI7IyMyIro7pODwtCKvpU3iO++OKS9c1xnpQ+zvhvffj7 +19cvvgjHf//vdf7z8dt/X39zHSeD/+Q/8Oe/f33800t4Px7VPAXr1fHlv67nKaVkrMpvqKNS0EIf +g9M4xMuvr0/fO7/8L2ikZt7KODspZY53PsD7/vjyH9dfwpt3cXLRaXt67XynJht9PL1+VpOJ0aXT +o7ObYtLent44a+2nObi/vfwUu9a8a20mZ5yD2UCn0EgY3U1OG2+XV77E7iaXlA+n78OTck7F05tn +M9kwK3X/YAoG8zHVnmAFYVLBRgMrcLOfoomlWTcBeEw66DLHN3COn7y8/vz6m6Od7bKTPh1dNEcP +6518WA5K2ePH/4Ov7R5RP9zqjMI8wQlpNyWPJ/Tl6S/nOzd553Q6fXXGZzdbF05vwW5oo5MphxC0 +xt8VLMuaePoUF6udgr8e4LgU7FxQpx+dcXFz8u0MlT49OcPPJkR1+jU2ssmGsuuzOf3n+c5Oek5W +Q5M0+RiDg27uYJbeem1O751hC5LW8fQ2Tk5551Xt3VkLfRpoNauuTw+rsyHwJj/Ks4Spx9NVmVA8 +3Z5hnNn62fEun7Tf34ae5jm6OI6onIERs8xin09xJGsUiCqt4x14srM3KL7ws4ZpxtMNjblInHf9 +kHewx8akyPTg12dlpzw4iSsb8ftnEEVjtDp99e3S3MK+37Q+l3FCUrCbdx66VKnrnHYQ5VWDcBgS +66d45jAi7+YJraGclYrJlVXCiJq/saiuM56p8yJdVifWKZ9H3lftNIcFeNOCcHrTrZLWQXvItljs +dEahc94HvnXv4+SD0i6KfS6igFog75zU+W1rfTjgo0qzrwfcz30txXjAPz4reJxdt6+0cY9pkUXM +fQpF+Kz3Vdl8WEHmXT3fO5ApAJx8yD/GkzFq2dqqMuVoYMlVbHTT0jmcfnq+AwB0KrlRT1Dv85pC +sonrCS1qHAkVgQR0EZtN1ag6Juj/D/AEjEsWYQgASQWApj+f0egoOGjWzU/PYfJaA8zQCg4cfWic +RaBd8mk8dlzYD6CDqGzQHFQIRGkkJmcMFbpV1m1ZTYWEUhTvKjcvEDGDgS1kJ0RysywpmMglkYZ/ +VDAgoOEpECDBD43CTMEikwEMEtP6QU5Qoh62tKZcPz/HKegEJpbt8qGYHWhPy+x04j418zBRNVuY +k6hmHSzUnWPTBJsI5hNogGnmbVas+8EY4Yxoc97BuQUfAC2uBlDNmyODKuFJ/27tlw22tFIRprCo +ZLAjJOTjRkRQfoUIE/ZvZqviypy2UT+FXsFC53XluWZ5A1y1c1CdnnesAGdlErS/GQhC20HQ5p+f +7/RkrTVORnjCDtI2etpgCk1tf4/CCSAXbDUFgGzvwzYCe/JD32Sw8G8HscfndePESdAS2MkzHNju +UsfGynAanVgIfTJp4rIO6Dr7BASNbFNlfU67TsTr768tiGDnCZgMQYKgncvS7Wy+6zy/h08R0Z/o +AchRBQ8+445otKE6c3sZDqzO7bK51z+yTSALR3O/lVX7Spw7jf9E6p9ZN1L3t/D3BCYtVc2LHS0o +owbjFPNzyqsucFPw6KwCyAjsUiP2cRs4ilRwLlGFTFd+nZWcqf4N/bUMBtOunA7NMhGP2wYNR95I +VJeCFyITX/YHlueZj8LgTDS/iY7ndn1SZXSyi7CTwVvXD5+XDCjYSSwBCJcFmtbFyyPAejL4Mb4T +VJlk5ylDPx/Di/gYPRfDCScUg+JGv6ClN9wYMsVkzTuEXgAEoD2aCiBPOvpKjLj2KhrTGUbywC86 +1SQkk/skir/HLprNo8PQOKKaoZvOKcn7ZVRv0wUNFrGEdl4kPjcSIj4FVQ9Wu47YbAloRYVqevFd +7rzV/RL32KG9dbPyLRADfdVGvmJZphNMwLkbeHsB4SjCwBnHuzkUEL3tvIgiXcjM2SMnyU01PoNx +3WxL3Gb5W0N1BkVc7di+cYvHSAPboqrjdzj67MwSqqhhhdfOGhTG6x7LOn4o2HYyFx1LyLMCv5cr +fpUA9iLRLObVPOGqVyFColblqGfdLVkESAYmotByjIgTrJF7zHzDORJKZpgYPuxixg0VJxVbvG5D +ZQRDWU5JA1oQHXhA6ODA4b31+lt8NeqYNoi5GEYgm8ycoXsolDIMCUVgIXUmdSdc4UvnIMAUVty9 +g4gIz5uIdh6jhj+6Vw7GdGhQjniDRRCRLjEBH5mnQeHFSzyN9sijE0yvYSXgDKWenS+BCAY/IqHv +Fjoq28dZ2ZK1nVdR1XdacCREy3Gk05XcpfYMEpiPlm31RphRDDNIU1xU18MU+cjH1oaxzNsNmakS +CMcHzE5bq5jwM0nmHnAfJM0/c9XLIGD8FJKvIMDle5GOMOtOZbgJrNIpcZ+BLRZG0xrJcQopItKH +Kot2ksZuWB2KifbjV5W9n6gcmc26N6wjKvYvMhilWdktr2FlCfCPh85jY4iTVcd7WSNEjkekgub0 +1X/jMmHHrBA/V2QmFwyj9guQFDHhtKLzlyg8QaECZkGl6AY5I9SIJ0o4kKxJBzkgHJsoFsiJwjrU +OHJBAaZ6wyakRy6A+dptQdyQo6GtLxZm5gENaV2CqvQcZWvYjBTZXaQoZDtv7g4L4S8GGj1cCrb7 +DgBcaRWQly/UwgDQqooqMnF+iE0rMsyUoUzUmA03ic2O/JQ3cZ/CrIzsAUgzEkH4q1MeaNbWyCzi +gm1kSYTaLUVnRKzoqKIASnJ8g+3dd2Jt9+NlN6E+QFqiM3UVxe7MMJnkqoT8AW14mL2uXhYmpLmw +MLl9wv0kGDWhX7LlD1lgQMl5OScjhUPGMFJmNcyxYASKcE8Cs9czvfPKcrVn+kuq+hn8cYb5z0ng +IMRqSI3FpGvv/KyBcn2oOeMix6DJPAxBRJgYc9JGQboEcFeanQX+BW4qOMdjwIhF2dZh+xtBzP8C +4uMU9LkhiEQLbgoBMiAszQvq0paYk0d9WET2xRfKHWFAmLqh/H+yPP/vUpqAb+f8/3OwRrA1gFDv +woLnGDxC0R1Kh1IIDEjzk0GRq08/zAEjDUdNv2L+S1ls/P7yt2RrC3g6ZMkBTcoeM4CbSjn9NiPv +x2wlNaodqZKKuqSeAaQJtG5ZTz33GflNgHPDnByjeU1AFvaD7gQPDhRZAaDpwoOr4CPqEkkVhSAI +GjsDWFWNC8gQuM4End4ltaPUIpvSRpsyj2dLLYpXg6aiUSJV5eb7VoJBNiKvVhBYCaO/NCGe2F3V +caDAD07Kpn0SYb3AAuCt5xBAylELGiL0TAGEagI2gnNVRRnR3I/f05hiCnJIka1xoa1JoJ6J8+ND +x1JaRoTZIHqX8QhpfqLRLToz215nyPYLTg4/B/EcpaIGTjMO6+h3bs9CKSQI68RlPlrO91miYC2H +uFOUbGRKXymL6g3rAd4AkQMw0ScNr8BsTEwPwVkLvxecBccGlmDQI4bTAryy6DM8zcOBVw8ydIXG +BVQpdm8AiQNVnk3kaPs046mbPSoWonaEA3lGcPqowek7ubzLYtzh3jdNZosGQWOOrP0zQu466BKK +xeq3UmuhDGzWD9FmpGCzLtc+HwDhGiSwQDhz2a7acbEAJ2F0BTe1d+xFlowO7I+XwxxDcxYGatA6 +mIrcSIghiVSTtR7LX2iFYsybF3Tx8HN9kzXqfMlCwUKpddSxD0sNBkX6sUNvIRN5kKIk7Hc5BkQV +DAt2g9jMjYCTFaEXxXzJ5ZkVMWE2JOczIB05sRWKLsYdRkR/LGbaOfhWr5TFYwbCgm8+Zv5xHZNR +bMrYiYE2MVrPXUTJsxorJLsqm35F1UgU9hGcP32Ihi95rzvXp+3Ns7OFV+zpI/jvA6qfreGccvgc +3vdKSJhoj5ngucpfzgQvUhfgj9WDUqRvp9/lmYeUYHKNTAkJ2WftvQ/pvY/OYCwUYswHnIk1x+eP +aAZ9MmETOqpCbDC0m7X/seqAinb/1IbSS2Wis52fWNJuDl20EtLvAsajZ3WQAyWMjuz5NCJF4ckN +oSiT2vwWuoRVhLx7i3OkQO5balmujep4WQ0msOjWrajcUiSXya88FDViOMIyP7SUnk320a8VHT3s +ZdxpLj/JIbWIGEtbucFh2WJIpkjVN1xamhY7IZYT2BhBArCOzyOAYR3C6FTnzPJVC/iOQW6v1tyw +SAX6qkkvorERNiGnjoRcCvzn6FWNZpIBZ/vd2g84JScqTdwoA6U3f4ImPmjbuUtdvnZti6xkt8nQ +s6FpDcyXEYnGHk7tMZzK3dYWvJvOcR1s7tFAqh8nUW1VewXn7FyjeMV8fIa3LZ5fRNytc/lmCrLR +18+a8+0rnA5aCrR94CsFb1jwAwExTLOZrWEBE2LeB4mjU5zkvWwtcrX9z+BNXKtVPBxzhQYIxH7R +AAUo4F11IhzGGhfPwSkTWbesg2UqgLgP4ObALiaJmjP9qXnZ7jAFT4vYIyPsxMgPTBd2ZLj82IUY +i/3irkJ7cZCtPj5BBlNKc3R2qEY86jAwnQP9dTQE2H2bxtWaNPdBmCO3t7XKiI3OgPF+bZAZ6vq2 +UymslAIyu9GBxfJGmFiLrUgVnDyh9y5GsiJIB3qLoNRRg3TUoi45Ys/qZw7ymniYgDjoVhxFSFjy +RdUcy3deSW2uCgE2PSzVabTE5bKPnOmyjvvKpyrbYuD+cdM6LlaCgduNkwjMiNGZLk7SOn0TPT5v +A5+mWFe15Saz+oU+aA6dM7K2SEWYmYe6uFGIuyyj2DKxa7u8mRtlAMbrTtq8jo1tyEl+IY6143Ye +OJ+ULzlRDiCkzZuLS6Exzi6qrjCNXhSDsDSThwQEL6elYopzn42KZSPkge+VWHQEkbsgqDK6C7km +SdTlagy2bWSLGESxXteBlbUPsXIBcmm2yG8Pa1q7SMEDYp5d8CufgLLSZvW111RYRd4zz591hnAv +/CUw3I0AGNFDxgTWJjfFLT7L+f3ozrJXD3IRw+BQxaQZBd/JcjaY6ah6laRNZ6paA15mQxJCcR0m +FbLn2DneS/wM4MRGwgyyjwLzlx3PrsaVkictjseT5jvxNyHhIV6yuOEFsDsOqoC4EjQO8rLOtvBd +bNfU2LtiHZwYqqBBBxdILEjHZXbsQOAeQ5FBXijLUa1rOXIRwjpbsggD94hZ6kNS/eHsEQU20iVM +uXiBlFS+IESY5fugQzHJWl/37L/O1VnhUrsehXLTzisZrz6v6512cW1we7dj8PDMxEFOl473VZf6 +Fp4bbLaE59EGFXmrFVyHKNCMjj2MPYrFQEx/FpzJl0P7iy/0zLyf32AXDowWOMKgGRHsK/rEMCp0 +0WUc++cKlXRxowv31UNm2so0r7syIyg2mwpnugS5Iz7JBnEzQFrYyegrGCpyLOfDCcBfcZtDMDYy +JWOlCvdkuhZ9p/qHplAsUl6vaemNApqNO1VCNJr77aKbfL8p3/DsR9UloZYd+6atQ4QZY39dYn80 ++HwTbqjMiydqhMwY12PBXovVCBRf26wtWscLsm1f3IUEihmpZIicYNxkAMW+QlC8J9W5KeIVoRX7 +t3aTMe/cW5cufW5WFlTfYCNk8IqVBeM1tyuJx7GFiN+5kKsx6Ca4bMCZJA3lr2gHSjZVDTUQ5Zw3 +Ygfc6DaFJjdguFfZBQn+eDazmbQ2OFL+Ss0SFrzoU0H3BhbVHHC2xkew1EtssdiX9hWL6nBUQJGj +IAS6n2BsdQ4BNOBQrWw2A1jUxps8rnAyWgFMjo1WIN8JDylOUaduJy78aNL9OxETfoyH70Tbf0re +MWSkSbETpToB+a7p7Yq9lkbClbYuCz3Gw8QEvhi4p58P8l0pmbn0jmllMevKCGdcdzlzFFDwx48G +dgG/bODTfPTHb/95/a//t2PLkXH8lNVStXJ6o3xsaje3YDT6kstBf5CRxrhkKK9QK268YtU17del +fFLPvmYVMOvAsgofYnI04RdPgKykyeBJgf9a8w9UZ8nyC5QoeJ+KM+nNt/FAgvZAFdiMltGTo1qg +R9SYFXlS7mMro1FWVhMaIawqjTCfMWeXV8xn5IyJTvYBCQ2dwKyOGQ1CRaZtiQDylkVE+AVVqdpm +CA8lry/j/J1XtPm5gFWebye78ZBorhTD4CnB4V75Ai/MJEqJ9N/gs5+t9u07U6AGOSv38sMv+dXr +geckx61Um95HvLKipPmwdn7p8PlYPb+yJYwH12NndebsqBg7pldpl4cvxFQXlQJlDymi4j9ezKY3 +jr/aiXJk3pJP20mE0Ji5vESRugqSVvJc/RO+ZtackP0gkWGZIHayV22AeAl5P9G1kGFcmPT1ga1i +jOas7sSVyN7tVTPLyakriWxvxMTvCW+ubxPtRKvk4+8QYQzqiW7/jtdzeSnQq2wp3cLp/bCOHi8n +z+kxS0hTqKv7LEkFHhmS15da+gSbUF0hVuu3goWDgBAXhLeFCrAD0cAdSBjClcsHSS6v+6/j7H8f +arww2l8XIMeIuS3MLItfKrkVOPzjixXwlyjoeEnEnF6Ur5Ng6XXDBxboaa/a07tnFafZA3FmEyW3 +9VdU9visZX3p6YP2NKZ/y+gkowudfEXL+EywjKqZWvZBra04HKM3LNZL0r4hkmRq6ZzHSPCKLowa +pi43lM2TKfRCp9lKbIASOGzq9KkJtomdP1yrWsRKUybt/4FbCjYusiA4fspCgWc3W/Gu/Tp+uHJw +e1taTTaVhFk4QbwdIH/241Wy3UMgF2dEVEO+riT21BU8rzKj3a0/QiO+3PvuIa2/ZCMEv4Z7SP3n +Mt4rMW5QON3UfetKEhW1jxDCAOptKe9NbZ61GugWwV1GX6t7X6fWBDj/H0oxQx0mcUxZWaL3uOCj +Nnt1ICWmnljtIqf4YzZkpzpYdA+YMepkoilDNXaS8yIWARPssk/4Fdh29Bk28DVF3RdjKCTNnb1e +fWKn/7CCxGTk2iP5K72U56D2UtVijm18fv1/9b/HfmVuZHN0cmVhbQplbmRvYmoKMzIgMCBvYmoK +NTI0NgplbmRvYmoKMzcgMCBvYmoKPDwvTGVuZ3RoIDM4IDAgUi9GaWx0ZXIgL0ZsYXRlRGVjb2Rl +Pj4Kc3RyZWFtCnic7V1brxzHcYYulnSOBPJQWlFhbItrWZJnZe14+t5tBAok2AjgGEhs8I3ykxMb +CCAHUv4/kKqe7q7qmZqdPRTll4R8Wc6lr1VfVX1VPfz2OI1KHyf8W3/8+ZvbX/0xHP/6P7f58vG7 +v95+extHg3/yBf77z98cv3oGz8ejmsZgvTo++8vtNKaUjFX5CXVUCt7Qx+A0dvHsm9vhldOz/4KX +1MTfMs6OSpnj2Qd43h+f/cftc3jyHEcXnbbDq6ezGm30cXjtpEYTo0vD6yc3xqS9HX500tqPU3B/ +evY7bFrzprUZnXEORgONwqNC72502ng7P/IcmxtdUj4Mb8Av5ZyKw5snM9owKXW5MwWd+ZhqSzCD +MKpgo4EZuMmP0cTyWjcA+Jl00HyMv312+4fbb492svNK+nR00Rw9zHf0Yd4oZY+/+W98bHeL+u4W +exSmEXZIuzF53KHnw0enM8wjJuthBrAWEX7CqPJuwNoP7+JuBB9gNerGKD08OSnYmhAVf/RRu3iY +98vCHs4LPJkhnM5+VF4ZB0sNa2fMFIa38e1klfbDXXk7wmaf3ajjBFvxNrytjU5GGlJIuGl2dJNN +w0/xpaC0i/DTjTB7zxt60lp/73SGNfDWazMcIjw6KQ179mtoFFoNQdGQf4TjDN7gJdxKZUfYome/ +v3322XOYT35VueHrv+HYYI2DZwO+O0E3k0nQzTyOkBzchhbtFNTGEpeVUbZMYkqaz6ybEDYPTziY +EcrUlPxw+DVOzk86TXY1DeuwUxBxeELTjJSvM9qaR91VPo35rh5qh/CndchWkETq6+/wbeWdVwNJ +BxOpKjMTe73cdtYOR5ov+wmtgn5OEdbm6xN24CanHZsxwxWa0qzq3lm+tiSUXEIe0KjpLbb2bag/ +x01QKsXh/dPZwiZBk++gbpmoYe1oIT4GdEkppDR8svjlvRk+nVEkuDD8y2ovEaY+OCmNs3R1O2LU +Vayiw/Eqj3uoYfH0NEbUA1z7epVaYrN4RD+b8jzMAqKtBriqGDdvkTNVPqxOVZC102WFQlIFQnXk +I6dX2MiPTS+rgPgUmAlgus7eIqyg5v/5dNZjmDxs//sgFDGCbg1rfShriEpmhg/hQdhxM/wGukGJ +iZ499rNThEEE2Fz+C3rxMYDaX/FTfGu+qId4gj1REXZ61sVzWetzgZlqHVA1f3iUbvefMBzOt/no +uWo00ecXSUkY8FeMZcrYtuAprEfQCe6+hXpjHM6xm1kCyfYmMQUtWqu03sB6Bo0i2Fe7bmcDbRL4 +LjDDyZDFTMUWH0FkR22PIJdg7rNXcyS/gt4CBQMshZYAYbP7g/ryAW6b0ohpH8E8DOhOyjALnUfw +NUAAYYmDsbggAd0PgNQvsiXyRofhDLeh/5CBewJnyZbtSdbARp5ThiZcDwMo6KwGrVWAQtag0YHx +ACyjrsIixGhn6YbfUwQT5B1qRxpTnDLkInzh8LArA3NIWWo0QNHo/cZPmAp0kgxo51MELmMNwMA7 +J1wBsMkoqrALIIl1ITxuOEg5zuQtfBcFdXAw6BRDyM9lJAMZ+BwgBPAUTNU/tV+fZ3T0aGLo4sfs +V7tNF00Wm5Sy9QNEBKugh387gZLF2TjOK+sQwkEAvcJlfB+m4IIFiWeTgcY9+He88U+EX5/WURS9 +vsYj83bKOv9N0XnA+JTtMvzzF9iCuyChcwsTTC3OPt0RxmyCDhZGBbsKemQS//keqqZLsEwAugak +O1l+8Q3Ud20UaNVjuD0B4trhx3mdwPCgf5WfBGR4HacaVEqxvg4X6Z0PTyh3oNG5TbRbCgDqBu57 +mL9CYwXLor2Dnf9x1lQwxCGUUTlleLPiqF5vt9n46HaZswYJpCd/Br+sthlRWJO4aQm9A/YS9V6G +NHUX2aTmPj3Y8new0RTshBb62v130ZaY6TnHwRvB92LYSFa2WF4ARO4RFbNvUqyOMoDFiAttJgtA +yZwbhplz1BWYQ0dozfGUOWfsbTLN7P7SK+5dJzbhzvWvrjKD+wOb/auAqD7G4Pru1+1/kcHHhWBl +H+4OrAHsqOHOE/nUD8gtIf+GvX0gh4Hcls5bLa1zL6x3Vuv7fD+zrdMKliG7YQagPkWKWpvPRX2W +nS9C0AZNzfdxU5nJo7ZfG2aT3Da2EswXO8Brk/ImqgQGBXUwqBZzZHsyOzdlBucSclTvpotAnqLu +WAtWhPkuda2sC7SnK9HNgZakECR7RY7QsDLZXO30vq9/YP7yw7Z+zRVp7XTr+F4269Ywx2rpxk7d +U+TvMKE/wx4r6NoUlzBNKmMfdA1GO7HIZ8R5xcBntYENrfOHNC3y9El+ZKlgojBrZDB9kN357YvF +7LXmgOuh0uSL0Gid8Jkq9StXUHeKSJvP9HjJKuRhiLHzAx5+1Hlwnf0l2i2AptCrX310C4SqHhTc +hWAQ+2KaypV2HaWJmMPfEpHkoTRtus3k97C3PSudSkqO/vie3yyCiFmQ2qNHHnrmJ31tFLSu3Fbo +ChArVwYa4V8Zc4mYO1c5IWx5zgBgGYuieyiSM4LQdpQNUTIy+jwglaIgilvTpsUU9UqkBP3iQ28v +Ey68md2vCSm1psN7FBEbOl3syZnWwDxhnXxDrA0b8UsciC3cTQUgZm7IVPOe2AOPdmiAbvxVSbhq +EJAKlvFJQROIMiZf0UQU9gOJK0Pi9ULNNrA+OhuWKUXfo0wx/KwlSa9lrgR5UZCkxLph8CytjKjp +HKdrO0kkfjqTXnG4i581gI6fgiGbXlYUY7ake8biF9VllCxxk9aO+qzPiQadye2GRa8itpKV4v82 +g76QFbMghW/4MlOjiz3M7GS92y49WVpQy/1t2pYzDnxyBt7t7DjMxupsxhuB2igT0nvWZO2FEenc +a0eqUPfc6KGHuV6GMxPKzfCKMutYxypbjyGU90nr2N+eCUT0QtI63zIvczDGcA+AmzDBGenUa7GP +OLm1YWkYi+NkiHMjKdOuMSRzz5qS/BKmwOSCMOxaGojoNm0pIYXsit2IOkyOx4YvRpwx3/o1foLp +q6P11XBm07ywwWWfuQ3e0O7q2N+JpvOCP74Ah0OTdNlirl3qm0Wkh/1RK0x4dnMF9eLGaKumzqN1 +yafOfVynN7bSW7UhnvNYeXybK7CBb3UzRYsRToAro3VezHkmZPRC1eY3sAdo02K3eZEN/oKu5rbe +OmE4GI1Tc6/5/td/owfenlkfD/HMOxVhwMZyI+kciFjeMMAYmzI7VEX7IS4VqIbLvANmXIMGxYcY +0ngVeEuvtQzLq5RheaVdfLf9QgvPtBA5XYMh3wlzyzFTg4jXToFryKb3GCNXNcHa8F4/wEmnqNDj +hlYBN6ZsXUG2oIfhH2bONC8UJh9xR9nbWXjilEDz6R12/x/rTDxYDtA+WCcV+QMbywOr59Vku6n+ +BNuCmeTx1an+dNacCSzBh237nmSiLTPZZfeSmo0GjBBkGXZ6xn1opCWOcFAMLGB7IIoNHViUxUZe +riymg58HtGFWwbKWxXIGg882LhCmPDDb1pC/H9scUQnKHI338KzGXEtUfI5PkRQOE9iJIzL0QVvM +AcE7E8inLbudMA3yGBB/8skWHzskrztZfnrCycfg+cWPKAH+80x44/2MhhZHyp6c1zKoOGM7KP1M +1VbP+mPcbbBnwbJHy6QtBCqfzLwmJsA+zRSrcTlP/V2f9ljUJdgA02uqzdCOR4t9AqgtLY83QUeR +H5Xgw0A8oXO5AvqKMB6hQAOEV4ODTUH/Eg214oPrEog1KGbAdg0TUeGERwzLYB78Cx4nMFP+Wnaz +vI6993fZkaAFkwP4TQO/pmUOolMk0pY8bq+vyyHNYxRWi5ze6yeFGpDcgqCoi8Z6Z4lCaqmL8i7z +LqIbySbK3n+30aJGNVr0pnNOenoJ3ZjOseVwpC3oE0u8PhfWf0EWSOwy0fXMGaBXuGWuqsxKBOrq +RdO8+ivXDrtZrl0O4KkfTDqqNDrleFD15ikb1cD9IfJmxdiiNrgdvy5dLqGshyHHR6eAxgbMEYeZ +tlFyioI1dZCiFbGajBxevrmyznJFqdyBIe7gAwpuKyRxNaLQY1FKkte4Y9JE5uKVVnfEwgjqKm91 +RKu+R3TSNNYMzYKSZCAjBRwHushneicN/x5EYOPMxYqPpbveB04dRuxGTlI0tIqcMrm45Bbnnefg +wEosWIgjlnEJBW5KIgpVIwq7Yg0GDzTxlUViREqPFDKRw0OadfUEhT4z34NeChGnHXFRNbfLP5QB +UTNcWdt4xA5FDDsQ5lwT9a6JL2ZgKNa+4XDKXRpJTrgcNUHjzFpNVkTTkhWpbdcGx7YupemTIXfc +BRGs+gYlKiRGxBQhdcnaFLMpkvvAHLBdkpZGtC7aElOST7iZl8q/aBxzm6C2PUTwXHbxza7kTkQE +mDeWBytL6Q6pq0Wki9WP0louzNotqKKeuvdJxYmFZIt1fVLzILERG15+l/GvWe3OfWUwTAOoqyIX +sgp06k4+/1KOlAo9Z80EkYjGp+FfsdhIKd2RHt2CSdp4H/a8YgDgf8WADR6d2h/nmQRrRFvXmcK1 +8twjRmCTZhjQBTEQ9AcT+LWHDHaEfKVYLSFHM2wiHJdrSzIj3SE4FbVWAlYEMO4MNlkk4CGMkfd7 +JaElhKyzEzIg84Yvqxquz4Awrd5Lz4t06iMKTjpUqRpC6csuJpk9e1J+ppBUtrpC33z/KEUioofQ +VwuxFKBUs81rR3Jp+pxT+v2y/pXVr3Z+FIvRalVrkQal2US70CAPqT+G0McGF48krITNxLjFm4hI +IEEv5Ytp51jva4Y/l3pIJV0b8NA67XxLwdfYKBKQOIQvQGQmFbapIlK8hcu5avIKLibnjEpc5uBx +HUSyaBFieZ4uZ5Ah5kHENPK+o3ifVAwbgrQm12aKrzACQn0+rfhO3LgZ1jHvsh4zEPPc67cyP7Nx +oOtcN3TP2TqSvvOSAlJpBpb0FoVgTGMJJXil2WGZWGcVEYolWV9GmRVjTvhc51urtBPuH6fn2uBa +HeOWy7YIIDs0YNd4cuwo2M5lFLfNcl4W3b4iSghsbviYZr4vgive1L2rzcMphwSa//kJK/DDFNmx +ms8oVUL933EhbiEST5UL1BIDEdISkZm+X7b2Yoa58zmFbPKKL7tfgNhBRL2/Ki5az+RijdmqFALB +qGy5m1OeFRbPeXwAA74jFWAhTYpLsrbKAEeIdZWEss25jpa5BCKXeegUv8HB2i3FFlY7DMrzJR6k +gMDK83pQpnoi7yFp4eW60ytWv05JrEUj1KC4ieFW5+5VXGpIIhZ2r7MrJYBuAvVQDhQXhTAaXOoL +fBI+yepkSAcOFEQ8WQVj1qCAtFgMpQHAqCsyocNUnCeuar3JE1OI0uhZoVRmixy+nAQReRCR2pbw +hyg0Wpk7EXIkP26X9LoHtXuJulwEzwfyBop+6nxCta8vybu5UV7CoiDJ79Sal4pxNKjnWL+CTcOc +vi0xXsoA1R36HfAoztWBnfoew9uJNS4xrOvzlLNb1DSW0jvXl6tyZkYonisZwqi7PhmwUKPs4gyU +WBAhHA2mWYpVN6uz4gg68qEHEmPubojafCdaxB0Ag15nzwTlx6wPyrLiMplo5fVfC77EwXZvJL2Z +50IF6IJnQANhqPdlE/Z9+BU8g52zv6L/JtE6X5HVFGvrr0sNLpaTU+wXUoMhdZnhEgS6BoEKBlua +LfFKkzOqU1+WoRcZ4BjF9HoLBCQqaJsFwDCGZ6GF4x5USff9CID24K/QqAQDfsNBBCeWC0cewNu6 +Y7nwTUC8RTmdeOrrupNei2T/Xj5hVU+8YgAUHh333HuXT7Xcyydm9nP2TMDbja04iiy1zD/uxVO7 +1vliS5wKuKiu11ABeyslIoOYvRPq33vbtmaEr/9WwEGO8i5WRsdJiF1zIPNAPHfX59o6T2befQ4T +DyX6kmmARIHw0TJsoUdFTpQV3YpxBc+olNtXF6uzMIh/4kX4hAsvoOWiVEztCmXITZ3Mwl9oT4rx +1tVHXMWq27L1WH7XmVyiJqUqLvIlubxkeFa2T5tI+lqoDg3RdyKmYy3EnxOn8cnJDp9lssPETlE7 +iqN9DoQLP3uYMIVHFivitkM+qcxHCAbuxWqskzkvdDD3ZcImyyV1Ippvc8dy5WiQ66TpMEiGjWuC +nlkIeO3JYUFSyhRFPah2iaHoPhVy+MGIiUUh2j2IiUqiymmofWpC4G/FktW6oiamK6dUigS+H4dx +D5e2+fDtyY7DEHyKfTpjra9XsRk2/h3YDKK5ic1oTe66KVeX8Nwnd3I/OoOxLNW33HYCqmq/PD7D +CHxGy6vWA/f34zMaSRuWX4GoGRchr4sY1b4QJn9G7f8zu3//zC4L7AB3AfiClpM6ovN/RbJXoCy2 +dGJV91YO61qkqezFw7rfP9jbSff2xQ3383iWBVAvHt69vEzvSwnvrJdEnQ0wUyfXpHrLFv9fTfW2 +RVSWw8RPwIXwWmvT+y0rP6yzvALy7JwI5J8gaBBJ3pds2TYK5q639xtVHUIR+U0rqDNOkVdTY5hL +JYK9Ki1T5VclP3bK6V6QnqCDFXLavDouYnWtWAy4TH/l0hgRW7r62L5OAJebxzASeJBUXsFiL4pn +cQM3/Jwf4ljwBq2x+i5h82zFc78dcbA6zqE6Xeo+MLXgDhZ0vegvXyZVF0fvFzTpykVeZXLXIEL8 +/7/joUvY6eg71kL+Zg2rLJB5C0kwOF9RqzF4Xcas5RbzR+tvBNwtjU/+Jk9PX1BhBrEXwqEZBuf3 +8f8bY9jVorSJdt/5urwQUp6H1bNd/UUPXqEhOglbJ6/WVMbagdmiMmqWXM6mdcmRmkhZ4sC8xdzY +N8G+itJo4Q55/GLtq/iBG33Cz3IGk+qnpXLw03177PrP7pVxU95d2c76Uxxz8UvCHPWYcu58sfgx +VjdF7zsmZeXaWQlI9gOYZTXv2sVeMEAb3wMsr+FZZtE3kaGXFSovKCK/LNhmwUiGXm/aJw69uQy9 +LopfeloGJnNSdwJV0qtTfzvfQGH6L9p8NvwvT2YyEFQb7C5/Bn7+KORV3+K/+FlJY8Jo7VF5/ATn +/GHJ/lhJnap44ogQQQYzdpV/AK8t+2/hUTWBo214CaF4JmtDmvhHVYiCPq+PfW/4weK2atRx5+2y +UM4YOyavuk248j9EuLgJNoAa6G4TWNJ7n6liCNoLB4AtNGu0w/8fQCmVju743X/e/uWljTx/lVRZ +/ArCPG4pMkuEv48EyGRx1Ye48IBaWuSYiBmRvylKVPDvMOehnWpn/Bfs8v7B4806W/Yq/3RQBSU2 +nDIZ/Drw3UolEN8PDHUINg/yV9D2v+z2Yscfq8yz2/2H85v8v0gG9VwAEhYiuAqQq09S6hj98GJx +zWUifH0Qp4xk+fH0rDZ/uP1fosdfnGVuZHN0cmVhbQplbmRvYmoKMzggMCBvYmoKNTU0MQplbmRv +YmoKNDUgMCBvYmoKPDwvTGVuZ3RoIDQ2IDAgUi9GaWx0ZXIgL0ZsYXRlRGVjb2RlPj4Kc3RyZWFt +CnictV1dryw3lVUgl3AP0T3nJj0JB4KmYYjSndCVctnlD0AgroYX4GGC7lsyT0GDhBShML+F/8t2 +le29XN7u6kMgkaI+3VX+3HvttT/sfH0cBzUdx/hv/vDlV3ef/tEd//z/d8vXx7/9+e7rOz/o+M/y +BX7+8qvjq9f0vD+qcXDGquPr/7sbhxCCNmp5Qh2Vojemo5un2MXrr+5Ob5xf/4VeUiO+pWczKKWP +F+voeXt8/ae7z+nJix9mP0/m9K3zRQ3GW3/69lkN2vs5nN48z4MPkzWnZ+dpssPo5v99/bvY9IRN +T3qY9TzTaKjR00dS7/MwT9qa9ZHPY3PDHJR1p+/QJzXPyp/eOuvBuFGp650p6sz6kFuiGbhBOeM1 +zWAe7eC1T69VA6CPYXJTGuOzOMbfvr777O7roxnNupI2HGevj5bmO1i3bpQyx//+a3xsd4vq7jZ7 +5MaBdmiah2DjDn1Oi0RrrJVO83fTdPoefZr0FHRanVGf3ol74qyjNXl5piZGHSZ9Orx7vtAf1tgJ +3//R+TIPTunJ0b7Rx8mPtKrc6uGs1KDCaLl9/hHeOMbntPP+9MXf4rfKzlZl8ZiNoVGFwYxWh9ML ++tLSPII/PZa3VvGJI3q2ShfJEr0eBuu9m+FB+PnNs3LDaMNc9fmCP3Kj8OW9ONJVaA3PMi3MNPu0 +WnY2p4fybpo6CWFpxgbXiKgL6jTEhdcjPWxpHnFDjB3n1OOsLbVavkyzm+aJxjlRW7M+fXGO7c/j +PM3QPvUaJXbSapiVzoLNjbJmHl7w+KB/VlhuNIuOCzR+0hmtJ4UrceTX171xGjcx7axREwzkwM3/ +5hwHG2ghL7FNmhGJw0/OjmZM+nT6YfzSaLUMqawDD2QVPDNtfs7r/O45qusY7Om5tMr89qvzhcY+ +GzufPiH4sCTADpvkEb3khlgR5OUsAkEz3ipNnPsb3H7aGjM6GhRNzoyzOyX1VDTY1KzyzqGcrRNY +Oqiw7pJl4KLMQLC0CALodQ8EiqhnUaFtY41JI3MqDcGFGT49i786a2aSblp171CrsZPnKNupv7fP +F9pRT7PCBXwAFU8PfnqOmKpVOB1EcCoP/ursh1FZk3dsDjZIiBd1GMS5ajRPt4M/MM6yOR3FyQIJ +L61mavIGpSf16ec4Jlo8H7WV22QNa3ct/l4vcw1M9GlCkX53BQtjabpTBosXZ5KhEawAr0l6vwUz +nkjV+u5I2pZYHx+uq2u3IwGLeislIoMwvO/FvgIJcYCh1LYtIxx3CpsPjW7lOTZ/QCxnlMBRc7dp +U/xooIVkTOZoUnn/0ATR5/z1BibS7keYUInK3TM2JAtoKxO7tfVR93G0gC386KPU6AN/WdS2VtAF +5kfHPycjoUn/fhIhg75U0UrQqpip2C168DcM6OU7VngBL/jHXdHFtzPmZTGIYJeJA1CdylQw1UHL +S+OwyuBKt6aXliKJwKwVCCFbdmgTBetVbN8G7Vq5WUgIQFA9/QUjJhd5bIEIsHUbChYV8mcEByFY +q08fns3p45VWuxkN34Okp5Ue8LOMLqCIyESIH1hlb4AEViPQvufIVPK8gNPAR3HiEmWqppc3plbo +mwEVkJ26NFEsUCZ5RmX2j5LIribZersFgHVrkSaAK5eWmaRyWLt3NCbW33VDCPjAE3h/EeRxZvEz +xGQODLdgYMveHcrrwK4eceUjfPnZA2xPNCJSBB1i53EuCcL+EJ2yj+7ShP5w9/rjz4Fk/s/5YgZa +Y+r9VfkSVO797E5l3VJAAxrVXaBL5E+/iuBEu+lMq7ora86bBDNuRaQhNzjQtM4Zbfix9yJHCtPk +ccTsbEHTjF/gDR0qulMgTPS3GDVZaN860+Jb4+TeoSPmUuh2sczXzhy7EUWquVVcOqYJyLtYzRdI +I9kh6MuYxg3J8MgodQBFFNXvQQKUA8AIY9cBwA8m+I19L9ECAOb11jXPBrptaYgfQ9c7LZzoTI9a +6wMyrsq/65ru9Uk7qEmt3efFrteqMJtNT95OqvKbOCy0Ab4kAMh8nrNSg//zWJAA+EodJ2AXqCjG +cXXV6dFGCxxBwQfkT9ppWn/ODTWeeCJsDTQyenwSzasJZlQnkUIBRIueSy2YTI8y5GFbaaRmMjsj +rUBj4yTVbh/TIpA5BjJo6MguVs8ki2GMBd/m0OcEIuPPTtibhf9olbECugdezYa+pf52qzJ5UKDK +4vsiORHjRYeJRmJHtyBYsew0aLbsa6yyWMloF28LHoIupAlHS4yEV4ozcpPgELAugWZXBnYbfDtU +JkpgzgzdqJMvUe42sagr1Lt4GRGARlPrEsRosCsE2Z9HejI7VTwDrdJ+tKTku5GK6JmYVNnnDpb8 +Iv7syU+rrHSt5sISgiPXIRmtQwRafNVbutkPe78WsdhcvU95cwSkiQ/wa4+NBpFMAFnlUfI7FRPK +TT5s1R9Y1hpcyPqZWa8DTWROsRMiQMKVv4No6HtnskDe2gIymoitKowEPCB07gR/S3RL3jtfLL2j +kDhA51syuAHAjs81GRJzW8XBO+Z9DZbOdfg2P9lESJfexdi3FDUVkhbVZnywyGNk9nLzx60dqgNr +3bhJWXC2vqJHKieiyts/WD2Q0YRTs8URWiDQm5DLqoLpSUbQXXsCaWFIzuIxTZU71/gZLg9XKUD5 +B4kzsEgB2BQPDxTtUcYisPXs5HWAIK//FAcXv6tco/88+8FNwetd9lFRKviYsyxg4moqneFHDhUh +8a88A8EHAGvfX7dFgqt1ywskxxeSj2M8yXRJlYpB6Ktq5TcESgpACOhxPZHjoc1s2AJik2TY/IxP +3G+dZzIAUuCwlx9Cz+65tCnwLDcAcw2S9w6/Q7gDBWABmRDxoFJyzB1Usdl1+9BDkWKvwLlYlzli +Uql6fudAnY7KkQGfutIMAVuIFyTVAXVBuytEOuS46p6F74UGhHBFxQWBeq/8UdQaIILMENIb4ybd +wyFc7h1WpGEYUesbhpEUOOGKnBwAQWH7K+VGWNOOyT3xw6hZzbMUdyKOj9coVxy9bAtv1e+n5Y63 +effY0wvBqept8o73JmqsAF4V5hySWTEL7chYVdyqZbFZKTdu1cLzP/2jmo/UjfX0aCniCAaLOOZx +Wl75aqli0dToPC/LSD9Odl4Ui3z7Udtxka2RbJol401+Azknxtloxek1Hz/R8ulhmsc1POZoeQPJ +9g/oS1pSamrxNZRe9FoPllBUVW2+TWsaG4jR3SijNNqIsjFEsUQY1+/M6afnS1zmeYzCk798O34Z +nFkd4jwO7oif/IB2UXljrD19f8kL0IZ5fOk7salJqwWY8/vQ/n/RmMi/WMaZphkSf76lcIYUmcRp +KW1ady2un+CPcdwboICVEhxaRCdM6IKXfNVhrihbmw2TfLCe+8LJ6ublJkMLpTJ+ulIqkxxjwMt7 +JEd1BOwmC9GWzbxsVNtuHO+DuAvbVmfMKEC0E4iLSLs4FFdxtTVK7IieCAwKoUNwUR63BHmtRZHy +0B1+Ud6H1YH4m4hxsscohJ3gncp/BqqVsbixqN08fDVmdpZlY5RbqpC2NAVhKeZxxdPC/EBuBxw1 +4IlJgGvb3NZ6xW/FZWxEOBbasLCxjGhTzO/L4rPVUfRFBNfkCpI8o+MIYgJuWkr6Ftef/TRUMilb +/taCgqPSAg1TJqnDGKoKuiqalNVaLjwQU18N+96PKmnI8MnMjeMVDEuto6hjaElqvvbOylSvZfIT +WpVnHzKwiasiFvOwnHd82srnWGqi1JUSDaBaQk6FQ9EqcPUr+BZTTPAq20leJw2JVlgsyZNTOr1Y +y1Oi6vnZ22ljrc3FlZYBtFLSPQQTsbKk9vaCaog8pSXMexZl3M2l7Zd0XaukKvHxtaIaHlVLgKhE +AMYwKOezuLRlbrGGcAtIJBrWHy+JG4Hdm6amMmHNNm3jAnUYu6R64nPUjMqyOtURFvROF7Uj+fx+ +hAU3GQdaL4eMK00GN3LtqQpfMMJUNQTZuavi8hLV4kd/Qb/TkJx2t0XmvxGESmXIvBZIc4D8LH6+ +1RFYoSvuvxCmTgHQNnqxCOqzAkWuQJHISPay8ph93E3rM26isRCAps4IcW1eBkiYqhjJFgkjLAQW +VOcl4dntBtc6FUnbUuClPi5vk1hU0HHfxThf16ff1ALRhqLmH6VaPvGkAJOOzbCyzPNbHJtOUZ6U +UGuco2bWi3Y1pngFhTJVOb5RQsUY8EqCTBBTUqI5sTU6xPNdfy23CK8nI0fedWXkNtgRK3g22HE1 +L3ovugZy1WRVn3WlOPtQiWQGx8NVHmBnsAHiloBu3Usb2eSxocGq2j3rCIZtgSLIRS67RcUFONAD +E9nQGktf4glCDSQWm3BhDUz+0GGBoh4/B7JR3pLO6YSuD5thEGielBfcjQhKK4hrjeckbq5SzA/K +9Qyit9mL4Ob3cUptR1z4CK+g9IiFV/cof8ue2qaAKElEBy4BKJrUc+3DwZNMfKRfd2qwWck4eN6p +KNxxxuRqTQiFP2ylFGzlFjj7yYXlRIY0qm8KJ00qUY1h10LefLKBiYSc20OXJREl8u2941rDJ7qS +C7SIBOERCILkvknQdt+sU1OcLEZn8uoIZStPywNWJSI+wn6VBhTdPZ7ItTSgzKJ7yZODVNMBLSFR +arLHa3ZD5pk5ySeepdlSrlU0EESuZuEql0pGAQmCtgpdn9eStWg3jiLDjHx+QTwKIem++KBYA1bK +jBtX1JletCc9mJiEUV7I/27YKBMimNlB5tOyAco1RHD8UjwrwM5GRY2yrxWUdOg5v9JRgfVRY/ZA +7SkUQ4SFN0q9m1xTDJPf7P82+YnlNa3LuJ9v5S24vXSB14HRfe8AnExh5NQtHOrL57eg5AfDNhsj +NZeCGalCYJUKjB033W9KOq+qdKf88FH4OXsREpNojUllvVGtO3n2Et2uJ7ONh+zGebNXcU3M19ol +kUlLZ1IE5lGlqsrk5NqkjvUUwgBiYgg5HtvuDbavYrrCBv1tS/zvG8WgverEK9gMyscZqgqnTWXV +ajCvzqThmk+jQMeNuYqjAw6x0/o7EQ1m30sAiK7l7Ufr9wJN3ahR9jIFyXZ6Vqe9csLqtPkqKGZQ +vghKtybJGNrr2Xb5CgME6yknoeqDRTn0A3EUyT1qSso3lUJikGi3gpB9HYiQSmk1JgXy0TSprvCJ +fOpa3mnnTMWjxF7kgcp5ECg0FP1tKWMhMx5e8nSwPGY21cy3UEDAJZvDiklId7RcciuXFKT7013s +Hks34t8fpf/GAN6Pl6oZq+1iwcdYTEMQHAtHAonbElWjcRrnTx+uxSZhjZRFTRzHBMtGE6/84kRc +w4/pOg+2hmOkk5pcyu+eY7F/cCrmL0NUSVNa9elEK+2JMVbnuzm2VSqn5VjAar9vK0MBfYDiElYn +ECNM/wpng3olfuJ5i6xk4jHCayGaqAVYZFdeqo4u9aME/47sC4RQ+5GvzrGIKvuCIRNJVQ7/8qSL +Jk/Z6fbcIiplZemupjqecJnJjgHbYTPV+uxYb/5ZtK9Yx7L2NEOecL32w/l/ckGakg/wPnyQA5SH +htH2U+fM6us7GarCocXwdg8uJgnAsmDhfqWe138Df4YAgmCj4bWPmjPI99vlix29bLY2WrFe8UbW +7p+tFwdYssuaP34Snf7lfRjHh/EojYor+TE/uV5D4EI4Kb7Zaz0l552F6FPR7HKMnM9o3XZADg57 +/zqivxsjyfqPc7y+xTkcKR9EFw+I926HycjFFXkvpYUGlBRuzoGhidvArzQhi/rBvNmv8IoNCcB3 +D59Wd4FBnYQQ5Rdjtqx4ePCuvQyArG6o7nCLgaPl17+vv1Y2ORZAmKbIJm4fZPf61Zq1kDxsjeyq +hE2xZusLjJXkHNhUgZJtLcnWHc3NV1te5RHqG50W2XlSIgF4iXQOk1vgmtgGeEctH9SrxiwSmKvx +513zcHtpAEeS1pI/IntYFlof/YpCitanOaMdBwenJveNsFSxfuBRiZcvsvnCJRPb4keh0Zt4DpxY +KHc+ZKsGrebSH7A0C6lNUayZiEXYPecSWJNeChEpaWQQWaoPxRVx+iz+qoPS5SAc7dJWXOIlYk8S +agj3kKtOfgefR5Fvb6iYPCSvRKWDMUNXnbsBGUAqvt4tLBHvIahZ3+3VxdX5doGCiRyoQsJ85DSz +XxeJeTkjC0gIF0GAuLFmwz1Ev+SPv40HEsYl9AqlVNsYnqn1EYl8md/CLNRYx7sYD350dsEPfgqr +E6jDleMhZiThN0cVVL6H9SjdhLo54GDGGV9ZzjdcNLnP46SqA6PNRi8qxVdTYPKDFe2hfJLfx2sg +ugf2+1d99Xy97Snyyp+aNE2Kvvw99eMJL1xR4n7ZJd7XJZx52OJjPQwsQ97zTiHHtHOK4yCh0Vju +c+idC5CPMWXqBNj8U5b3z2iXnZ+8A3n9dxKm7VHcrQfBEQ4onegWkOVnHxsXpTknKBWDMq+66dDt +Bimb+spFHoRgB3/ZOSIj+rKNIYqlvT1DlJeEy1uh/5a4kDR+GluaybYd9uy+peYd4Y9RHK4XA+bs +AFcGidNjGdoPz0pA0OsSEGQrAlbgwIgp2Rsu9UFzIpXy8O+98x5CkEI2JxDNEWummvtF6oor2YJu +LmuKB5gzHTK0KRUZYo4D9ZYY8MMTZvUtWs2FitlBYcfgABUD1RV8rFrgVf+yeNWr6SRUCTKBZVdb +Oj1WWc6SKGMfQqz72T/+uy3IQBvmhSTNlVuXxDI6QXGfcrGQbMZi8YslF+z3a+R6ChWmYzE0g/uq +UCHiUVao+gitFMKTyhOecoIDCzB3kmBY9FhZNcIW5+uLDf45q6ZvsWqXvEZIgAoWgs3B6uSWqcjH +7jNhwlP3RaqA3IsXBO4czrzh5FLhDHny/zIHpsHzDYyIvswWZTcOfMeXaeJ5t1223cJs5RpL8dg3 +SsAPfeR8847R5eadp7nLpX35VAYeq2uPZzzhfj8wktUBCzH3/4RjB9I51HzN39VjqOtt1UKNQk4z +JxVc/ucIn939A8II92hlbmRzdHJlYW0KZW5kb2JqCjQ2IDAgb2JqCjUyNTcKZW5kb2JqCjUxIDAg +b2JqCjw8L0xlbmd0aCA1MiAwIFIvRmlsdGVyIC9GbGF0ZURlY29kZT4+CnN0cmVhbQp4nK1dW5Mk +xXUOW6xhR8TODGohT1gEbRQOurWeorIqL1WSA1nXB4wiLLyhl0UPBMgIh1jMReG/75NVlXm+rPyq +u3cBHmh6qvJy8pzv3LO/3LeN6fZt/Dd9+Pjzq3c+CPtPv76avt5/9enVl1dD08d/pi/w88ef73/1 +RJ4f9qZtgvVm/+S/r9pmHMfemukJszdG3uj2wXVxiiefXx3+7vjkf+Ql0+JbvbONMf3+3gd53u+f +fHL1VJ68Hxo3uM4e/v54bxo7+OHwvaNp+mFw4+Glo2uGsfP28ODYdb5pg/vTk/fi0B0O3fWN652T +1cigh5+y2V3jut7b+ZGncbjGjcaHwz/IJ+OcGQ4vH/vGhtaY05MZmcwPYxpJdhAaE+zQyw5c65uh +H5bXigXIx7EL3bLGB3GNv31y9YerL/e2tTMl/bh3Q7/3st/Gh/mgjN3/5ov42NkjKqdbnVFoGzmh +zjWjjyf09PDoeO8a4503h7uj/LHtx65fSNANdiFL6LrD9+VT13djf3gjvhNM3wXZ6tj4YWjD4QfH +uLN29HFI42Vh4yBvC5X63lgc/MF81nKy9ezWt04ekLeCt04GvZdvvfXy2kN94KX4Wje0clj82Zlf +bFpp54bD/miEm4JM+uFXOuvCbM5a+v6y1M51+ORdHuoGFx05qe3jOPJnG7f3MD8IK4aNPhYye/ky +6NsvHU1oWj90ae2uNwuVQ58J5seQtxE/wzo3STaNO7qtZ+ctu97LxJFvu25ogjOJvWvyxXlVVvX4 +560G344gXTjTwlKjOfwsvuSEk3BRu2td9YdHWZUXKesPu4ms8t4gs3ZtM3jjRcQnoQvOH/5NaDmO +3veH38r7pvV9MIfbvOpdd7y3IrC29UjE6/zAGzKTjWPCg68J3eW//QhrBpbS7cGIcLz6OtLsVh8A +9uEjCALKFL6Lc8VDuU+ncm9sI3AxHQ0XYZCyXSKDmfc7eAHS/4ika4HZ5RBfi8cZfBDowwPLzCnb +EDhsBzegkN8Bl89i87PprEIIRt9993jfRxIGe3gl8uI4DKN8ki8Hma8//LtKyLvHoWmNF0n7dTyL +rh1td3jzaEZhMHu4n2buujAe/im+Y3vjRsCBdj4/Z/vDq3H4fuhk429PlGydwy+XR70M9eoxNHK8 +fTj85ngflyyzw5JfPdphkOUZhXQTRbdXjB0X9N53vSx/2MuuBOknPfiAaSKGzHL8sokZmWGd/3i8 +903obFhYKrRhhWIJhYEXAKVPgqQf8NFvA5Ml5ME7O3igRIJJPbQBR7iu2CnzkKolECJc5/yAcMuj +zKjAs/HJxLQAyDd5QljFxXCfZCYgSIAI434pjt+tB42Aok8idMjnCZpFfIYObJiMnbOOtt0IcL4Q +IKpw/fL1yFF2MCNAuO6zFv5tkKtMBdm+LgPQUrdUmQrWdIkXupUlkLf2SzEGnRmdFamXIW3nJviw +TS+y6uVLGUiWORCdXextOUOxNQulo6TRxT9CRcfOAwbQCYA1YffXK1NAPuXjQiJzMzRPswwjrK4P +LqdlZPkifhOD9KER/QdGrpqx99ZFRVdokIeqNhLJDBp8N1l/NLNxEwYLoPP9uL5RDtEDptSyFMfc +kCVVVQoJL0cFJfvvHTBME/fat9YUEqorBbF+fJQdTn++YPyJgn3kqfMzrECpYvEhuFInM7FaFion +iPzOGBYARpkUWKIAoCRD1PCl+DSPOYi1VoDWxEYuNNYlLtrJn4Va3vWRtkI7O9rWAOveC84Ywabx +8FZUXUIcY0sVXTJ5iRQ3a/N+kRDZkW0HxEZY55asrXZXijUyhq59Niq8l+E7+db1gJG6XgCs16IV +6obW43o3EEGNTL7INSJMqxTfQEyPlct7vxxKFF+zOM/38f3WRaYGAzAtv+vADQO+VFNimX8ErXZD +EYHpfvRhspjVli+YKZN4JJ0MFClUcq1o9W14R8UZWGGm/NB26It9IEbl0Io0JwM/Goi/ilahHzu7 +2NcLJr4fTba3rxYSv3/15KdPDz+fLOdu6ND03SFFFl4NBp+4ztB5qyQl3lDhYO/yps85yL8WQo7e +hoBzAiI8RPBJpEhHByPu4nNmFGZmZ0zRrAB4OZoxqqo76tzk7fwoRnR6sfYBZWFwxfn3IsB0zkxG +S2YLpTAxTv2wOftELVdYI8AuO27ucJW/Uyx4sOhaoVGfURIAYre7XZmyK+TWGagNyO2tApWEj0XK +SlRKkleg0mk/XCkEOPjW0URfU17PGF4YV+eG4gCnS6EWKuxEfd/CX0e7X+1aMj7od9WLiq+bIZNV +yCZq6BUCLyeOFtSe4uUSvhh9t4QX2rEDtL1DREicn8IPwS0MNkNRH13KBEzrUGTEpx/E94wYk+Ph +J3G7Ju7mcWSWwQkVDv8S3dquHwUqXznGqMsYjJstP6Fmv4iueLTtBNqLwMKXr0TKBCfjvx6HMq0N +edQhSsnxGN2S0QV93ySXpYqCIrSCGa+aCuAFKZbQdAdwujb/wuhqZRQVnWqLrcAgCW9QT7AwyiAY +uZCticc5hBLbGJPBMhHSVJ5gIlWA+Gjh2yeE10f/OR6QgIwpSKJACqsf0a5KbgbIHnMuC/Wdvtzw +flXHnMO4hKytPN4lZNXxFfALTRdfD31fe1ORjuqmXij4a3NO2WR2d4Q1NgxunfSFHF0WdKyMm7U7 +gU4rQcUdNdg18AHHoIQCAGVm9NnzfpByOg7cVl0e4Dcq2IojzCDWzZwKcoOvsHjmkXuhaQy2RUYp +3M0MEurDghzs85classSXGtdOAHbZLuL8O/174pM81mK0bkBHTuVjmR17Xg4ShmxjNVNeCXHBjFz +zEmsdHVcCf1zkTNYubpvJ/ONRn+pHabcfEE0JTEmxGWVyxaTUTQyIgA6kDnWjz7JhCS2FzInILlR +pAAR2a/3veJsKixlqH5JVjL4oQbeyezWypqpmCpumWYlFF9wfFj0mVXRgOYFAJRBURhQmGMQgxFz +KToBqPs6p0fMrfnw0OH99tZWhVKgNUs3mrkx18ALGFxOOvlcnmTmlYh8MLt+eYuslt6+SWEJAA2c +U1cyL96NvgQYcKRPB87UotjBt6rLYM1r93vCakLdOXRJkpEJuErFmEW9TYmvyeyNtuIcWoohxoNm +tXYFlfPRaTByAdfolGUyFCUHJJSJ27hbewWzN5qIBxTJHu7indmxSDvcou4A46A0/CI4V7I5LVk+ +DBGS14olyqh6hjDgTUX1KcqUd7k7pwSK1I+yQFoIjI9OIInVoVnE/G1AuFsGdpWttyxvNhWF/mPQ +UGXOFWt483Jb7oauBObnG7hZi601PCOjOhFMdnRckwXGkX7JUxfByxj/E+dOxCPIHm1rSW7UjZvm +djbU9P3CPQenvJOh+oBbpOHNorShMNjmk0LnecnyikGAQbLkuQxaFDFipvJaH9UYGvUKFVlJwYWm +ewuwOxERqCNRJ11F4KbSDE8o+2ZcgbW2Lx27ayqDOTrNPVSyQRheV12FXSdz447ZOGprVRmVKEtv +HocmdKOc0nuxAqPrxnCgAe1iP5oHFcgandN6hGk/SaZtyDKta6O+DKQcSs6tt6FLui2OZhXHjptT +cVAB3C3hZeM4lVTa3pfv2miRYAzyF8foq4iysdSrQiImJamm5QmwX8k0nlrJEjO10r5WifQ6+IZ0 +S7kYEP7lz7KLxB6m9tHmg0SRh9KKSpV13QHLyjJCglYDq2+ZtS/yD+/GYpHJmaoCydEU5KqkKiHx +pYumWgOIVgckF6tP0yx5Lpoq0cKTIgafNk2jBTUlZtkn4OIjnwh0qlupJgZDyGLoJKX1yCUjqwag +DhETveRkR6XzeCk4E7jvQl2Z+XtZuDOxXEhXBMeqo/94wgAr4oPHulOzhaVXKZr8Pi7OO1do3p2e +BUsNMjmDccAtB6ND5Qz+DpvjeZmL9wH1U6xU7/WjjdmvbhPvybEXGaf0Dq15vK3QKKIEBHU0FrT8 +XVTTdt5zYQ/0A8HGAUSAKjb1AG6YtaDh5C1siWsZ7ajaFKZU5wdtALUCVdCUzqdVNR18I9xUqO21 +Fx3hamEtY9Hc12ErfildonJzLNVG7BvKgwCmmrEqiibqMS9nRxj9don1hKb3fXYFdjTuRLV99t2Y +Yr5m1v0GRKat/ygXHdZ+boTdii8mEAvC510ZstkgAp9H4zw1XD2PsVfD2SsisIMR30SeEwwxwQW0 +22AcuotdiWFl8nNChGV3PlTSv5wqSj/EkTQUALw+q4NYM1bEgxIiQKBAYyfZczQMcEvDnurbdyKp +nXylFIAlLZXLc21ZGbEoIq6nh1YbkVaVVbSPkruj2aG7E7Jbug5QSc3MlMI2vIyZvOzVtLZMVGxU +DtYIAerycc7Dj86Rokj1UO408lvELersMKjoMzK+WLK+H86FY2msgWdmcqBdV7QRXYdcQnIXLh2R +axBaPIKnNtmT4+gL1wGsObrQmfGdSg0R8eUA0U1YrbpM8ar2Bo0PpYxgZGvgTBPMRcAWUj5EHJXl +L7C817kSGmOlGRKaFoaAYhlrnQK85xtkdHoWUQQMpe8UNU0slY2lfMQ9xBxkJiKiQdLjwlfCv521 +prQbk+zdLD6C8HioM8KQS1znLCZpp8kdKifEpES3hWZ01zGZ+N3IzGCgBkPEYu6cIVOg4xHUorDr +JAYU5qXmgOr8HU0BsRVj8Izl6ZKE94sJP50e6nCIA6jPj5Kp4q4JXDTgQYdfaMFXyUXLs1vnovLU +m1dLDI6lE+b07RA8WtoJkB7hXkmAfh1ALipjzncp5Ee1ah5mrEs+cq1abLbk2ZlTNIj61om+9aFz +lquC2i2cfNLUczaE3HN2m+SKcvMPJ992KDoLztcU7HSA92MZlCxkLNJU2ih0yx2vglnOxNtIWR23 +gXHhRWSEW/uzRkDyLpSCjWwgGbHTaJKGibubxD22ZtFwAgypSm3NA5Odj+ZT7PVybeFWzUMaoRAJ +E5lYlNJv9DZYsZCDLWyIjfD6+SqRRVShulrTiGXU/3TaeEc8/Z/LnwVPYialsApIJoWma8G3WZez +o+2hln6l3TWrFHGNpn/TzgPWB794vkMXF5moWxVSnG4v5ZW93K3IBirLvb20OAu98IytcwuIeBCU +Oh/tAElPuTjauFFuj9T/bmwvi7WqXGZ68SKZUopIEgfqsqfCRWPRVrlhXuY5LTALdignp1UsZRam +7s2oTlRYFpQUFI7UpVXx2+28xMwEG60UO+K3Y00BCgKaGUl6KmtuWEUKNwIMlf6QsYrAXB2+31BP +GtXnpaNbFszMCnswDDfbmmKTBRNySMfpMmmlP8YoaDIG+n2pGNL4Hq1s+vBZ3KbwnHW8Tp4FGpYK +si72lOfoQuE2aawwSSFtIay8Jh8DoUVGRCMaRKBWoL6untOoz/MgKAWuGuwBDrdivyS3Pbl1KcgD +6v0aUSDRDNDqK040ZsUU0QTwJUmMgkaZaAsMPEmQs8aRhTfQ6AAcqVoHV9hBuiMNpiuIC7Npkqgn +QdowFTmwGJrCFaj1TWUb7wM4TJRq+426qDVJ56I1zufoGK06n8CVKsrhSSwVox0qwQRKSh4nMR2w +VlX/nbPHaXv3hB+t7Hn0CT94AdEvomoPre8cD23Q4D13POKhh1H2qQ4pLebciB9R5atrYv2bmu4t +8iPppg4AMu53fduF6vsbmJcIllqYQ+mvnIx6boLjGZxd8U0JU+9MIa9pzrvc8BC04aFwiLTFGyyb +m1xWv3KD+pjuKWtmIRXNLwxRa4FFWlIGJXVKVrch5c5JIQv2K03/u27/iZWc5MqnuYh3Lh4ubqVg +Qd+NIl4N8EL/wnNXuoPrc67pp8jPqlWTMkrr3FvZKIS3J6TwLuQJzq+7HhIwDBStDo8LWu36fOk3 +lcdzzScqR+peFH0gKfbj+xz74Y0BNN8FaEevm6DuC45J0xgqp0AVOBpFQ1r3yRF+oxxWr06yYxC3 +fqQS1np5Ybk3TMhDrpS573vbiGyAKXKY7p6Z5S2FHHl8FYRQjQrSGg6QobJWdxf74Sz3btwqwxpp +wIGBM8q1sKSjueg8O9EIk+uVJ9JAXGaVPF1x+8qfASbSQGpdxtViFx3IxVZdLrFoaf4Oa4vpbRFp +okyxpcbSmmZ0+Q67kv+JgFABQvk6XXkJph+KzzpcHc0BHZSb8OdbmrPXV5REbPZV1t1Iifg8Yls3 +Vs6XPpC08qoPJ0HEy9Gf8HbLDsH7cs728YDJUlRNzMeLdgDLpI4q0lpJQa1qvDOKtdgw5awWU3cU +GjXWGoZvXtbq2+E0wKWHcEfroGq0ATcqH2g68xp3nz+Se6rKUqqd+hW0yScdhaWbFRtnsFnb/Wuh +YtqYKbA9dFy/FeXf+GjK3MclQsd2GH0X4FHo6I7iLOu2sgf+LMwFrzVT2XI/u6lpiz+OxtTQ994f +fjhFGtoh4Psw/jsxODK0o9voGX9jPo9WGOInYnOOQ8yMTVa3Ff0VozQyVJbd8gbOsok8FvmaxDGT +ors3Q7QrNguFHmYOJa3iobzkYwP9L+GgSgOxqB0w0MUXU5SOcX3DhKV2IMv8Fzy7ceNNXK9asmd6 +3i+4WkK7VOB+oJSWLBC9Ln/euOUsKwQM6KUsOICtltotGQAb0bsuNn7Bnkyar3/R5nhyfxk2/eaq +hvLeDKpC0vtqOKOOK3bF1B3TpyfuN133zCtVrpnhi2dCyFt5I/GyM72ZAAI06B4vAuqKFiXwmYtb +CApdOTHECzaSqx/HnWs+lN5MUZXd19c8nL684dy1ZRipBX2cb0KiQTLsJivFtCUlWZOvR3ukapfz +bNvhGmGWrkdSYqQl9A+5aF1uKuKtiCQz/2hxVEWZtNBNXqZJ1gYbl4xNj4gNcQE61Zb+VrtkXdNE +L9q5uLOdXqyhJSCQfQc1rGjDQok6DRZvZ9elCB2Q9AQbSH3sMxWVO8j6Fh2fqSKhMsCdWZU2LEmB +mUvQDmHJDFl50eiYjJLSuswKX78tLzNNVnmV8ptzjrRJvXL2WASoNFloLWPRzspCcrTeuE5C0fu+ +pyrHzUDB6SnoDuldZmj4JEedq1R6kRdn4sTigAC03mqBFTFmnWYYz0ART8SjHkT/nOhe2BL27+Z4 +yonhF9pDTzHeeEZAqbpC4cKbyM40NVM7gV6AqRxBLSZdKTSO60owaEnje2U+Am2K5UwRBEDw4RoL +vYimvNMhf4QSZxjhmr6Grg2TLBCnIoqRsnr0ykYwMAoDwgiZ+9EfaNnQqXZ068pbADcu0gALaDOK +GkGK+kr0blbNlBdGRnUp0FBa9Szq+EJSUmVfJ4xILZCDD9sJoIXdiptAVhltiIaf18K1OqcX5GH9 +e5IfUMdZkM71WxdOhsZkmELO3Sa0KnnjYq3UXcYv1uK1BCABiAPEG6N2Gt6Ke+6yk4pfUi3kqs0x +sgBCBncpABHYHaIszqf+hhJwqw2CmQT0cnfWRcyvcqX1RuvIeDfyWEeRzbvo90HAnZzu7Ml//g4v +7WHdnrVq9ecvXOD2PsIOZuR4IWydTCgDRDR2n6MJOj7IwfOEtl/oTurienuafntO9duk21tZ6ITN ++qKhE2IHbiHMIB/kqMqkxKr32Q9F8WblpHv9DZDl4NdJvnc+MGEfL+IVR0B/YMKP+AMTZkg/zvT0 +8J9x4qFvxcb86xR9tbLsPx9jBCTI58NH8e+9qO9w+PooSwgxqPJn/XIvH8emc6JSn8X32y70hy/0 +799Ml48GE/rVW+lbeOAv8wPxF0M+0o/fTJ3/sdqmfCtN+5d52iGNH9+BJz/Oq/5q2tXQtqM8urzz +ib7zWST8aHsrkELnfJZeWrbnO7K7ONLXU5jcOFNsFMd/Rpf6O1lqO4qTPS21sdMIQAl4a9qVj5xR +7noiynj4v1g/0RoRl8+mTQugdnC+f4WlLPP3ncXxv1jQRVi1zxXS3+Tx4aVyWwuFPp4pIEIS50oL ++JuO/8nq0KwfYfnf6PDAE/nQ9EHd0hdImzw5EE8f1df/OP30kBNj4ZeTGHSxovrJdAqhxwc/SlN/ +rWPrX/+XcCCc4He23E/TPH/jXPsJ0gpGygfwWR70GX0UdtfMR+CnX4NZ8i7h3C/XGD9OYPT5lbxE +MnfTOtKFv/zC+sriKH0dXpRwYd2PBm0xmgJWjGr3+qceyK+JnSk4yPPqRcDJtqjC57GEGvZxznv6 +r2xEVUZqGQjZFbegpc6y3e653Jftu8rjD6hQx16DtGBHkN/rmct759+ZEDJ0HtyeC6OQ32UChpYv +b9lfqz7dSKCNFB42yxO3cMcPgRIWr5hK373Ar+/wyqp1Tm3KlYzqpaglS3Mpq8hT8XsV8+FidfTp +nxcsUh114YH+GJZ+B791wXsttKxBBWTjFwu11XOz6rctb0zSUj+4Tue5HYgEKRuRmkeFp6IYxkCA +/sgNYJKamVs946sM03wr6wtIBe/TAKf+e6y9AiGE1Dixtq+NnDEp4D2TfF4uGA3WQMUcXLDyTL4c +umEcF3N8+vHOP1z9P4Q/jUdlbmRzdHJlYW0KZW5kb2JqCjUyIDAgb2JqCjYzNTEKZW5kb2JqCjU3 +IDAgb2JqCjw8L0xlbmd0aCA1OCAwIFIvRmlsdGVyIC9GbGF0ZURlY29kZT4+CnN0cmVhbQp4nL1a +W48dRxGWE2xnN5K9i48SrUJggkCcSXSGvl+IBLJFXhAvQfuW5CmISEgGOfw4/h7VM91dX8/0nLO2 +UOwHH8+lL1XfV/VV9bwZxCTVINLf8uP719e//5sffvjP9Xx5+PGH6zfXYdLpz3wBf3//enh1T8+H +QYrJGyeH+39ciynGqI2cn5CDlPSGGrxVaYr719fHR+P9P+klKfAtbc0kpR5OztPzbrj/+/U39OQp +TDZYZY7vjSc5meDC8f1RTjoEG48/G+0UonLm+HhUyk3C2+/u/5KGVji00pPV1tJqaNDjz3uz28kq +7czyyDdpuMlG6fzxCf2S1spwfDrqyXgh5fnJJE3mQiwj0Q78JL0JmnZghZuCDvm1ZgH0Myqv8hof +pzV+dX/99fWbwQizWNLFwQY9ONrv5PziKGmGP/87PXbRRe10Kx95MZGHlJ2imz30ss6/3H8QCM7P +QMYzMMU35AdyqHeeDHo10vxCR6WP03gSkxaGDD7w1Q/JC0qrqLM/vFLHT8eTnbzUKjmJrK61NDRo +nIxwOh6//ZHGd3Q1BrJ8nFwI3h6fjeQ4EWworyv6efiKZpLCe4LU4Rejn5xSNKmiZ50I3tFbdajn +oyT0+ZAGsBPt1cFzZUs+lnVGiRO9IuRaGS3j1SQsVEM/kG1nDa2kmkJoLP1yPNH+rXH2eFeXvyzQ +LWshsAs9m8xO0lknC92sMccXYwKniI74RvcVva2yR4yKwJUXyXeETkfGW1xqnLDA3Du++Di5zDuy ++G+IVzE6p4+fL1zx1sGgYNPFjV6HulIXfQ4CVjsc/ganL299mKJJJC/iom96C/12pEEd0VgfD3RR +JlcGeGmJBSqYAj0l05oSthI0C/aMVACEKdkxeELpM149rJnj2kWTgiN2dlL23HXe4zHBTsmYhi6R +ihfKu3u8xF9lFbGxIGdtJk87QZTDRLA7XgivGJ78bAw0ptHo7+V2oPCbY4EMvppEks/bSHzSTk0U +L4aTNBMFzXlX6KkSOTia5P2R1XPk8MLDg7ccge74J/qEh3rG3MnbovUdktFkFA5nghDXuDTB2MCI +5Qq8CqysrL2pjoEl8Lb5VzYnWZEmIdTSbmWfPbhDmL0702Hg927rAy9m1hgjVG8bjCWePi8p2BJt +W/Lw3IBJ4NHG0un+DcwzI14pYpgviH86ElCc8TjjHXpE+km42EQTGJ1TAfGAFmKFVRbQjUGKN3Ix +nnFkxDDCpOMwMiceKaTCVX2ZVhUUxTjY1YEtftujJBDxAGPxAp+m0EziR++8dTkdAHTqqrqxiyHB +08NtNFX2vyF5eAeurlGDx1+M5oJDzOxE7CU6ngpYUjSRWY9CFGDNkbGuQ2BSPucHORrUu8WZNBmo +II5AmTKuaKANKYHKDTab2RdzcSart39NEscG0pWorz8eSTgQhOmVf9GDgbZGADuZKWmEYpQcWP+a +FOrvrrNh8v9Il1gS++QxoVmXRIMS0xk9v5JUyUAL0155c/xtkl8UGEi1wc8Xabk26jmz6kmZaPDi +k/GUICdJgH1EtwWh0Bw/IWuKtIskz+Yn4xz3CLsyxlBep4v8zi9pypR1zTxmMoKcJameHMFBJsCQ +2FKOMkIan7ZBSc77vCorNQ7bXdXnNAPhjaLtZ2kpwTrSipsnXazbJw0HY+aJRHOxeT3JpqjmrfZq +i57Yd5L0oVo8cUpoElYT8jI0lq2SvtWyyhECzsdJoWjZpkAAM9Djhn9m9U2jLwKMOOa28TzR5wPi +Y5Bp9m02RL2+JlLKh43464z9RxIYgmJFlWyiiC8bXUQaQXLjWAclwPr9+aVDk6VLuQH0zdWMMq1S +hMzxRfIjoVxIyAF9qbgtc1Lg4vS7ydRvLTXndKkjaatQ0mUjINNmfaQkthFYcSOFt0mwkcKd1Pv+ +HIycCsc/pFU5oaIwxSpa5mhEOI+IcwrZVF8ZN5yUp3gxV9L/zdW+xwcNQZ88kYvtodcQoPmpptNl +7w+mCEA864eUU7vSi3jrCLwyYjg/5E0ai3nlap3d0qOAOB4UwLs4OTnhak/adaZidMP4tdblcqcl +TOEGo6GviRgCqBgK2LMypuTd5OmdIghWwIOhTuLBeIrGqCpFU70jSYbe8Lz/TxeKGEl3YlNDOSJm +Gzm2BLhbZe2Qgh2vvSPAWz12d0F74gDPKhmbIq2oLFSRfVbZMPmkgygjhv8nqT5I8kJT5nUV4BLB +hJo+02vjFO4JpVYGQ57vQo6A/TP2cUK+yuRkQgC3eqprWqDlCfxXqwKnV9bVGWRbmXFturfnBYgF +Sle9WP8c2Vncv1WQczDf7GWfqBWJXK1h6dBWxlDPlWVx3gIe5tpMC/qvKtjo1nt7FVd9YLddUiq5 +hkyFbVwcgakhhzUbgOqtvA/LavpSkC6xpCsPMJtrqBLhAXQ0fopOz3WJdz9tkivsACIBvbh12ia0 +jGOIeZ3m46Z3mu7WvFN/NOKMnV3vF3ad72acwUrT+NzkyiWDPLglhxhZbT5R66ORVHhwzm611arn +Bq1LTkGs4nr5r5oEq2DMrz2JBqjPTUJCmxAVIs9XQmS94vdGlerspSrJAZRx3tbeQIR3YFIjHDlW +XGyclrQHi2bRcttHzS34oRgaFrUcAHgddynrqIzWZk6h9iem7Dldeolzq5buzOduncUk32VVKYma +bkmJJ2UbdJ+bE5/QQrxRtiae9I6lMs55qzwSFQ8ubs83gn6V6mZjjG70400P1k1eLLD7cukwyGiA +QYdtSzhBpJ+PN01SUN1KItMPPO2wCVDElkO/gfZkIS5hzvva3Ufqr8XnO5w0dCQHq7XuMRhQ665n +gUNPe3Rt1WbmbRC45MLtS05uDTGfL1zV+7jR9tShGDqRW4TF2heOLnN5Kw3SkinSyNSKfHRQJ3+e +DXgG8yYXizB67AF0h2LNOUNuoUOfEQQ1O4WVOUy6cN02cfcAo7N7UGUCUh51aifmH5rkrgtpFqkv +69HsgU9pc//TCKwg/zQmT4cgTLehwRkG6/sllVIBNXfhZows6/RC9Rs/Z6r/jcgo+RWI16avzsFg +e+QAquhsd78mh/4xAVzkOI7OrTGi6Ut1tnfACR7Vxs/azUSCaqkOYObgz0+uiJv9gcTFMq207aFF +z2wqnxHsNXEyK1laANMJNgQrYeIO0zkS1HFsSltWUPymDEbluIpBYy7ql7Pb+vlmTYN5veh0LFcb +jze8XI+S7NytIw/NAXnn0H6nGbpX9fFhxuWiryP1FvmgiNs7ZizrfpmLUlqwtIWy6womd3qwSijv +n2Y3ENwcMUHSVDQ/CrNX/E3GF+mogfzgu4VD/6OGboO4X6+03a13qWIy+KRLVpNxSr3YLfaW/t3c +AfEQsjhGXj64bdiZTX+JnXj+3O/MN1/v5JYffh3UOaBeN7VTpsXOTCEbcr5zJpISZ1PSlKiBJN30 +b1YMY7GwzvU6aeON83JvOD96yx9OdJV7NxnioUKb2B94ljB0Mw6P1G1E7pbsPYmKHw6URqzxtRG7 +TCBicCgs34pVlTQVoIdbdNVWeC6WsKGJODhnAd9enON+9M4R9erg+5wnmkS32AapBOdz+PVczXSQ +tC/WgTvI37TAE7CZT5sqRKxU2sLK8m8/c/X6sHtCuZD2cMvHfpsDOogjqsmDm1P+ty2a3q6EY2F5 +oW7rf7a11Ybw8vbIwCT7zjSyNAZ/IYNxuqnqSk5vqrouIA6Ntbb17m4i334i9Fbq8mxdCJxuZOaF +aqKsvjK5qzLz55YyqrmWUJOLzmyaRCcVaF7Kb0RU78pnxyepaCmTyQ/NX4Z+ff0/i3dgGGVuZHN0 +cmVhbQplbmRvYmoKNTggMCBvYmoKMjg0OQplbmRvYmoKNjMgMCBvYmoKPDwvTGVuZ3RoIDY0IDAg +Ui9GaWx0ZXIgL0ZsYXRlRGVjb2RlPj4Kc3RyZWFtCnic7T1dr2RHccJgzF5b9hov4MVgT8A2M/be +ob8/EkAKcR4SBSKSlfLgzRMJRNE10Tr/X0pVf1Z317l3jM8oeYj3wbdrarrru6uq+5x5eRBnqQ4C +/9U/fv/Fzc//yR/++N83CXz48o83L2/CWeN/CUD//v0Xh18/B/xwkOLsjZOH53+4EecYozYyYciD +lPANdfBW4RLPv7g5fuP0/D/hS1LQb2lrzlLqw63zgO8Oz//t5nPAvA1nG6wyx1dOt/JsggvHb57k +WYdg4/FbJ3sOUTlzfPWklDsLb//1+d/j1IpOrfTZamuBGpj0+ENudXu2SjuTUT7H6c42SueP34a/ +pLUyHF876bPxQsr7F5OwmAuxzgQc+LP0JmjgwAp3DjqUrw0EwJ9ReVVofBVp/NvnN7+7eXkwwmRJ +uniwQR8c8Ht2PitKmsNn/4VoD6poXG7SkRdn0JCy5+iShl4tMgLO5NkFoft3ohm+A58H/MrnRwHy +8cEIf3wdVAUqiqC1FydUW4zShOPT060C9n08PjmBlLSS/vh90GC0EjA/PQF11gknjy++PN2Ks8C5 +nD1KmEEBEd4cv4NwFYEedXz3BOxYE2xbTg+rIRQNCujpyz0CbQpnrZrWUKfEpgrHn8LXAO6MPOoT +rKuNNccftxW+AzoEM5BFh85SAUnhz15UOzt0Gd4n96gOLuizy0I0p1t3ttY7IAQ4CUGg3IBpWEJE +WB549tFLiwygjQqN7J3BeO3xA9CAVQG+3D/8PgpdCquHL4Pw7FnAx1l2RgiHwvPnoKJNCoQlwc7q +5B7s/9HJand2SnLmC4yAbxpqvjPrRgMdoblY4dRFRQlLvProlEcBwDecipScH7P0zrJAcgdhpCgC +MaOKw3gJq8JMHgXzLqAGFZopPSgOG1QTByeNABYUVVid+Qas0IEXx4Ae/MWNDka34V0Z+ijKMCG3 +4X/c/MvhT5d4+n0Wp4NNJhfBVIvN2dMt8A+erLPQtBj+ytoJ2srjT1BnoBKvqlGCr4F4MHgZH0CQ +EOy0gbBJvlSUg8H0xZ/wW/nvYt+gHzIV/7Uu9E4VftyDcJLuRVHwEtl0dyQM36K5GK0NofxRZ+fF +EVG1F8K2IOE529AQMJVcTAM2uWYI5uAPX/77zR8yMAqVgboCYwNG08DSAqsLMkB9gwKdtn4AtqVW +9GxxBQoeWeEGRL6Sl6ErfZ6gmvuAUTZg1KGCpVVxReahaV5nLwHiYgW4LDYj89A8ryvsQsgdkBd4 +0l6bQxlBFbWytwHtcgP1yfqBViKs6Dw0T72yuAHtslsXnNF5aJl6EUjBZuBoiyszG9AeQH20FQ62 +KFdsHppnXnnZgLoGXdabsXlomXnhu2BzcM1ZzstqxCbvHhC72uguj6zxeZQw2+jireOBJBGjows1 +On6Uc1sn4/ETTCikV+r4rAM/7H++ipu5d8YCZgP+AqJ5jD7Gkm/D/v1JA8mSLbshvlOWv4CESwci +gTxsTI8C2UUEUkbYDroMSABH6qr3VPJAt5S8NGwEZeSd6QvmDFtCp+/diT5nB/rCSF8Y6UPkvemD +nOoe8RF6gLxoFSUvDQl5A7X7kAeplh5M/INTOHuoOPTxMe71wjjY3x9jKqA9pJNvnm7B7J2FouVp +/zwXqOgMza6/gX+EEM3xY9auB16R9ThoJg0766MkdmFdaXNW1HL+cVRNjNRylJCUvjwk9MXdLUfp +eDabljPQA2m1INTelWGjZ6J2H/KMnIIjaV28DsoH+UIl8+1UicJ+QM3p7f7nd7Fo9c5DjfxOKjqc +cSpVHVDLRqhKemPinVyqYFHTZ301L6qgwKXff9QMNndMoHIhM0EqDYm0QHsFe5aQxRqpjk/oBHM/ +xEOunvshKhjyaZ+en/SbWFJbpwIFvtWoI1/6FnqWAqAa2y2XZ/qXxEmb/pf0dehayPpSUO4XyQr/ +VfUFBaB0OqSdr5H9smUT1U4V2S/uyrAZZkbe105ribPhRxpzEEKfCTTDyENCn74CfWGKwCXJ8NaV +5MA5XZMMBH6cMw8RqPF/UoLsaDIDO8BdSfIrd2nYuRuZ3YU7KAmxw9al/4tR+laFgT4TBvoMzW4y +8s70KY2t103roAQBfQ4SU0JfGhL6zBXos9i1INbxSTeED3mdOx0HmkkGfVeGneaEvDPN2CXaznl2 +8eYWxuaGQmGU1id6hZZ6+RIgkR5TRI/IPDTNa8BnHwbiYgW4LDYj89Ayb6wFlh2RZ3iSWZsDUo6x +VJ7Z24B2uXEF9IjOQ/PUK4sb0C67dcEZnYfWqWeBVOwVLhXHzAa07ylMBb1YKAPNM6+8bEBdgy7r +zdg8tM48812xGbjmLOdlNWKZw4/Tro3u8kgLTSr2NtqzYofUWavNcrURp7w0hLo8bARl5H3pq2lY +IxBPkW4NZIjO19M9M2ai5RjQGkPSNIrwcElWOxG3iCmALUsxv3uCQkMASTQFJZ+/k7rdIrq6kot4 +jAX2GpUKU95a0uLXcJfyYCOW5OqvY7oSdQytO2Lj8bfwHQMZMM1w+jwftQRoIxXidsBBrahl5wct +O6rWSen75HSwa+MOuGWGu5iQQlXcW7O3Py8u2klJQMzuxQnsErbzmE6jICGRyobRWGo9021lozAj +33odbcCIYOmsT7ruu13ieVY1vH4q3r9P7LLXaARIipZXYFIXvA68WfdirwgKNshS0EhzFpBy/MPN +809YpyVM9CKqu8nlXurwXEW44PD0CIQIqodc/40TOFSU2hPv6LIgHJI/OzekgqPKagU1V9D+BZ4c +gqyk3VAFmbTX65cJc6gOm6dqJwPx1DxsrpmRd/bUkk+SeDyUX7XSGmIOiVM1ipGs/FkLVHwY43N2 +wjjKwelBDjjschjFslPOblKbl49YJUuUTGY9Q0v+eQmQ5AlMsjsi89A0r7BMBrwAcbECXBabkXlo +mbckQlCMjsgzPMmszaGtG/POmb0NaJcbl+iO6Dw0T72yuAHtslsXnNF5aJ16FkjFXuE585yZ2YD2 +eMFkuouFMtA888rLBtQ16LLejM1D68wz3xWbgWvOcl5WIxY5SKTDnjLKRz8mGtUz6z7aMbO28euc +hD2jX7rnJExvn4Q19vPRV+M/DTvLozj2PAmzcfscrBNn7UAcDjs5CXlv6nJWuEWdHakLbqAOhpQ6 +ewXqQJ2duvmMjpAD1DkxUIdDSt1A7J6HYBuyg/SGUKeslYS6NCTUIfLu1MFs3fHewLtLOqggaYLW +k9mcYAchA8n0xloAjyGgCiOf33t+Rw9zakI3JLsVOGTU9ayjl38k7X3wUKd+/NuT8+ocrBoLPGvi +oJNoB51EqoSEvLNOtIAkOTSL+eV4NEfJAeqcHKjDIaUu7m4xGiW6Yc6wvKHEQSZKicMhIQ6RdydO +Y208bySbpx0fcqcd/AHZwAzyFsLAW6BBeGJ1H94M3hDmBb9LdA/yXOXWHPVd8CAPJVugO+2vTgHP +47B4/7IXnkMrKRXPXtKA8NoJilxnPC1Wh9q5fX1xdfx6L3sHV29a6w5O2kO9hip1L1gAiSlsn6lH +JLLQj6FwBek5UsEOTSzubBcKbLygLb05nhFBC4irw/fIqo+5+EXC8UbLrJ7vMi07LJLJAk9OOqYb +3LRClgHNVLfzUxHa8K4Mg7JlmJDbcKcKWaFNN8u7hlk7j7nlOPnLlnyLyjpJscrRcfffhLy3O+fm +AO/P+Sy4U+eGdDQNKXX6CtQFkrX8mYH0GdNf7cbdYXrrqDEMMgh6kEGgSfgkkt2OGi2fk5f6m+tZ +zNBS2V8CzBUY37OYkXkozmtcLKc9+j4gFnEFiItpMu2CzEPLvL6WkmZEnuEoMzKH9WNFzzcWuJ5F +gXItBK5nwU7NsLgB7bJLC2oy9YLOQ+vUs0Aq9grPNT3fWeB6FgXK9BC4ngU7M8PLBtQ1KK6nycwL +Ng+tM898V2wGrjnLeVmNmPQs6qgU6RCHSM+ijfbsWVhVn9j6uvd35dq1eNZAn2x2LboAcpuiSSAP +G9OjQHbtWlQZcH2LTp6WShLy8rARlJF3pq+kAF1Hux1m+fwoCyaZH2ClbIzRw122cjdPmuEkg88U +fwNJpZVQD2+cK/3oBD6h1HzCVfPUAF8H3zH09GY65a3nUv1LpDYmiy5M43OhPYveSAPqXx/eu81L +7mzjGZ2RntFe6Y6i1QGKkGwMF3QzLjOGj4ib1r8udHzkVjJi+wUj3v4pr7HhIK1WBiofJpp023U+ +HSPOiec+xDnTsHljRt7XOWsCvATQzcOxDx84HOPk+OySwzEqBqcHMTgaNCep7Hk4xsfQkjOJNc9c +oCUbuwRIds05z1yQeWia19hLgLhYAS6Lzcg8tMxbtv/xOTEGnmTW5hifE2PY24B2uS155oLOQ/PU +K4sb0C67dcEZnYfWqWeBVOwVnvOwee4NaI8Wc57JWSgDzTOvvGxAXYMu683YPLTOPPNdsRm45iyn +5JnGuBwjPCZSZXSXR1pHkme20Z55ptJt3/pKiWbeSM0Q9HxUhJ+Abtn4SaPGQcLcl59o8apL5wd4 +GHo+hBqgLVBZp1GjZqR0n4RRiFTyd+I+Hokj5EDBAXx04tKoEzeQuhNx6YUShLgx3YZMhBI3WGkc +rDRh7k1ces0INdOeC/EPaVEKa/HSCM7DTnHcn+JSvGyJs8TkRh8+bkjoS8NGUUbemcCSsXYCmccP +KYFhJDCMBCLy3gTi44f3CJAQhE+RCWqReUjoG8jd9eiV2OQbJxnAiawbzzfnK4SlJvizHlGsCf7y +xFp+Aoo95KxHFxtt/OWu23LM2b7VUfvnP0ilqLDDgcOBP77o5xuEwLfIA29M/UmrFqY+/PSkTIT6 +djxmBf2rwTqUGqxD0Y0nI+9rHdoJfERz03x38V0BFdnF7aEaLkvJZo3ut0PxNm6+Hfoudh68StV+ +exHL13qwVhKrxRdvgIYh+tK+RaknA9gCua9LDgd/c5KguaglPZ3v9eiP8CDLWhktMbBuQJ+iFEyE +BIyp/F/eKIWxQUlVTCXls2VYj6lku3KdkOWuFxiVNxhIDKQu9SJnvx17byMJvXfjLjBzc6FPSm/C +khMV3ZzKkBPF7n9/DRpFKZspJpD4Ups+r5yUOAc80sS1qsq4wll3pzbICsRMc/x1W+l6vRoTJITi +LG++LfNkuY8MXgOGW+1+84y2OU4/VibHxvRZ3OYY5KibUsB39IbHX5mb5ITur/mIAzkjfpsuuj4j +fWAOnvXYH6rLPxB2StvrPXBlb5SNG/GlyzZTDgbm+re7kLvm+kZJdp92M0ATV2KvA813jnLzcml6 +9U1HkRSvnvr2TSch77zplKbX1qaTz3I7gWaof/KQEKivQGCYc6Y/6+z3nkeGCXv4gChhLw07e2b/ +Gqo8MkzZ+/jepjX/EFA+biZ8jGpyo5rc/oVqPZvm7Si3wDI5U9twhubm2kVA0gRZO3kTMg/FecED +1idYV2CUDTgvtiDz0DJveeuPDWFEnuEosz6HjWpoqi3sbUC73Jgu3oTOQ9PUDIsb0C67ZcEFnYfW +qWeBVOwVLhXHzAa0h7O1jbdaKANNMzO8bEBdg87rLdg8tM48812xGbjmLOdlNeL6sGqetj6siiNv +yMOqfbRj29D018SOG42TlLYoKG1p1KhJmDvTplM63WibiqN+hFb/+pAcjbfUrVdRv+T7S4QpYNF4 +yiKOGlMjw7v1w6C63JR/dd1CnYzBEPLysFGUkXcmsOTYRAnDE7xM6bjxXHA+XQ5+zJGJovrze6S7 +subNkBOSDPZwsgrKrSinFzsROeGLk3Iwr0/fpmEX2yjFnV6cFM4Ytrf0WiNQfdgOsnVCYB42ijLy +vgSWDJNxrnvOVdkch5KOqagcOEnDzsnI2D45jkgvVd0WNSRzlEA3EuhGAhPyzgTiq41HFyKn0b+8 +91HNrTuPcpA5Hj9TlnDYWRo53PM0ekPmJUcq18f0uP+N0JJ9XQIku+R8E3FB5qFpXq/imv8twLTR +ZuCSV87IPDTPq3UGSjnklSs8yazNIZUawPNToCwwNiC+oHZK22b5bEC74JdrjAs6D81TrzLagHbh +r4npjM5Dy9SLRAs2o4FMCvPYaYWmV/ZOed7M+wa0R/X52iPnEQw0z7yyvgF1DbrksTM2Dy0zL2Iq +2IxYMyXMQ6oViq8wptUkY9cVvjy8ykD3eMu+Ae1+pVfsGyXbq7q/jTmItcFA2vlaepe9CfQv+oL8 +R5jPKGkhS3nxp/wq+/Ja/PJufnyHgrSQ/ueGqjhrZ4YV3jxxL7Ce0zKVTgwoleTOId7zU0HTTO0n +sCzML8zxPQQaLS29ZkZOoXqbrTyOAls4zch6861//QfYR9My/xaAxUMkNd1iZN5Q8eSBi3H9WJh5 +KcvfnfARLiE9aS/SJ3ZuHchHTm3T2gzdOglrbal+Reyf2zr96xsvmbz8ucR7D+xCf/t5X/KH2H71 +URja071NLU2lnAP1ynD2+LL295L5KLyeUn8U4XPKWjeErVdnrG3S4fmgiklfj9lm709s0nekkMuk +Te7s7PSwsM3ZzyW7vOhhxNvMm1+Ghz+7kBOim46PbrWIkAubwy0IFvaM+TdQlmNZKCW/jwlycF7R +Z8/y4QN4eTP3xP3S05bDUWtFpFVRewiOnJ31x+lYZ2SfhuMfpqvHbcOzdGzN1mNBVxep2H5GNMP0 +8IkjdNZ/inRKqLmOP0+/RSFEjOTFMkTuvZr/aPord1xLVKCe+T66SXAuDE3mvKSS8vg9/Fzh+WQ/ +4V9WxNlJLfRRdijIeL1tDkVWp9eqW+SG/Q6V2iO3i3R30TH1ZVPc/s4JSHLCoaWiXo3WSL3Eu97+ ++BboKAJ5KQZjtp1Y02eJ9+LT+RA4ukm2CQQZlU/kgTenoXqD6vgsQ/TZX2BjArPv87yDv/tgbBC+ +wx4nxiK+VKjR8CvAc9KhL7+RPjawUaUXA+HdGJFKl4JKWHgNZW2c944QTJZ81Ff6VmJDWUcWheCm +AFdr3LvQ9vDnWd47pf1SpzlvI3zFWJ12HyWEGZbP7hQ0qujtvhQh4M0iEk2F9zRJLERLiP5GOpaO +5Vc3YE5lHF0q7TYOcMsJV9CgTirJJt3+9TS7il5iaI94xpcORpKpQTiS9UeJ8FkEXB1T0sYTTt80 +Kpu1gJu+lnw/JI9s9L2OUQDwFJoGbBjGKOy24OfAX2i00I+JyAhmlp7X6cpg+dJbTWKjgap0pt3w +c2bgQHtolqtozonN8nswVUpvdh7JVOTP9vWnZcoqxPY2TgiO6aamAvyD/QoZ5UMuHExz4eIgUg4+ +XKRp0zvNMnXCdB0Geb8n3us0wrBOQ3xuwxXo3wSFSP/NjvC06+mbbY2fcd7WVVajj7RsVChTWkVi +HDUNgkpMcPKbJJXus9Xo05F8EwBx7++iA8B3DGXulRO+1swG4kqGuhKJeqtS0UWIFb+Cy8LOnwyx +ugOwldwZaPNQfrRUrPjG3+CW64WxS0TeNPLXk8otBEX8ISRYW0ZiMISIIYqX9VgaH5ftRdmO2IXN +0cVq5SmdpgqQd14uNqwbnzUXWUUTR5v1FndTqOUwJYbsBm++yLJtqJB+sg4RIUM4/lWSh8VMhFDK +B7shItUI3APfsL9gpQfZkSEGWr9OUgRF48tttZFbKH3xncJoKA4ntQ5yMkhrUHMaKrqfpgsh3qtk +iWDVJpqYfwtKeagDPkgyUyp4vE93jh7oT3IqmI/aTC+OeLEiZQlg/z3bwJeKGMgIH6OgAuRSyB3k +oN6KlHb3oITFoY3A6JOUAQnQ2feSRiD5w9+iAvGCtalUjQF/UuQX1JelfpSL30aojikQYPmgcpxI +uaUbZvoop7YOtrKCq0McJsUfogt+Xh7SQ+mB0nfxRZ/BOrXxOdpcPEMhn0lNGQbG2tea2N7HG2xQ +pjvKFZoaXlfX2f6qqjA1E94Ps5Z183sfMmoKuSpl1yk+t+0Lvm4h7zSH9Y8v/5gafsqXZh1EqQPE +t7y9QfA9qHICiWwdpGjPwqbPIO+tByNCtOFdGUJZU4700jxueC+3SHvgRT9Pef8eCpUBbKLGtf5F +9lwfTdt2kuC5DS37k/Q01e3hfEzx6l5LU7w1xV13qBY7k7V34oawgjYqcF9pE5Fccdxe4fMoU0wF +X7TSpJ+9UwovapF1eipLw18OShDePLstcFsuWfFRi1PjlggRxw5pOH9FTwIz1GTg29Rk0rAZSUa+ +ks3gr5GEMBjNmrfU3Jj7+/6cNTOvCfPJAaqLDY60sxtoXV4+8jlr5o9p1jeUEpIp3YSfc+CqruEE +gQF2PaeAUuCQwvoVm4emiX1tabeIlJFX+AURzupyuwdUITUJcM6k2YIBaoUb4pvPvyXwxY3U3rfh +XRlCuUziWxtdJb5BCVsslZSuJBPLbogtVJLZk6j1lNF88/HeOajBwno1FlekRKgh5v0ElFKTsp0Q +R+yPq2DTL0BGSCbGa/ogWUflbqSjck/DJumMfCXBS7BISSQ/nExKqwwxKd1NKj2o020qUpvKnzXm +lFGRMJeHnbky0XWYC+ktRcSsSEOGbFxEc2+3UPck5XFOWss1JNqGsFT+ZN9Jm+rQaarF0D0tjuNn +2J8L2ihq+cN3RzPF71QrlXxkzlIuiszq2jkyV1ELj3tOvczPFFiPuYKoiYOI8Ek5+XFLeC62NEbi +AsTA1w+axYqcbbph6zFAr1PbJjdDzR+nXuF5khVeAq3V5YF4PLuto7s8MlqRMNtGX+H+wUPRVcXa +glluTWXroG/z7NTlYSMoI+9LXzGeDQKLDubH12MDLjqfkWscE6zO16lhPfyVoXwGKzydeoXnSVZ4 +0Xn5HY6i8zIqOtdKEp230Z46x4c9+McIkxorcUXJlbo8bARl5H3pqzrnCcw6kHHVeQEuOp+Rs84b +9qTzdWpYT0vF6nyF50lWeNE5FFhE52VUdK6kIDpvoz11zr2br+u8EVeUXKnLw0ZQRt6XvqpznsCs +AzH/nHFswEXnM3LWecOedL5ODespIVmdr/A8yQovOpfRE52XUdG5iDSFbqM9dY4XpTdV3mjLOm7E +5WGjJyPvS15VOUtf0oCMzG5egIvGZ+Ss8YY9aXyd2iJ/gtX4Cs+TrPCicREc0XgZZY1LSHq6xvto +T42b+hgfq/JGXNFxpS4NO0EJeWf6qsp5ArMOwvwIS2zAReczctZ5w550vk5tgUEfJx0W8FqOM8DY +gDNtzMQVvvw+hSGzjDQzs1Q400RYoBeoSz10PKfwyLPk7f8bnXQek+1vF0qCSI8zQt0gojT0T9Kr +bk1jTXvxF7TtC1lD1x6kor1V2117bIs7PSzVO+yfYlPbSOnnvj3etRARqsyxca/P8JdpQhDB06tu +RJ2w5FkLnQ/MiKs93CyC2j8lMCoY0Qv4FLHqJx7y8aldJL0tCQQ2+9vwrgydI/lNH12jXYR7cVT/ +3w7/v9IO718GJrQM/us3mbfPWEnfjk73SjlEBp/R5lAOkRu5/L2dsshfnjAxtT5OP1xg42DzMQ42 +j8Nm5Rn5SkaPvRURiNUP+6oGU2l+izfam9tq4237JDhBHTp/1rjTVlrCXR42dspE1+EOnyTZYK0t +kfZnb9c0ngF2LaXwVi9eY/dxwc6yK1DyNIDBBviCzUMTGUXIg/BV5OB5khV+QdQ2pR9rzNjil7a0 +Y0cV5zhcu7FRxja6yyNLG/x9dI2ILUPYscFvIL0HhxsfT5SBcmsF5RZHjb+EeSVuJTZjXWcXEqnh +nWImEiIBORAq87CTaeIVydTYrSVaWc9IlgtonNQHFpAjIwaODBX8xODOLGmFryLYkjxwPIgeX4dN +CE1DQqi+ouzzT27zHrF1qlQ3/81jJasH7qIeuMNh5y4hX4s7p/DFdV0N47GS9nwYw4vnW3Esf9aY +U8LRSJaHnbky0ZWOldLTJER1PfFiDnaGS3Qt0rVbdPRg8TP4kjExGnqsVC9Gwp9vPXBJdj35eYmS +ob6pxmijRmfMyFeSmzJhjIrUKOBDyxuFsspvGUX+rDPnLLX4POzMlYmuwhz+uCfW+N0ohrPGfoMw +P4A9qgh2+IELLwYuPA2fGflaXMgwcDH1lgbK8OeaJA2feUgIHejemVAFJTiVNn8Dm3iJNljlTL4R +pB74IbnSXRl2fhLytfjR2HPZFnzQVPBaOmoheUgI1VcUPL5xhwp++yS8XAtlbnjWmvPyKDZwnN5W +Rx09DxvHkzx2FoCPZ5LJgm+PbyoQ1KK0dp7SmYadzpHsnekMZtiCP7/kOsEq+hw0S1zO0XfnqwM1 +cnrbrg68j89peR1ba8Sar3GdINnh8ABHu6n66qXXR3OJyG1PuSrmt6dSMTdrcEP1lYfdGspEV7EG +LK+39iYizP40D+uEbqiujJI0CuVhZ8ddscAqb1T4KmGIuz5/4Y2cp9z9oBrDNNe54rebQWAoPzvK +b6hPJ3HuKz8r7BDEttstzjCdlQKcX5ywIOdMf8WGZE+u2DkFXLFLD8VwTZsVu3RWFrJ7dkluVGay +V3gmcIVnUlZ4XnSFl/aLoRd/6qgcFWp68aePdjwqxGJs4+KPj4Q4meKR6Rd/cKj7xR8f96avVlJb +BNbNp/1qrPOEwDxsFGXkfQmse9MWgTlmNwJzw7QRmIeNooy8L4EprvPUFZNf701V4OK+M3It1Gfs +6h2Ccd8Vu/qMYNx3xa6etN7Jkpq5k4WTrPBM4ArPpKzwvOgKL+6r6R2uOiruq+gdrj7a031hC9i4 +w5U8st/hkpFQl4eq3+HycW/6qvtuEVg8shJY/LUSmIeNooy8L4HVfbcILB5ZCSz+WgnMw0ZRRt6X +wOS+PHXZ5JkrcBW4uO+MnN13xS7eMWFn912xi89M2Nl9V+ziScz1OqmY63U4yQrPBK7wTMoKz4uu +8OK+il7Hq6PivpJex+ujPd1X263reMkj+3U8GQl1eSj7dTwf96avuu8WgcUjK4HFXyuBedgoysj7 +Eljdd4vA4pGVwOKvlcA8bBRl5H0JTO7LU5dNnrnNWIGL+87I2X1X7OIdgkueV+ziM4JLnlfs4knM +TUkQ3HpTEidZ4ZnAFZ5JWeF50RVe3FfQm5V1lN034l1F0Ex23z7a032V2rhZiQ4p+s1KGQlxadjp +Scg7k1e9d4O+7I+Nvuytjb407AQl5J3pq867QV92x0ZfdtZGXxp2ghLyzvQl32WJS+YumGupFbi4 +7oycXXfFzp4xY2fXXbGzv8zY2XVX7OxFK9koOJEEN11/jHhTMoHNvcDYgDPfzMQZPk+S5MHMkuTB +zJLh8yxJTswsSU7MLBk+z5Lkx8yS5MfMkuHzLDz0dzf/A2big11lbmRzdHJlYW0KZW5kb2JqCjY0 +IDAgb2JqCjg0NDMKZW5kb2JqCjcxIDAgb2JqCjw8L0xlbmd0aCA3MiAwIFIvRmlsdGVyIC9GbGF0 +ZURlY29kZT4+CnN0cmVhbQp4nLVbW68UxxGWDThhiWwIUaIjy9EoUqRZOzvu+8WRIpvYL1akOPGR +8oDzEGEwRAYEvig/P9X36uma3cPhAC9zenqqq6urvvqqZvbFxBYuJhb+l4sHT3cf/9NO3/2wi8PT +y+92L3ZukeFfHMDXD55O985hvps4W6wyfDp/tGOL914qHmfwiXN4QkxWi7DE+dPd/Nb+/L/wEGf4 +KanVwrmcDsbCfDOdf7u7DzMPbtFOCzW/vT/wRTnj5mt7vkjntJ+v7/XivDBqvrEXwizM6n+ffxlE +CyxayEVLrUEbEDpbanW9aCGNSlPuB3GL9tzY+R244lpzN/9iLxdlGefHF+OwmHG+SIId2IVb5STs +QDOzOOnyY50CcOmFFVnHG0HHL853/9i9mBRTyZLGT9rJycB+F2PTQXE1ff48TNsZySfDhQ+3nu6M +bX99n/5ikue/JP7r8e5f07MLHDGoC9K8Mq6dsfH5jK1eQHcLVlEqHnHbQNCNa+uRctxwj7RLf1aF +0uSr1Y87D76zraDQwiIFhTYWKZj+rBqlyVeroGRyEWpbQamsRgpKzTVSMP1ZNUqTr1ZBxe2WdhCf +VRcF/18+3D3aGmzn7lUd5ho0GSbDqKVmC+X4OBtGNTVbKuHH2VKhFdFsJa0dZ9OjcYdMiDTImcXD +gHnj3GHQ18HBGqPgPL4Skqw0SklWGqXk8ZWUZL1RSrLeKCWPr6Qkq45Skv1GKXl8JYUefV2AYgvg +E2BzTkHRf7lYHLjz33bnH96fD3u1CGl9yCUwTXLB519DzmGLUV5Cqgnpy7n5FmQfJ7md7+7ZopV2 +zM7vwjy3CMgKkCUOalHGWjN/s98f9GKktgLJfA9yFsCR3bj9wf5gAAk0k3WCUQ5N+E0YFMLbuCzk +P2m1na+dxTzjjfUhU6qFSQ/K3t3DHr3kZr7T7qcdCGXappp4tKubGyLrhPbUIeRprmyQxCGXgnny +I6Be2FM4Tcl1u11MJuV8Fi3ivO4szxcLpoH8G7YLjuWqaUCfqan2zctmBST07T34iBJOzcgyVSra +eNRHq3nZHyBzw5gGMSFDCwb4Ca6aE3nat5XcY8NEjeEwNm4T69wFHYP9QbPr0b0gu+AzycYSNp80 +mAM/jk4Cbew21qhMpWxIP5MdyTCD94FGaQmkgmgqxAIHwqN1t33KTmgpUuhEeS9a6VobRQbKDgNe +MH8UTQ2Ia+ij6Hw9eI52Bt/f2EDyE7UkoIl+gg61OgcRcYQHh90j7Udn7U45UVATNDgophdvzXTI +iBb0yHZkWnZIg4ZRJNclSqgyFMk5MsB05ZgcD0obeNoBNAb9C/zVh97LujJFoQxhEBTd6GB/G0YN +50D7aTP0aDOGBfdw6gIBz+j2ATnALNzCQsHV4EJb1YUNAl1ajbKxd/YwpqCUqM4vdWdJuPJcGbx2 +B7kFCguU8W5DzQ3/tD9AirPeSjH/EV1/iK7b7NvZU/1iS41xH9sMp5ouALMDfxaOQYEOph5snxXQ +Q0fOqYcHcl9dTBZjUDGFIAMJyv4SohOthOZSKSBLvH0k38V4J9AcWSPYEI4MaI5oMhOrAFIy/wHu +QgHJpZ/fB5HSCGcUvXGk+cn8ggxTJOVkbISPi4JGDorW9/cBHUA7ZMM/x21q7l3NeQoKuYpl6FSz +egoiBIIXNsWdwHZFhkBUI2kNZFHjTbXo/33Un3Pu1ogGS2gmIqKBx0ZtfgePCcb6yKzgCZh0p2FO +Iz6Im3W+l1lYC923IswBa+SN49FI9G6CPt65+Ioght3di0s7ZhBQIX54K+UkoPUbLKc+VHzD+y4o +Bljtskekrnr2+GAQujTks6HB4e0GJKHRo7FrqcyPwY9mlmMYnhE3EXDeyI4KwkQlZ6cTbAHTowm2 +ZL820rgpSQZQgGxAaEf3+lSnOopzCvDpDNfuI5UpNMzieeegQ0CEjV7QCDh7JC7gTW/qvn4peuYA +8ALTIgQk1D5ud2dZ11rXR8F7luQe4PvgfScyXXrImJLfACP8/BWsb7iDwXttMIWYAP7U2OEW/e5h +LLQqO15GhAFTJwus3tqYhY3Uq4/DgjZHS7yepVElWt0gEklC+gdwPpDkwFnoPV0cT6iKvK9JeTgf +bYqfM26IbVAOhQCVwG3MYAb+uKX00Ty9Vd8EJ+EeaIESR6DMk7m13u7Qpq7eRVwuw7oDq8lnhCPX +8U+KEFIwWi9ankGrnKBUH4WHveG2rXGkBxB03aigqkR6FaIMvGjt8GogPZqFDBeadJ7lJAehVHMc +SlcE6RtLi1bNR/61blpENKPvoxjCYAbRAkEmOjSrTGlwVoCUOwS6nKg/b7dHBhwSDXOZxSUZEtQM +iyKlWo5o2UXyVWq2luhKPQhBI/aBE0M+xO0uqldYj7mJw6hZCFFjj13Tp5G+12vFIVFEArbzr6Io +BUyeymAoxO8MxgjnFHg5VzGyRWDYHhEya6qz/gVUM8CVQSA6CBqp6PAmm2NFOb4ZtF0rMVVgtRoi +nz7VZRuqmTW2k2FNw+fx0rir2wJx0JBjqbINVXW0cenamEoYFLbnQihyvEJ2EJAjK1DC8WGVnd2s +7QejqfYD4qnrUj+Trjr1GtKkrnmBDhk8o7jvsIvI5Bh2tmjSSr9VpI7vCVBHH4EfSe02PPngYUEF +D53s6K67R/G41pVwX292mJcQtS8piwsgwG23p7EcxchwtPRD+nSyj70hqGVtQ6IzMkBRCHTeFZWE +qSK0+TgXBb4Ak0V5FZSrAQ5KpGrAcl2qAc7x9nMDRViJe6PomKfmOS0voPvNvJjWk85xqi6gXqPQ +pQC6REauzoUYeq9emUn1MwdEzZm5ON+qWxGimnRX9PBEYiyaMBov6Eyk5O1KNvezKuMmmNXdzNLD +G8QMXa0J050P0SCgE/cW3qH0U0qbisqY46Ls0u9Rhq7cyGJw4q4CUSFOprATXL/G4dhvocMQxem1 +i3L8jg8MCQZ7bOvvDAHF0F7QWz6aA9Dt3tQncAjubtWUpmX1C7SJ5tw0Ea3eN/IPt+r+92F9Kdpu +ZaDtsLjBtYRRXUmI6DrKhwO55utX15du/22l046ilt2vGGqc+PHeLz4eJvWChkhEF317umq5Xph8 +92+UxnR5jFeu0+MGryzFw5fxfYLlTKDgXr+TWnUkuhcLDWwKf2fKtGIzx/eIoV2gI8jLy9V5fVFe +j3lVjEW9uk44UT1ReEfy9gZ4d0bKcHMsDk7VARvwlPqjExXicVfA9VT3yUjdHtk6piaOpAW7Qdtn +qk4BFXCdGuO+nOhBwIo57klmQ4IBjQBf5/6JKwDn7dZbjgIA7UDL7hDHbt+NoEXGzrIbuskEwWlQ +gbkKPGYWq7ww8ydBrmfWYvbdvQ4ua12AhJSXJkRjtichpyCjvdWaqLYZQpSB6K4koZq7Gf2UtyZu +A55jZPuCARX5RQ+iPze+69aYVPRBq+AZrjAfILglx7G3ASR5cJ1KAwZtvNigurD18atgBp76qmDV +6+38aFUIhPsneEvS10G+PdkMpXMc/TKGAiF8Gtezf9hFMT3kBsoiRAfmvaNaiNj4ECzwqM331YjP +xI9Ow/eUymoTPhG0Wk/66j4S1IaFT4XPn+7wN4GIDmy9ikGcaGgZ1jLTlhqzhT0qHK8h1KVxA3G0 +deu16x1+tk8fmUs/gd7GMdn261X9Ml9ChpggvOuOfwgHAOfj3fwQ5HsjhZ6fhdCATAHA8gRUUSqm +jedt9CXslykOhz6BBnB8EETft5lZEuzk5/ZMG0Qz8+PKo9v/i0THeyiGHoZyEnzfzQ/q7Z+ayB+b +IKQnuWZbKO/YGo5FNfmPQ1YwSsSP0Azo4SC1/yfeFkbA44CuKiBJvm3hRJAij5NMcLm8engorS6s +nv8aVgf8NQrPfLK2XXjoUTSyFHihL4LvWK8ZD2YaF3pQr35qt4+aaa1o9FppF83qjyP+Dv6mQBPV +VKoXT0KzCsAYXPBBOiwR9gBZHjxVZkfp9/A8GhhyB7XBTUtm0VMkQsJaHnlINiXabHFo2W32GSUL +TUWXSJmvQleWG9h4O/+6ox+3pHcTA0ua9kKzRNEcW6SdDvE3I8m4X4MY5wBtXTaMhGdThIhAKsvW +JM8rxtFsdts99axNzQ7HBeyhym9Ri0L55+ruyFzfUiH0MmYfQMfIzQBo689ajvwOAyDbAsbyULcl +xPkknaBPtSLAfGiLfRr2Y034jc+nlaeeHoSEwpjwl338ChYK3w3kQcvcJQepq1cQuf5UjpeKwJn4 +YWOsCMLxBH9DHUw649TMnumzU0my4QGRsX3ehKEp6ZcS2YwSEU3HH7KkVPw5uLRSnuNPf9F3sGOH +zuI6CnV48dcY1WwjmQwOPn6mQH7iTPbA0eHcg0EPlZtdFzfj6VzKpV/xzJorvonQfHMR0wajcwgo +Z2sn5HIrJpextRZPIg/Z74LcXwZuCRxfYAKIaCbmluSnfuvvkJjq3563sjDQPEa+aF39luIipUMR +e0b1wNEvPVoVuYHw5Dm/psNdARgdcY7ow0odmxl/H7rtcAJIwdbjiWmpRTrZfO/KcsqVhc0KSfNv +AP8PSHdMmWVuZHN0cmVhbQplbmRvYmoKNzIgMCBvYmoKMzQxMAplbmRvYmoKNzcgMCBvYmoKPDwv +TGVuZ3RoIDc4IDAgUi9GaWx0ZXIgL0ZsYXRlRGVjb2RlPj4Kc3RyZWFtCnicrV1dz2S5UVY+h5kd +7WSZZEIikF4pgnSTvJ1z/H24A8EFKFwAI3Gx4SokIWg3aDfc8O+xXbarbD+np5N1cvPWszXlp6rr +2OWy+/QXT9ttV09b+n/945efv/rZv/qn3/z+VYafvvzNqy9ehZtO/8uA/PuXnz/93fuoH5727eaN +25/e//rVdjuOQ5s9a+xP+x7/hXryVqUh3n/+6vK16/v/jv9o3+S/0ibc/P707HxUd0/v//PVp1Hx +OdxssMpcvn593m8muHD5xnW/6RDscfnm9dnelA9BXb51VcrdNm//4/0/JdNKmlb6ZrW1kU216m+7 +N0FHq3Zzt6BD+Wcdo/jnobyq/ywOcbPH7vzl2/Gv3do9XF5c9c34bd/vE9j1zYWDxzcfHDhsfif9 +aDlG6x/ev/qXV188mc1QVN3xZIN+csqZm/P0oe3m6e//J6l98ONK7PZIadP8eR3F8pPfbvHTUjZ9 +VJ9GX5+3m7XB7Ef0Vt02Z4L860/Sf1dHNKUuL9PHpXa76csvfnfd1U0bEy4fxU8ufmJH/BBfX30K +3KEuv/gyolv8oM3lO9fdxk9+v3ycFQ8brab/vN22YDbv7OVNEpx32vs4RhrZ2mjimlLiOPY4xg+u +zypG0yt/+dF1SxxiaC9/kRT2XW9e/lkZO9dYWiMJ6Qb+KGPR0b0bTVo4Jfqdq70ZvW/H5ZPESB3O +qEH9bTSpbi6qfPcaU0Sr3V++dzW3w+lNpVHi4NYHd3kXbR0xYfZmwGq9m8ufZyIqiuHykziKt9Zo +07huStfIxGdI0v7L9Aw5FWlK3Wic05HzQx23PT6QP3/1/q8/TSEzt/0wMSQ/uKaQGp3/oU5pZrO9 +GMU9ZVTM3N5ZEx9WF5142f7hN5MxFZ+cXvfF9VlHv/aYCd+Oljfn6RNKg5Qo7j4qWBf/e4qcCfvl +FoNkVTh8TqTynyPHlHtGx2kjBmL3MSXTWOWjjnHPUbMd7+9en4/4BCaCb6/xod5isNNk42LyRgdi +MkXr3tiouMXH36XgdvyPZGB3cfxPmqtfj5Z25dNQXyZTh7FeRarFp+Kysvt5CNkEDRyfJF81KCF8 +srLtR/wwP0p4CNow95THT+OHpo48ucbPwWqnL3+aMsPbmEX02ehISPznN/KfZy/cEYTqt3IGKRMf +A+XqhPcXmdVmYnqTC04dcaA4WRybian7sn1IH7PNHwxJkqyLeAf2tIuAiCOljjv2LhadNkzKj1tc ++s8354zVKYSFrrTLo30jP9YmxVAqsOuUP1rZy9+kRDlC/FBL5PJSyo/ec43ks8qLaFoPvsbrwSun +7ZONU3NaAz5/tcf/NfGzIuptJzHrNum/Xv370+8eWSrsvaXCxaXC6XBztFh8K8UgrrTm8ldppjf6 +OC4/jn8dm9MptZ7jTH+kwP4khVDpuCT89OrTOqt98j57lfzqPEmO2d4xKx0b/HzUs3DHsV2n6Zhd +E0HP9PTWxT1OqZJeFpleVl4b+PgsR2InkY8PwK5tnDxK6A+XQm9vzsRpO68TR6yozBFjHx9BZ732 +l+drcPETC6H/GKRj0c/42Uk/s8h+9m6v+BhUrNyO849BxQwT9JTbJT0SGx9SXvsxKOvT0jh9Ds4f +9XPwsUqkzyEujtPHsMeVNC5c9Aj0se+8Sc6F3rnQOdf7usS5OD/eVBDB/2Yf/FjQCH5xXd0EPxKZ +X1ZezM/GWIavGvyfweB33kTn7N45l8XmzeDrEudMXEHOY6/jIyvoGbVrQY9EppeVF9OLmzVjzmKf +pv5YH3WhH2Z+7VrkXRf5zpfk2hE615LYfBk8XeKa3WIZKZ7pODXK0EcGXeijy5JfFgW/Y3no7Z6y ++CQ1bJ4kVNqEPJkn//Tlr179uoKGQF3AQzfQOlXhuLTaWTmibCJuNiqutt3P2mpTe0PjlqzhccsN +tL1VDY31YMVjqeVmbe3cxrb3ZtvELdfseUVH13ehau6CtoE20jEtHEAZo9luTINHQNvAabBRGaPZ +bkk3E3PokMoznhOj2Ygldp8Dk3sY5YwLtuExM/SsjVGyDDzEKHOexhu1MUqW53CQNsQ99AWiipPA +x4hW3BsDtDGaLQNfIKo4D6bxJm2MZsvA76wN8QB9gSg93ZQfx1Hx+HSDhwWjZBn4AtE0Xs2PcbxR +G6NkefabtCHuoC8QpfmL8iNO9KbNVODpwihZBr5ANI1X82Mcb9TGKFme/SZtiHs0r5TtqjoUrZ0h +mCZ9RtLujdisNmnFXoL2qnFDET/cXLHkLtLN7akP8JH8My6szvmQWl2Rxs0b1VUocTsvnDiUF05k +qdHOmkud2GNxcjjhxuXjrjqRbHI/QAlyJDY+Pdcl7FJpZ7ogvxkD61MvtQZWj5t+1bGnh7OxT2Lj +OzizatNvJP1p129k+saVSOYvicwvK6/l5/abgSmcul3UZg+pzf7hSOfqjz1xWiYxiexJVl7rybHn +ffNZGneEUn+le8hIZH493TX8XJ8JLZGHSH/n6oK+xU9+aJv0j2E4to5+Epl+WP4cqrgdUXcSWe1m +E/yUpjqw8COxESLltfysS5tbEd0XJaQ6HfDQjJHOJn5Hc/Ge+uiUx3vfI5HMoyNGa+lIFtmR3q8l +jgSXWxBneRwZyBlNOSXnYxKZX1Zeyy8+Z6HP49wF2bTacvO7RrrmsR1aUKqnH2xHP8gZbvBmBf3U +gXL38vhwu+Cn1S6fMxKZX1Zey8/a3CUeErnEVCTyJ/znRzCR4+dxdJ5Y3XliZSKT8lpPQkyKO4nc +EcrNvo5fFgU/u3rB0Ec6exkS2cZJzocgA/3dmMf2Zo0fu3kde7s5yT6LzL53ZgV7s+thufva0M7z +8jkzZU9X+JHI/LLyWn5W9c/ZH53HkevWeeJM54mTJRIpr/UkqK5EGtK445Oai06mMYmCXsd2DT3f +rxclje2mj7oH2ZW7fO/q/Xazyg+tUdelSXzOJPssMvusvJS9jf/pvD4uzSQ9bij9jJb210OgbSDo +ifXKGM12d182qfouaBuYBtPS7KiM0WLXDDvibu8yNuCajT0uoF3ra3IPoxx30BDrtTFKloGHGGXO +aTwtLY/aGK2Wx3BUbYCDLDpDFScBaIgN2hjNloEvEFWcB2k8LS1P2hgtlie/izbAA/QFotQQo/yY +G2K9NkbJMvAFolZxfsTxtLQ8amO0Wh79rtoAd9AXiFJDjPJjbohN8xdAyTLwBaJu4/yI42lpedTG +aLU8+l21Ae7RvLKigbbR7cyHGmh1o6zT3b795kOstGRH6OW9PkXtB+3Ol200TaIk1n7QZkIVk3IT +V/aDmstD2fZVeznOwHCeNnNKjJU5SjhjpVqrs/SPXvCfb8o/0umyqwpH3G8fH95kv2WFj9MdyFgA +GblhfCE3jPYW8y34NIDO12X0SdEYB0Awu8CV/FtZyad7XFucCfIIm4710NkIXVl6NkCusV7KGut5 +uxnn9ZZGaGlHS7Kb+uJ+Rmmxfwy0DZzKmFEZo9nuZswjoG3gNNiojNFiN8AyZsZzzJqN4RwRuIdR +jvtUxozaGCXLwEOMMudpvFEbo9XyGI6qDXCQRWeo4iSYyphJG6PZMvAFoorzYBpv0sZosTz5XbQB +HqAvELW8FkxlzKiNUbIMfIGoVZwf43ijNkar5dHvqg1wB32BaC4rHD7XA/MXQMky8AWiabyaH+N4 +ozZGq+XR76oNcI/mlXKOuJmNCoN8clgkOkc0hyq74qTJ0rJzRBsrQmUeLINenh8jNh/yYVzzIUnM +Ommu9aEcI7IX6Bixcaul1SYqLebTc114jChj/JLj+q7VQ2/unCIK8vSwNfJRZLqDLwurRhHb6RSx +C649nOSXRMEvKS/mR5UnyuDTyvPd2SmifAx3pw/pSRKFJ0l5sSdHOg89TeKOTz5ElNNEFgW9nu2q +Q0QXukCLQ8R3MuQwupJvoh98Rz/IxBi8WXOIGG4hnOex2rWcwJQOcpLIIhPKyov52WEOEzNxrP7f +wh3O67NjxF26YpSVriRRuJKUF7sSIid1nskdoXQO5zp+SRT8erqLjhG7OH89fWtqOw7FO3zf9vU+ +bQm13W/W6eE00cmEVr5b8rIovEjKa73Q6ZLuvYTOB4SNHx0fNn5ZFPyS8mJ+dJooA/3hDfWbO8eJ +whWrO1esfBiz8mJX6DjxNKE7QvU4kfklUfKzq+eOcpwoQ81NiHePHScy+3x+yOyTKNj3ziw8TjxN +ZDohbPxM2doVflkU/JLyYn50nPiHJfLLO+eJwhVnOle6SSIrL3Ylnyee5nHHp54nMr0kSnrLp7Ry +njjlce51vX3sPJHZ627Zy6Jgn5TXsi/niSd5XJpK04VYP6OlXfUQyC6C3hi60I/smmOfu3MAtA0c +B5uUMUp21XjDtu5iRjzFjG0MjTjgHkY57qAxhi70Q8vIQ4wy53G8SRujxfIUjqKNcJBFZ6iYPUFj +DF3oh5aRLxBVnAfjeLM2Rsny7DdpIzxAXyBqedIAjTF0oR9aRr5A1CrOj2G8SRujxfLkd9FGuIO+ +QNTxCgUaY+hCP7SMfIGo2zg/hvEmbYwWy5PfRRvhHs0rKxpp/tHb+J984DDxzQOHidEHU7bTZbpt +t8mT6A9bxaTcxJVtIY8ugH31W+FTHIdezif3TxFFY+KlvN28xy3JEVw+RfSHiZu+BzbZ4pyRR+A9 +40u5Z6R/Y+mMLz4WYf8qZ3y5fhf/+fvpjM8fenP2w6eI/bbq7jHiu4eOEWt6me5LihNaaoeHQNvA +8YLSpIzRbNcf+1xlzKBt4FS9jMoYLXYtrF5mPMes2eirF+QeRjnu4+2kSRujZBl4iFHmPFUvozZG +q+UxHFUb4CCLzlDFSTDeTpq1MZotA18gqjgPpupl0sZosTz5XbQBHqAvELW8Coy3kyZtjJJl4AtE +reL8GKuXURuj1fLod9UGuIO+QJSqiXasJ+8hofkLoGQZ+ALRNF7Nj7F6GbUxWi2PfldtgHs0r9Ax +Ylwyyv2ifHBYpHKM6Fz5Xn/WbNK6Y0SnUo/9sQLozekxIvuQD+OaD1lqrLPmUh/qMWLzAhwjMrdS +VFVyJDY+PdeVx4gixqJcLPXKB84RJfv8tDH7JDa+gzMrC0YOLvg2ouCXvn4o+GWR+WXltfyo7gQZ +fFp6fnL+ZUThSPo6n3Aki+xIVl7rCH0Z8TSLO0Lly4iCX+gSd6C78MuIII/ppt8jX0aU9I+to59E +ph+WP4bly4ineUxHg40fHRw2fiQ2QqS8lp8dJrFHzhGjxulBovAlH8WxL1lkX7LyWl/KQeJZKneE +0kGilnMaicyvp7vsIFEEmjeFb3hT2LbvQ2yd3jruYtb4rIjMPSsv5a7Te3fupPHhJD06VGv0SGR6 +WXktvZjGfUHxx38VMXSOWNU5YuXzSMprHQnmblHRESpnh4JfFgU/u3pdTmeHQ1kBv4r4/as7QoTV +fHYo2OfDQmafRWbfO7Py7PAsjek4sPGjw8LGj0Tml5XX8itnhziP3+JuzYvzs0PpijOdK04WSKS8 +1hU6OzzL445POTsU9LIo6HVsV54djnmcG1wvHjo7FOx1t9KRyOyz8lL29ewQ5zF1kgK4xD+h1KN6 +DGQX54bYoIzRbNe5+bI9AG0Dp8FGZYwWu/ASP8BzzJqNofsG3MMox33uhg3aGCXLwEOMMudpvFEb +o9UyvMSPcZBFZ6iYPedu2KiN0WwZ+AJRxXkwjTdpY7RYhpf4MR6gLxAVS/fcDRu0MUqWgS8QpdUf +XuKftDFaLcNL/Bh30BeIippx7obN8xdAyTLwBaJUdsJL/JM2RqtleIkf4x7NK1/Unpq4xF+l0n2z +RpOUNZu0rvtmfKo1Huu+vT7vvjUfSg9LXuJvrLPmUh9q9615gbpvjVvtUHWX+BufnuvK7puIsei+ +vX7oXWCSPT1t3S3+xndwZmX3jYMLbvELfvnaPvPLIvPLymv5lVv8IIVPb/Gf9DlLqSFv8QtPssie +ZOW1ntAt/rMs7viUW/yCXhaZXs925S3+OY/zTzX8TnbiTq/xS/7Bd/yDzIzBnZXX+M8SWe208WnX ++J38+ElshEh5LT9rbjiP72z43p1031yQrphuxiORXcnKa10JJu+tz1K5I5Q6WEZLfllkfmb5nKbC +0c9pqQH3vN32sPlNiWbc2dvAjFzslN/klEci0++9WdOA80N4UQeu8astt3bpfesyOSuv5UcdOBHd +P/bWc+2q8fV91XliZWaQ8lpPSgvuLJE7Qp+3NlV3fV/ws6sTubbgRKjhOwTuteCYve3ymERmb5bn +cW3BneWxKTuwduc9bIIfiY0QKa/lF9RtOy19SpsAXMue0NKAeAjkEgR0O8C1bGzX6vAIaBs4DTYq +Y5TsGlX3OqFTnvAcs2ajf80Tcg+jHHfQ6gDXsk8sAw8xypyn8UZtjBbLUziKNsJBFp2hipMAtDrA +tewTy8AXiCrOg2m8SRuj5Vmd/CZthAfoC0TFlAxaHeBa9oll4AtE86xe8mMcb9TGaLE8+V20Ee6g +LxAVxQBodYBr2SeWgS8QzfVEyY9xvFEbo8Xy5HfRRrhH80pprVhd7jpTM0Wb2oiIktkdSVmzSeta +K1rdrHqwtfLivLXSfKAGRfUhS4111lzqQ22tNC9Qa6VxK+2HSo7ExqfnurK1ImIMWyv37jUJ8vRo +dhfhG93Bl5WdFY4t6qwwP2qlNH5ZZH5ZeS2/0lkBGfzHvB9BeELNieZJFtmTrLzWE+qsnCVxx6d2 +VpheFplez3ZlZ2VO48ffjyDpB9/RDzIxBm9WNlbO8ljtm5zAlLZykiCxESLltfysyt9xHvO43LL5 +SN4D+dDrEazqPOmeSBLZk96xNX0L1c93Y19Fd8+ZcspKflkU/JY/Zyr4Wz9h9G0V/vv0Nes9f7d3 +/J2ckQd3Ft1supPGpbCp5HLty+SyKMgl5cXkjq6egE2fRq90eSo9EpnesZ4eNX3EZ/8V3tkQOk+6 ++YLERp2U13pSmj5nT1lHqDZ9mF8WBb/ls0Bt+ohQw3c23Gv6MHvq8jT2WWT2vTMrmz5neVz6OJVf +6fJUfiQ2QqS8ll9p+mB+pYExnQ/7GS0tl4dAnvVAHwZdcYF2009lPgDaBk6DjcoYLXbdsAvrKuax +6dNsDE0f4B5GOe6gCYPut2DLwEOMMudpvFEbo9XyGI6qDXCQRWeo4iQATRh0vwVbBr5AVHEeTONN +2hiVz+rU9IF4gL5AVEzJoAmD7rdgy8AXiNKsruB4ozZGq+XR76oNcAd9gagoBkATBt1vwZaBLxCl +ekLB8UZtjFbLo99VG+AezSul6WM2+W22IpWmjzrKGULWbNK6ps/u0w9GP/jjel+ed32aE9Q7qU5k +qdHOmkudqF2f5gbq+jRupTVSyZHY+PRcV3Z9RJDl19m+fOxGjaCfnzemn8RGePBmZd+Ho4v6PsyP +Gj2NXxaZX1Zey6/0fUASn/Z9Xt/p+7An1DppnmSRPcnKaz2hvs9ZGnd8at+H6WWR6fVsV/Z95kRO +cX7dXa45b/wI/sF3/IPMjMGdlY2fs0RW++YEP6WtFfxIbIRIeS0/q26+n43xm//ftb4P/iZQpGo6 +R47QOZJEdiQrr3UkfYEinCdyRyjys6Hjl0XBr6O7qu/jXRdo/Ot6f4bbPpJvavtYmcckMv3emzWd +le1me/pfu6ZdoDXm9BWetkttv8uZjUSmnJUXUw59ao/fXorVtuCnlZNTG4mNECmv5ZdugN3hVzbu +lV/Z1ld+JDZCpLyUX93lY360Y92mo0o/o7QXfgy0DZw33tt0Y+DMbv6pzQ+DtoHTYKMyRsnuscFd +/oznmDUbwy4fuIdRjvu8696mSwQAJcvAQ4wy52m8URujxfIUjqKNcJBFZ6jiJJh33aM2RunZmX2B +qOI8mMabtDEqn9Vplw/xAH2BaN51b/iqxaiNUbIMfIFoGq/mxzjeqI3RYnnyu2gj3EFfIJp33Ru+ +agHmL4CSZeALRNN4NT/G8UZtjGq5Fk67fIh7NK+s2KVvKnWiH96l33/rnth3ztcN6qYzFXJi01nE +uumMWwy56Wziyk1n83n9T3iheJ5uGOtPdJ29fE/sfrqf8LL7cdxcV589W+PcLfgHvh8tTkd41Nfw +xRY/SKh1+1Z+2GuPewmfdcv+QYxWPvv0z8TrG/iXw+qL/nZV3zqQvk9cXip4zK/LK3kxlB4jWhb+ +h0DbQFANoJ4/tBvXy0dA28BpsFEZo2TX6ToXdF/YnfEcs2Zj+MIucA+jHHdQCqCGP7YMPMQoc57G +G7UxWixP4SjaCAdZdIYqTgJQCqCGP7YMfIGo4jyYxpu0MUqWZ79JG+EB+gJRy9M3KAVQwx9bBr5A +NI1X82Mcb9TGaLE8+V20Ee6gLxClUgA3/MH8BVCyDHyBaBqv5sc43qiN0WJ58rtoI9yjeaUcMMSn +j9byfKRQpHLAsOmyk82aTVp2wJBeWbHd/8LuS/G+4NPzheZD7tI3H7LUWGfNpT6U8wX2Ap0vNG6l +GrLdK4kbn57rwvMFGePXY0n4weMFwZ6ezcY+iY3v4MzCSk8EFx0vML98nsD8ssj8svJaflQtohQ+ +rRbbGRk6X2BXcoueXckiu5KV17qSzxdO07jjU88XmF4WmV7PduH5goy0/Mbulw8eMAgHgu8cCDI3 +Bn8WHjCcprJKczLzU9rLiYLERoiU1/KzJvW90UxBuwL4N35JU2S7S1/MbqUvWWRfsvJaX4JJF55O +k7kjlJr0m5w2SGR+Pd1V39ntc/kd3uP9MP9U0WbD0LAXfPNXjveOvpHxHLxZ07DPZ1HnqezMJvn5 +TUt+WRT8kvJifu5270k7nJwJtNolPRKZXlZeSy8N1X/8j+z28fXSbn3WyrrOFSs/elJe60rMTnNn +1egIpeul3aJGouBnl2fqsfWZ2k1qH4kGidvtTWkzXC/t1jxtNzklk8jszfI1L98HupPI0QcZXbMp +Oc2SyPyy8lp+VqeDsTG6H+gpnbzVz3aeuKPzxMnQDo6tOULT50kchw+SnLJBksuiIOfCcnIh9SJl +mHETrqwWbninn+3YayUXCxKZfe/Mmnf6bcP+aDqdLGyGFuGIlgbdQyAnE+ja9coYzXY3rR8BbQOn +wUZljBa7vu7ZQ6884jlmzcZwOgncwyjHHbTsem2MkmXgIUaZ8zTeqI3RankMR9UGOMiiM1Q8FaBl +N2hjNFsGvkBUcR5M403aGC2WJ7+LNsAD9AWilpc60LLrtTFKloEvELWK82Mcb9TGaLU8+l21Ae6g +LxB1XNGClt00fwGULANfIOo2zo9xvFEbo9Xy6HfVBrhH88qKFp+Pi9WDHb636Gzy9aj5gV8E29RR +tvk0h6r2iw42FYW7vBDL4sqOVfV4/dEkCOa9XtP9o0lpoTubjFvUuIk6ZEE39ADwD4OVU8J38Dup +P7ymnZnTdAoZI6W7E8sXuMcAfxlM/LNPuv3yzQZdzzmVjnvnMxfeNA/esgKfxb7kuuqtLLGyB9ZO +55wlx4YiZkRpqX8MtA2c6wqFjh6R3bgDmq9CAdA2cBxsUsYo2d3bnYejU57wFDO2MZxzAvcwynGf +iwqFzh2hZeQhRpnzON6kjdFieQpH0UY4yKIzVHESzEXFqI3RZBn5AlHFeTCON2tjlCzPfpM2wgP0 +BaKWl4K5qFDo3BFaRr5A1CrOj2G8SRujxfLkd9FGuIO+QDQXFQqfO4L5C6DZMvIFonG8lh/DeJM2 +Rovlye+ijXCP5pW48vr8OJY7S4d2TfqMpLiukJQ1m7TmjJB66zafYYBjLBucILc7cwh2JDZCpLyW +37HdtDrnp3azCX5KB8mPxEaIlJfyUzY3dBu9rs8kKoHXoig5+SWfQ/phtJZ+ZJH96N1a0/enQyyO +83guoZXk55SS/LLI/LLyWn5HjKnpAi1+17Wvs+C5hOrpB9vRTyLT771Z0/c3uUA+TePD7YKfVvsm ++JHI/LLyWn5xR9g9Zp8+VP2evFfi6FyxunPFykwm5bWupI//TiZ3hMp7JQS/LAp+dvWMmxr/2p2F ++u2HMrnjW14sIehnken33ix8scRpJudmPvPLHXHmRyLzy8pr+ZXOP56R/+DOv/TEHZ0nTmbu4Niy +zv9ZFudmviCXuuOCXBYFOReWkwt9Gnza9qqPdv4Fe612yT6LzL53ZmXnHyexFUtxv2me0LJlfQjk +ZAL7WHA5GNv1oRSW+i5oGzj+cPekjNFiF14OBriliqQWvV3nH7mHUY472MSCy8EnloGHGGXO4293 +T9oYrZbh5WCMgyw6Q8VTATax4HLwiWXgC0QV58H4292zNkaLZXg5GOMB+gJRyzUc2MSCy8EnloEv +ELWK82P47e5JG6PVMrwcjHEHfYGo4yIRbGLB5eATy8AXiLqN82P47e5JG6PVMrwcjHGP5pWyaY7l +g9g0F6lsmp0NYtPcpJWbZpN/E+5s09zIlV1yZUdiI0TKa/mVTfMZv/wjt8xPGWMFPxIbIVJeyi/9 +bCy9FRjzy9+UZn75e9TMj8RGiJSX8itfqz7lZ2iWq/zy96iZH4mNECkv5Ve+Vn3Cj5ZiP/Ww/IzS +Iv8YyCkylS+jMkazXWfnCwYAtA2cBhuVMVrstpPEo1ce8RyzZqPv+SP3MMpxn8qXURujZBl4iFHm +PI03amO0Wh7DUbUBDrLoDFWcBFP5MmljtDw74HoBQBXnwTTepI3RYnnyu2gDPEBfIGp50p3Kl1Eb +o2QZ+AJRqzg/xvFGbYxWy6PfVRvgDvoCUcez5lS+gPkLoGQZ+AJRt3F+jOON2hitlke/qzbAPZpX +SvkSCwFRvhSplC9W76J8adLK8kW5VCWclS+NXKlXKjsSGyFSXsuvlC9n/EpFUvmVeqXyI7ERIuWl +/Gr5csov92cbP+reNn4kMr+svJRfbeY2fo80c09fEnx0rljduWJlbpLyWldKM5dDjZq5zC/3O5lf +FgU/u/pRqs1cEWrxwquXjzVzmX7u3jL9LDL93puVzdyzTC61a+VXKtvKj8RGiJTX8iuFLuZHRZsB +l1smlMrBx0CeTObac1DGaLZrFah+Z9A2cBpsVMYo2dX4csuM55g1G0OhC9zDKMd9LjwHbYySZeAh +RpnzNN6ojdFieQpH0UY4yKIzVHESzIXnqI1RenZmXyCqOA+m8SZtjJZnFV9ugXiAvkDU8vI8F56D +NkbJMvAFomm8mh/jeKM2Rovlye+ijXAHfYGo41lzLjzn+QugZBn4AtE0Xs2PcbxRG6PF8uR30Ua4 +R/NKKXSt0qLQLVIpdM1Wv9KfNJu0stCNGtv55ZZGrlS2lR2JjRApr+VXCt0zfqV2rfxKZVv5kdgI +kfJSfrXQPeVHtWvlVyrbyo9E5peVl/KrhW7j91ULXeGK1Z0rVuYmKa91pRS6HGpU6DI/qgUbvywK +fnb1o1QLXRHqt39wocv0qbJt9LPI9HtvVha6Z5lcatfKr1S2lR+JjRApr+VXCl3MrxRtpYug+ym3 +R0uZ+RDIk8l0RjwqYzTbNdv8w6gAtA2cCt1RGaPFroGF7oznmDUbbUHKsD6GGhqCh26gdWqsUaf4 +YJQ/uOmEedTGKFkGIcIoOz1VyqM2RqvlMZ5VG8TfzsEjJgUN6ZubfUU7eQ5RxTk3nUdP2hgtjyr4 +IVaAKk67qa6etDFaLE/RK9ogqn6OHjEpqE9v3unr38lziFquHabT61Ebo2QZeA5Rqzj3xip81MZo +tTxGqWqDqAYQvcykoMc2VcuT5xB1vABMZ91gKgYoWQaeQ9RtnHtjzT5qY7RaHqNUtUFU3Rw9YlJz +b/diTI8mVMJHKxilte7L3zywWDr7FHdAh0nXs+pq6Y6yWvrtlm6ChHSHK62VT2mtTEuneXr/8yT+ +mFbOLeuvGi+dPZQvuf/j9Tm9CnP3+vJ31+dw83FvoC7/fI1FhrUmEnhOvyJnvb38bfpW1rar4/Jv +1/T+8/i/y8/4P5troq2inS2VUNoG4+uf3u+Xn/JAT/znb/nPf0u6QR3GXH5FtsIlFrv+po02NmnW +oX7FVn9fNbH5ZNPc1G7V5f+uqVY+Dhv/Tfvn/xv/1LewbYc0+vn1Ob27MxaB0v/fXu3N7tFWBFNF +GAdOLy+Vn9IXcamND822ly5jMKpJn2VJHVtpKiZNlpa86G1PryaPFWh6G8f0PdC3/Gd75Un8+w1+ +15vZhRtp5mE3ksTEk+ZaN/b4YB5K+DFudZVygtxudhnkLDKhrLyYn/HpSoWMc32Hq2rfaLz3jixJ +OPFPc5rgH0XBv3dnzevUjlsuMM7im4ocwe9Qu+SXRMEvKa/lp5RKs+EpP2UOmZzKWpmdWWRCWXkx +vzRb38lPna52MT+9B/n5ZpEJZeW1/LTPX9A45+etnKN0SHUb80ui4Oft6mnKRGImnPGzIlpiVwPB +o4FOtSotztBhVo5hVkK71QJ7MAfQDqnr0LS55jdhn7UjahETve9m1ta74CeYxI8NOBnRAzGhqmTU +xqgVGSfffJIChfAUEoBn5wGe3UR4cgjgmSTAafFU4ag/w5aWyyKVxdP7QyyeTVq4eGpbKrGHFs93 +p4snu5GXy+ZGlhrxrLnUjbp4Nj/Q4snkaHlp7EhshEh5Lb+yeIo4/+GLp+SfVkvBP4nMv3dn5eJ5 +Gt+8HjZ+ajPy0yeR+WXlpfzq4jnEtwT1JYd6/smBvLZKvp+nn9jykn4WG9/BmyX0je0fQ7T2C35W +ZPNnRWR+WXktv7L2n/Kzykp+ft8lvywyv6y8lJ/eNPrs6bBAvvIQfnFXsk3kfZe7WWTyvS9LyKt8 +BnIaXKqVGj+ttyD4kdgIkfJafqWwAnNX/w3pk/h2hBN/v3f8vQzo4M6agw/Xzw2oMBT8ju7zJ5H5 +ZeWl/GphiPOXf0+ly2X8a2sd93QIouU8RiK70nu2xBXv0nuIT0KdC7LCpitnKziWs5NyLmdZuy9n +Z+1UzrJ2X85O2rmcBUyozhu1czkLmFD1N2l7cyAmVBPOIeH5cSpcAZ6dn3Fyc8bJIYBn6jNOJGf8 +i1qO1tf7U6la7wIkqdynLYVrkxYWrqp+geKhwvX1eeHa3Cilan3D/yaJZ82lbtTCVZ19EanUovXN +4qW0qzcastgIkfJafqVwFXEWhetH8gVf53WroE+FaqOfRKbfe7Oybj0NbylFK7/c5WF+WWR+WXkp +v1q3nvGrtVx927W1MjlJbIRIeS2/Uvid8avlRn2L8R7k50tiI0TKS/nV2uSUn7dyiqIuD/PLIvPz +dvUsVdd2zM+KaPULYgGnBXFUpgWxaQ8L4qSdF8SmPSyIozYtiDOTun4Mb6DcBb9pQZy0vTkQk7rW +jCHJaVSvpvEFgQwrpDuCRwOnmM6GK65ArJuVIdbASsEV+AyaleEzmK1UXIHPZvaIPpvZSsUV+Mxm +j+gzA1YKrsBnOXtEn+VspeLg7QwT+hVrhHTqp478OpHx2ft/OHho3mVuZHN0cmVhbQplbmRvYmoK +NzggMCBvYmoKMTAwMjkKZW5kb2JqCjQgMCBvYmoKPDwvVHlwZS9QYWdlL01lZGlhQm94IFswIDAg +NTk1IDg0Ml0KL1JvdGF0ZSAwL1BhcmVudCAzIDAgUgovUmVzb3VyY2VzPDwvUHJvY1NldFsvUERG +IC9JbWFnZUMgL1RleHRdCi9FeHRHU3RhdGUgMjEgMCBSCi9YT2JqZWN0IDIyIDAgUgovRm9udCAy +MyAwIFIKPj4KL0NvbnRlbnRzIDUgMCBSCj4+CmVuZG9iagoyNCAwIG9iago8PC9UeXBlL1BhZ2Uv +TWVkaWFCb3ggWzAgMCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJjZXM8 +PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0ZSAyNyAwIFIKL1hPYmplY3Qg +MjggMCBSCi9Gb250IDI5IDAgUgo+PgovQ29udGVudHMgMjUgMCBSCj4+CmVuZG9iagozMCAwIG9i +ago8PC9UeXBlL1BhZ2UvTWVkaWFCb3ggWzAgMCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50IDMg +MCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0ZSAz +MyAwIFIKL1hPYmplY3QgMzQgMCBSCi9Gb250IDM1IDAgUgo+PgovQ29udGVudHMgMzEgMCBSCj4+ +CmVuZG9iagozNiAwIG9iago8PC9UeXBlL1BhZ2UvTWVkaWFCb3ggWzAgMCA1OTUgODQyXQovUm90 +YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAvVGV4 +dF0KL0V4dEdTdGF0ZSA0MSAwIFIKL1hPYmplY3QgNDIgMCBSCi9Gb250IDQzIDAgUgo+PgovQ29u +dGVudHMgMzcgMCBSCj4+CmVuZG9iago0NCAwIG9iago8PC9UeXBlL1BhZ2UvTWVkaWFCb3ggWzAg +MCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9Q +REYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0ZSA0NyAwIFIKL1hPYmplY3QgNDggMCBSCi9Gb250 +IDQ5IDAgUgo+PgovQ29udGVudHMgNDUgMCBSCj4+CmVuZG9iago1MCAwIG9iago8PC9UeXBlL1Bh +Z2UvTWVkaWFCb3ggWzAgMCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJj +ZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0ZSA1MyAwIFIKL1hPYmpl +Y3QgNTQgMCBSCi9Gb250IDU1IDAgUgo+PgovQ29udGVudHMgNTEgMCBSCj4+CmVuZG9iago1NiAw +IG9iago8PC9UeXBlL1BhZ2UvTWVkaWFCb3ggWzAgMCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50 +IDMgMCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0 +ZSA1OSAwIFIKL1hPYmplY3QgNjAgMCBSCi9Gb250IDYxIDAgUgo+PgovQ29udGVudHMgNTcgMCBS +Cj4+CmVuZG9iago2MiAwIG9iago8PC9UeXBlL1BhZ2UvTWVkaWFCb3ggWzAgMCA1OTUgODQyXQov +Um90YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAv +VGV4dF0KL0V4dEdTdGF0ZSA2NyAwIFIKL1hPYmplY3QgNjggMCBSCi9Gb250IDY5IDAgUgo+Pgov +Q29udGVudHMgNjMgMCBSCj4+CmVuZG9iago3MCAwIG9iago8PC9UeXBlL1BhZ2UvTWVkaWFCb3gg +WzAgMCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0 +Wy9QREYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0ZSA3MyAwIFIKL1hPYmplY3QgNzQgMCBSCi9G +b250IDc1IDAgUgo+PgovQ29udGVudHMgNzEgMCBSCj4+CmVuZG9iago3NiAwIG9iago8PC9UeXBl +L1BhZ2UvTWVkaWFCb3ggWzAgMCA1OTUgODQyXQovUm90YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNv +dXJjZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQyAvVGV4dF0KL0V4dEdTdGF0ZSA3OSAwIFIKL1hP +YmplY3QgODAgMCBSCi9Gb250IDgxIDAgUgo+PgovQ29udGVudHMgNzcgMCBSCj4+CmVuZG9iagoz +IDAgb2JqCjw8IC9UeXBlIC9QYWdlcyAvS2lkcyBbCjQgMCBSCjI0IDAgUgozMCAwIFIKMzYgMCBS +CjQ0IDAgUgo1MCAwIFIKNTYgMCBSCjYyIDAgUgo3MCAwIFIKNzYgMCBSCl0gL0NvdW50IDEwCi9S +b3RhdGUgMD4+CmVuZG9iagoxIDAgb2JqCjw8L1R5cGUgL0NhdGFsb2cgL1BhZ2VzIDMgMCBSCi9N +ZXRhZGF0YSA5NSAwIFIKPj4KZW5kb2JqCjcgMCBvYmoKPDwvVHlwZS9FeHRHU3RhdGUKL09QTSAx +Pj5lbmRvYmoKMjEgMCBvYmoKPDwvUjcKNyAwIFI+PgplbmRvYmoKMjIgMCBvYmoKPDwvUjE0CjE0 +IDAgUj4+CmVuZG9iagoxNCAwIG9iago8PC9TdWJ0eXBlL0ltYWdlCi9Db2xvclNwYWNlL0Rldmlj +ZVJHQgovV2lkdGggMjA4Ci9IZWlnaHQgODcKL0JpdHNQZXJDb21wb25lbnQgOAovRmlsdGVyL0Zs +YXRlRGVjb2RlCi9EZWNvZGVQYXJtczw8L1ByZWRpY3RvciAxNQovQ29sdW1ucyAyMDgKL0NvbG9y +cyAzPj4vTGVuZ3RoIDc4Mjk+PnN0cmVhbQp4nO1dCXwU1f2fe2bPbK7NSe6EEO77RkAQBAGlUCse +tVZtVQiiVsG/VCtabFWq+NdqD4uttvZfW6213nIplxByEUISjpxkN9lce8zuzvl/MxtoDJB9S2Y3 ++Ol+1Y9kyLx58953fu93vN/vobIsI1FEESmgUcJFEUkohLvvqVfqGs66PF4cwyLzVAkAQR7+wXdW +LpwRuFLt9G49bvuqy8fIYmT60A/gu5MQOZEmk2hCh2PJeirXSGXoqHwTk2dmQh2XDpa7573Dxx0e +BtX+e+ZkJMVA/WRO4ZycJArXYMp4STrQ4Hh6Z1Wrh6fC0GEeQcB4LitKi2FIhXAr1m6pOtXA+nlE +ljR/2EWBohiCYVvuvemOldcErpR1sfcfbdznxRHWFZk+XKJn4F9M+R+GIoKQqyevSjLNSjSOidFl +GmkLSUA2Y3f7lu3YU8eislf710EJkkGkW8ZnbphdmGrSDb5BB8u9dqj25f11XpSUef/gG+wHlKQS +SOTmCdmxtEq469dtqTrZ6PFxkSbcfd8g3IbSpq9YdKgJh6qkC/wBiGKRxDAKRfJN9K3ZCStSLel6 +Eg/81YAAhFv+xt5ajyx73eHpJJZtYV69YfLUYfGDb++YrefRT8q+qndIOI6I2q8wgHCJFLpmXFYs +Q5wnXEPkCffU2pt/cMPCwJUrhXD9AHQMnEAwHBF4K4lOjtXdnWddkhIT9D6FcDv21rLhIRwAQREi +98LyiTeNycSx4B/AwHinsrH4X0dZCUNEXpPe9YNCOBJdMz4zTkcphFt6zxOVtWdEBIss4fDHf7Tq +rlWLA1eOdnrWHW36WtIhniuJcApUnQbQjqIQv6/IQN6YarojJyGZIQe4x+byLX59V6PIhGNJVftD +IqLw3aLkh2YX5ieYBtOSzeV94aua18palO+K55DBsvciQEnaJPpunZQdx6iEW//Ma6caWlk/hyIR +slgl5Tno+luWXX/19MCVEz3e52rsh1wCEQYdQiuICOqR0RwGXVtgXZRsYS6tsHew/uL3S046OSI8 +MkMGvJDlkckxd03OnTK4VbWitesPR04fauoE4hwNj8QRUSyRIZaOSDPT6pK650hlj4vlBQGLlJUq +AkVBRiYU5eYMSwlc6fLzJV1sM8vRQI24UiGrPiReAsYscVWS2Uhccrj8grTntL3N42MIWDsjtJ4o +/6B6ChubEpseox9MUw1d7kpbj1cAVJPRcMg3BBEkyUARWbEGMLkK4SRZHhJvHIYqCPxZ7QEqR0rE +Dgay6kMhsCC2gxSBQUXVMRxcG5JKgDBR7TzOT3XU8RtFRBElXBQRhUK4/WXVTreH40Vs0AY2JCRV +jo8bkZOZag1c6ebFim5vs8d3JetwF0KQZDOJjYjRZRrovmPnE8T9DY52t5eB9hVfHnhJshp0RVZz +vJ4OdXFlOaHM1t3c7aGJ8I45GCWgw2VaDBSOKoS758mXTzaedbrZiIW2RCW2JW+8a/V3Fs4MXKl2 +ep+usu3tYHVIhFwzmoCX5QQdfUOaeX1Bsh7/z4Q7PP4fv3e4ss3V92I44JfkgjjDnZPzFhekEKE8 +C3zyJc1dL+w7cbS1hwlzJ3klFkcvL0qzMOciDcfqhiK0dZFIA4awzsj0QRsAqUIxk3TIjuk5BUbm +vIwJb6ShL3DCiKM3j8t4YsFoHRmCoAIy+KX9db/5+qSDk2WeC18HkfOhrfHZsb2xVIVw9V5OGMJY +ammnZ0Np8z4fdmVFGmDA6JMl38/Hpq9MjzWcW5v6xFLDTDhgXlK6ifH0H2+cnmoOIa7a5eVuf+fg +l009kigE/KLhw7lYalYv4W4ofqrqZIPb6x/a0NYDpU1fepBvH+EoWi/x38uI2zwyNV1PBa4Bwq14 +Y2+NWwo74cBgMoY0Wn5+6fh5OUnUpV2DfSFK8v6G9rXvH2n0orLPE/YekpSVxtaMP0e4JT9+vLK2 +XsLwCBPu8btX37VqUeDK0U52bUnDYdnwLVtSETXKxPtnWahXJmYC6yFwzebyLfr9riZZJ0fg+yEp +kvPcMTHngdmFViMDc0cH639pf+0rB+t4yoiEP7QDCGcUvbdOzIkLEO7ux7fX1Ld4fP6IhbYU6xhB +H7lj5epFswM/H+/xbqlqPeAScM4XqT5oAxnDcUmaGq//2ei0XFPvfDtY/53vHKp18lgEInUYhsnS +5GHxm+ePyoo1wNzR7GS37T2x+7TdL2Fo+DcggiFK1BHXj0yPCWxP+mDP144uJycIwZznmgFYqYDb +syYUjczLDFxp9/FfOtynXX5aix2FkQR4ExxB0/XEVdaYWKpXh/Py4r+qW1pd3nB7HALgBNFAEcsK +06wmKAnX5fV/Ve846/SCtTUCvjBBlEw0Odxq0hFqLNXn54YkukWRJHluPoDa6pckQZIjxXmNgaMo +jaHnv1gwlD4ejLM86MgTFGQ1tqqnCJi9eojqE/ErvQt3v/4D0C0CV2OZ0UhDFJFElHBRRBTBCSeI +YpfT7fPzkixduKcAiHAgn30+zu31iaIIVhXwI45hcRZTSkIsQ1Ma9vWsl29hOU6S1J0HQdYOsMSA +nphJPE1PxVMhxJdcgljv5tyCBN4XQ+G8DLJEoGimkU6iSUiNCKxnjd0eB8uB52iiOqt7WOQ4HZVq +1gGF6VK/5hNEoLrZ3YplppXKDhZnI01kxRqV7W7B2gxOuC6X+4Pdh2rOtACd5MIugiuCJHZ0Oe2d +3X5OAFQTBBHwbN7UMd9dPDs9KWFQr/JN/KWh840zjg5OgNmTI6sRldFm+vvZCfOTzPBPOdbDbqtp +A1azCL4cuCnhZMSIofcVWJenWnRwnjDAtFcPnfqk7izLS4QWarsSnkaQ/Hjj7ZOyZ2dZL/VrVfbu +P5XWA4sBjOHg96YH4BWk/DjD+lnDJ6TGBiVxcMKdbet84pW3dn9dATT6Cx11AS0QyDZFB1WbQjEM +jOB3Fs66b811uef2V2qCF2vsv6i2tQsSohi5wTQB8OYkNVaPbRyRsiojDv4phzrcG442He70IPAZ +JRTNiNzPxwy7IyfBAEc4Dyc89mnFX8obfBKiUd4KEPoooPvGuSPWzxx+qV96u7zh2b0nTnWxylRq +pE2htD7PhP/i2nFzc5KCcjg44Zptjk2/2rHz6wpkAM9wbyu9hEMkcfWiOWvXXJeXkRp6/y+JX52w +bT1u6wLLHDThRlHyo0Upq0Mh3MEO9/qSxqNOf0iEI/zs1jHD7sxJNJKwhHv0k4q3yuoFjNAsUQp8 +/RS9ZnjCM0vGmy6mRfh58bHPKv5Q0SrwnFZsQ1TCZevlZ5cooQ4NCNdi73hs+x+/OFh2UQl3kRb/ +CyUcrdMJ/jemZV+XaoFU4sIg4RDlnWlmqlW3+erRMzIT+ukdYKKr25ybPinfa/PKrBvRzsmvvYR7 +ZNvruw8fG0jC9W0Rw2RRWHn1jPW3XZ+XoSXhnj9he6qq1a1kAcMSbjjq2zwy9cbMENJMDjjca0sa +K1gJlnBgiGnGxLo+mZs/Od4I+RRAuIc/KnuzrB6jdRoSDsyRHhPvGJ/5s4Wj+6lTvCi9erBu+/5a +h0QhAqcp4QxphH/b0glX5yVrQLjW9s6nX/vrniOVoMdQsS8UJXFs+dxpd65alJWWBN3t4HjtZPuL +tXYHL0HpH0C5xMnRBvz+guTl6Rb4p5R0eh4tby7tZpUPTApOBRnBMBwrMpIvT8osgt6vwfLC0zur +/l7V7BVkbXOlJIKan2F5afnEfrYqsE83fVz2j2PNqNZBc5mg82LIJxaMnpmZqAHhetyezw+WnW6y +ASsVxq4BxgNF4EV5GdPGFMbFDCplsh8OODx7250uXuF9UDsVvJcgIxl6eo7VODImhH07zSz34dme +Zi8HNAiY5RFoGgyOFZqZBUmmuEv7I/qBE6XP62yV9h4fDzWq8PCJUmaMbmlhWoqJ6TtKvCQDi+FE +mzOkbXMw8ItSqolZVJCSHWcM+ibBCSdKkpv1KnEa1QEW9PGgQQzDaIrUM7S2W4hZUfKo4SLI5QC8 +GdCojCROhzKjYGJcgsgrcR+oB4GnAMbocUyHo/CeLdCu28/7BUlUMqa0hCTLBIYZaYL5ZhhXVvfA +cYKkeewUPBGIGCNFwFTWiUYaoogoooSLIqKACW1Jnd1O1ueHXlKVmgEGPWMxGkhNc5a6ebHLL1w5 +O0rAasjgeDyNG0PfgwSWoQ6Wc3OKpqJ5ErKSlY8geopIMNAkhoER6/ZyTiU4GZaEZ1GWdITyLBjt +MDjhOnpcb7z3eVn1aU4QYHQyURRpipo5YcSyuVNTEkNwgAXFe83d7zR1dqqhrSFN0VfUOzB5YAJn +Wo1rMuML4Hah9YWXF/9UWr/7tJ0FRoPWH5CkqNFobpzxzsm5BQmm5m727YqGwy2dwEAh4LRqWDVZ +BTBTcmMNP5ycMzrZok1oa/NLf9x5sDwkt8jKBTPvXXNdTnoydLeDY3uN/dkTtjZeRAPVFoYMMnhH +CUGMGPaTouR1+UkDFBm5FDyc8NPPKgEPNHeLIKrdhhKkAUe2LR2/anTGwUbHuvdLznSzkmJwaT9u +EkEPt1BbF429SivH76MvvvH5gbKQHL+rF81ed/MyrUNb9q3Vti4ELrQVVhAE6MNNKcaNI1PgfW99 +AQi36ePyt8rqRaXwFqzjF8VxdRsMxO8TJCqJG6bl3DYp99Pa1kc+KpMJCpGE4HxTaijJYAaV6YaT +dCitz9LJzy39Lw9thQnguTQDZmF6DLl1bPrMBNjQQj+EHtpS5j5OT4kS0qNkEAf1eyvV/ubmJC0q +SD5m73mrvFFpIThTUQJHE/TKPn+7yy8oO4mhCKdxaOvh51/fU1IVkoS7Yf609bden5+ppYR7rtr2 +1PFWD6UbSsIp8S5hLIM+XJSyLM2iu9wMDLeff/ijsj+XN6KMDthlwW9Qwx7zMiwuP3+kg1OoIw04 +F4qaK9OyUGg1AzWxrtsfoOCAt2DgrnRGLrTGNDu9JxwehATSF2LGGUMa7tMytLXl1b/sOVwpiFAS +DshkEkeXz5t+16pF2ZrqcL+ua3uhxu7olXAaNgwNYOMxujxSfnB40nVpsbpBVEgAJNiy89g7lU0+ +sG7ASDicAETfMLOww+t/s/KsJECWSUCB5QgUeQ8HURdRLUt6bV7iCGvM5ydtVfZuURGKEISj9Dkm +/MmFo2dlWTUgHOvjDlfWtLR1SHD+CEnxvCOAaiNzM8xGqKw1SBzrYcu7vV5RY9c8PJSgAo5l6Ymp +cUZ96IZCXwAL7EhL56kOlyBDOSpkVWRNTo8DwwuWSD/4+uXg8T0wZcpHgkCl8qiZOGhRkjmWJmo7 +XB0eTj5XW3tggFeIY8hpGQnJRlqDHb9KUFIEgLWkZHVscKDJKTlEWnJDUMOjQ+qpRoFFyWiU+cdL +kijKsB4I9dfAiBIYxocwG2qtTCjaBH4ZoUmlSGUgjQ9yGVGSCnCMxKASDqORhigiiijhoogoghMO +CEzW6xMUkwGBCYyocRWUogiaIrXdLeITJa+oqiVDF9sCw6UjMP2gywOAUffygl9JBIFa8AKzpKdw +Wk0n9gkSuF2JKGiS8aWqg0AB0lMEgaFAv/SCZTtQdhlKa5fBXXqSIDXZLdLt8vz9s6+qaht5UcCx +4OoLUDAokpw4Km/h9HGJcSHsfAyKT23OD892d/dmbQ0B58C3BEzkKfH623MTjYPjnI8X/3G8+WCT +w8dLMKGtwC6mpYWpi/NTSAIDBsdfyxs7WT9NYMighwI0TmHoyCTLDSPTk01Mbbvrb5WNzUohCAlG +ZPgEMcOiv2lsZkGCSaOsrZff3HmoApAezp5CKAK//urp99y4JEdTx+//1rY9X2Nr40QUziEZBqAS +hqXS+O058WvzkizU5VsPHk544otjf4UObcmo4gR9cNbwe6fnm2myvLX7B+8cbHBxuOLLHfRQYKSJ +QG6bmHXP1HyrkdnX4Hjsk/Kqtp6AaRz0bgmnCiz0zxeNnZOthVtEydp6YccXB8uvhNDWz4+3doNu +iEPn+FUOQ8KtCL82P/mHOfHWAc+jGQBKaOuT8rdK60UCLrSFk4gsbpiaWzyzIFZH2d2+O/9+6KvG +LlnNkbu8PvRCRjDGYJS8L6+YdE1BMo3je+vbf/Lv0ppOj/KyMH442pDFSNHQVtiAKQ7SeBz5n6Lk +7+ckmC/LSxJyaAsnwOA/NGv42hkFFoYEt//m65O/PlDXxqPIIAucoShG0qPimT9+d3qg2teX9e0b +PyqrsvdAE07r0NbGX+3YNXBeat8WVQkHCFd8i8YSbtsJ+9NVZ51KEHqog/eqZpNNIY+OSF49LA4y ++bkvAGM2flz+Zmm9TNHwhLt/Svb9s4ZbVLFacrZzw7+OVjpl2c+G/gL/AYqTtOi/fVL2prkjY9SW +95xpe+jfpXXdPnjCZVDC80vHz8/VIrQFJNzml/4UqoRbuWBmOCTcL0/Y2vmhlnCI6gAGggEnro5n +Hi5MmZsUcq5QQMK9XRGahHtwZq+EQ5QCC+Lafx75R7VNvf3yNzihlD7fRDyxcNTC/JRA0Qkg4TZ9 +XF5l7w5FwhHPLB6rjYRzs76dB8tOt9jVvanBIakO8RHZw6aMGR5rvszNFBfFoQ73PofHI0phOLQ4 +VCg+IgFFLTgyJ9E8IS7k0644Udp12n7M1i2oJz4Ff54ajJ+RmTA5PZ45J1A/P2krO9s9yDQcAcWy +Y5hrC1Isut7KQ43d7Bcnbe0evwxnAIsolsAQC/OTMy2GoAY3lB/O5+d4mB0NKlSnDkKRBEWQuKbl +LP2S5BPV7g494XoBJC2NY4bQX1OpAylKvOqHgwdNYMr5aOcmFbB28HUFgRzRU99I8QJLmU/1w0G2 +AN6BxDHQAkxVnmikIYqIIkq4KCIKKMIp8aQQeRnYOqBtDEoKHHEZSk8ChyaGmvoLFqnQljp1P0ao +uTCBcyOhE1aUxjH0IlUE+yzLlyM7QIP92pTlwFCH0DfQAAY328Hnz+nxfrqv5GRDKyfwYJkO2qIo +iiRBjMrPnDF+hLalHvY53HvaXE5OgNsIoyQ4Gkh8eqJxQZIZngs9vLi3zVXSybKiBFMKSVYPoE1i +qFuy4pKg/cBA/fq0zlZu6/JxIgGhAoJ3AbS4Ksc6IyOBIfvqW9KXZ9o/P2kHPYVp5zxEUUn6zEsw +zslKzIz9hm13ptP9cW1rm8cPfgdGC/fyYppZt2R4ak68FqUeAjt+dx+q4EQR5oWAEKIIfPn8qXev +vlbzHb+/qrG387ChLQnFYnD0rjzro0Up8EKumeVeqmt784zDLaM4lBMfFTEskURfnJC5KMVMwMk5 +lhOf3HnsnWONLC9hMOEjRbrJ988suHtKXkwfWgPx9rfKxsc+rVDaUZ4MJ+TA+GEYGMLbxmcUzyhI +NX/Dyt7f4Hj8s4rqdidkaItHicJYZss1Y7TZ8XsZWVuIJK66ZlZ4srZauxAc1g+HEzrRv7Yg+anR +afCEq3dzz9W0vn66g6cYBPLUM4pGve7No9LuzbPG01C534GsrT+XN8AWJFT9cA9Mzyue2euHO49D +TR0bPyottTkR0BR8mAtXfvmXi0bdOSm334LRG9rqgA9thSFr6/MDpcr+JDjC4Siy6prZ4XD8PnO8 +1aG4OWEJZ0SE+wqSnwyFcA0ebluN7fVTDp9yphEc4UiSEPk7suMfLEzJMdIwdwQcv38uq/fL6GWE +tvr+TZvb9+qhupf21/IYdIfVSElGjG77solzc/oXBP6yvv2RD0uPtznhCZdrxH65ZLw2jl9AuE0v +7ACEC0nChank6jPV9s5AZgeM94kgdAKnSLgxoRHuuRO2359q52kG4WAJh/h9N2XEbSxKKYIrDXau +5OoZAYMM3gckXG7xzOH9CAcU/A9rzt7z3hE3Qsoc3ElLBIEL3I1jMx+aXZgT1985v/dM+8MflSpZ +W9CE07LkqhJL3faHXYcrQ4ulLphZfOsKzStgPl3V6iJpeAlH+th1BUlbx6aHsKR6uF9Wt/7utEPW +G2EFBkEAal5nNTw+KnVcLFTUARDuETWWioKFG5pwxZMz7581PFbX/zCC6raeH797pMLBqscYQIS5 +KIbmPNtXTLy+KP3CGlt7zrQ/+O+jp7r9sIRj9Okkv23phPm5WhCu2+l5f9fB6tNNSmgLZm8qghIY +OmFE3lVTRifGxgS/ARq77M6PWp0uJbQFVx8ORXUYMs9qXpoSA3+iVIdf+MLu3Nfu5lAMhVOJlLiq +LBeamevSLNkGqCXVL0j/PN50pLmTUz09MI8AI3tNfhJYtvQX1Ixx+vgPTpwtO9vJKVMUnCLAnDIT +2J1TczMtF0mrq3O43jvefNbphd0Ph+LJenLl6GH5ccag4wxVkNDl8fo4TpZkFMZNICkJjnqa1uto +QtMD7FlRcvIi/AFWSmlEFDGRuAGHOdmhF6IsewTJIwT2skPdEtiiDZ4VQ+KQqdFg1F0cr2wTl0LY +Ym5iSL2aZ3phBwCDQYMCaA2CImBOSRyPVzLsL/JsDoyzXz0pDG4EAjVPzQxJYagGaYJRRKEhooSL +IqKIEi6KiEIh3K//+mFre6efEwazjy+kh4L/rHExS+ZMHpEzLHCpmeX+1tRVB4z6b9uJ0AoomuC5 +9QXW8ydCu/zCywdq2/yyrNWJ0MBglOWFuUnzcpMGKDT5dnnDgRYnJl2qkgiK4mSqAb92eEpRkuVS +2lZdh+vdY82tLm+gIs7g+44SVDyF3jAy3aKjFMJd/cNHT5xpAVcjdOa9avrEG+lnNvzg2jmTAteO +dHp+dLihgklAPN+2M++V3X801dn22byCGeeqd4HZmvfaF21MnGZn3itJNNK9o60PXTUi9tIR202f +lL1a2qqWr5MvFuZCMZ1hsoF7fun4AQi387S9+J8lLTwOeVJFUKC0weLv3L5sYrrFoBDu+nVbjtU1 +sH7IgjyDf75CuNxhSY/fe/OC6eMC18q62A2lTV+xKKLVDEUMOIEI/KxE0yuTMkeYeyWc3e1b/sbe +Wo8se92aPUWWHpxRsO6C0FZfvF/d8uye6koHq9YevIBwKEqSZPHUnM3zRw7wKCXS8FEZfKQhKJTY +lx79xeKxqTF6hXA3FD9VdbLB7fVHknB5GSk/vWdNX8I9UNr0pQf59hGOog0i98PcpAcLrannXLKA +cCve2FvjlrQl3EVDW31xusv9i13H/6/aLot8f64oyeNYYYLx4TmFK0cNG+BRoWZtBYUSijBgz5wn +3Iq1WwDhWO6CLoYJmOKbzEkHEm7NwhnjA9cA4e4/2rjPi3/7CKc3pMv+7RMzFiebyXN56oBwy3bs +qWMRjSXczIJ1AxJOOVDrUN3mL6qVH/qthmp244r8xE1zRxZaBzpAdu+ZNiDhqttdGhIuU4cACZcW +WFKHRIdLMDFb77/9Pzpch+dHRxoq6HiE/VbpcIAHXnalVffChGEpfXgAdLj5v9lpp2Jlr1Y6HKHq +cEkD63AA/z5xdsMHR9slSh3nPhOqRiY3TRlWPKOAGbC+/c5T9uL3AzqcVoQzWHyd25cDHU6VcL// ++6c2R6ef16JoADQSLObFsyYWZKUFfmxhufdauk9xwErVyKyLDHDChIhzk8xXWc19nfYuP/+7r0+1 +cYi2Vur87MTZ2daBj0NoUHOuah2u/jVWlR/F743NGpcSpODLqU73B9UtrS6fdlYqGUehy0ekmRky +6oeLIqKIEi6KiCJKuCgiiijhoogoFMK998UBR5eTEyJqNMSZjdPHjchM7d3f3OYXdtmdzcBoEOD2 +PA4JZFnCMJ8gpevIpWkW66XTFzyc8G6VutlNq9cBKj8iT0mPH5dqgalq7eGFj2taG7s9SkVBnDDi +yPzcpEBxpKBo7mH3nGnr8Pi1MhoQnLRQ6Jxsq5FWjYbFd/+0su4MgkfULZISb3qq+DZgqAaulXR6 +7itpLEFNV65bBEw5RSOSGOd3r86Ie2h4cpah/87b87C5fdf8dmczatDWD7d2fPoDswtjdcGTETtY +/0Mflr5bbUNpHUpQSQi7Y/W0qcPiYR61+0zbhvdL6llJQz+cVWa3LR3fG9pavvbJY3UNPl6MJOGy +UhN+dt8t5x2/pYrjt2m/n7jCHL9qMrDiMlXyfClJHGUgb82KuzErPv5iGyHPw+72Lf3D7lM+XFvC +XTRr66LwC+K7VS1bd1c1+nGZ883LtPz2O9MS9Jf8QvpCzdo6WtPBaki4YbT07JJxqeZoaOuiOM+k +3j8oK0scha3JjL81M67AzAQ9IHWoQlvnAaa1vou9759HDnZJsaL77il5xTMKIE+7D3toK0q4bwBV +RRqq/kuSiMBnk8jC5Jirk00TY/WZcCkLQ044RC2CVPyvkrfrukeZkGeuHT9tWDxkXkeUcBEEijGo +nMxQZgqzkESGiclgiOFmZlq8ETLhNIArgXAArx859eKBUxNTzNuXTTLCZWgjUcJFFDgRj8lT4o1Z +RqrAxCxINhde1nGoVwjh9te3v7i/Ji/B/PQ1Y+AfFXbCDb7FKKKAxP8Dyx354AplbmRzdHJlYW0K +ZW5kb2JqCjIzIDAgb2JqCjw8L1IxNQoxNSAwIFIvUjE3CjE3IDAgUi9SMTkKMTkgMCBSL1I4Cjgg +MCBSL1IxMAoxMCAwIFIvUjEyCjEyIDAgUj4+CmVuZG9iagoyNyAwIG9iago8PC9SNwo3IDAgUj4+ +CmVuZG9iagoyOCAwIG9iago8PC9SMTQKMTQgMCBSPj4KZW5kb2JqCjI5IDAgb2JqCjw8L1IxNQox +NSAwIFIvUjE3CjE3IDAgUi9SMTkKMTkgMCBSL1I4CjggMCBSL1IxMAoxMCAwIFIvUjEyCjEyIDAg +Uj4+CmVuZG9iagozMyAwIG9iago8PC9SNwo3IDAgUj4+CmVuZG9iagozNCAwIG9iago8PC9SMTQK +MTQgMCBSPj4KZW5kb2JqCjM1IDAgb2JqCjw8L1IxNQoxNSAwIFIvUjgKOCAwIFIvUjEwCjEwIDAg +Ui9SMTIKMTIgMCBSPj4KZW5kb2JqCjQxIDAgb2JqCjw8L1I3CjcgMCBSPj4KZW5kb2JqCjQyIDAg +b2JqCjw8L1IxNAoxNCAwIFI+PgplbmRvYmoKNDMgMCBvYmoKPDwvUjM5CjM5IDAgUi9SMTUKMTUg +MCBSL1I4CjggMCBSL1IxMAoxMCAwIFIvUjEyCjEyIDAgUj4+CmVuZG9iago0NyAwIG9iago8PC9S +Nwo3IDAgUj4+CmVuZG9iago0OCAwIG9iago8PC9SMTQKMTQgMCBSPj4KZW5kb2JqCjQ5IDAgb2Jq +Cjw8L1IzOQozOSAwIFIvUjE1CjE1IDAgUi9SMTkKMTkgMCBSL1I4CjggMCBSL1IxMAoxMCAwIFIv +UjEyCjEyIDAgUj4+CmVuZG9iago1MyAwIG9iago8PC9SNwo3IDAgUj4+CmVuZG9iago1NCAwIG9i +ago8PC9SMTQKMTQgMCBSPj4KZW5kb2JqCjU1IDAgb2JqCjw8L1IxNwoxNyAwIFIvUjgKOCAwIFIv +UjEwCjEwIDAgUi9SMTIKMTIgMCBSPj4KZW5kb2JqCjU5IDAgb2JqCjw8L1I3CjcgMCBSPj4KZW5k +b2JqCjYwIDAgb2JqCjw8L1IxNAoxNCAwIFI+PgplbmRvYmoKNjEgMCBvYmoKPDwvUjE1CjE1IDAg +Ui9SMTcKMTcgMCBSL1IxOQoxOSAwIFIvUjgKOCAwIFIvUjEwCjEwIDAgUi9SMTIKMTIgMCBSPj4K +ZW5kb2JqCjY3IDAgb2JqCjw8L1I3CjcgMCBSPj4KZW5kb2JqCjY4IDAgb2JqCjw8L1IxNAoxNCAw +IFI+PgplbmRvYmoKNjkgMCBvYmoKPDwvUjY1CjY1IDAgUi9SOAo4IDAgUi9SMTAKMTAgMCBSL1Ix +MgoxMiAwIFI+PgplbmRvYmoKNzMgMCBvYmoKPDwvUjcKNyAwIFI+PgplbmRvYmoKNzQgMCBvYmoK +PDwvUjE0CjE0IDAgUj4+CmVuZG9iago3NSAwIG9iago8PC9SMzkKMzkgMCBSL1I4CjggMCBSL1Ix +MAoxMCAwIFIvUjEyCjEyIDAgUj4+CmVuZG9iago3OSAwIG9iago8PC9SNwo3IDAgUj4+CmVuZG9i +ago4MCAwIG9iago8PC9SMTQKMTQgMCBSPj4KZW5kb2JqCjgxIDAgb2JqCjw8L1IxNQoxNSAwIFIv +UjY1CjY1IDAgUi9SOAo4IDAgUi9SMTAKMTAgMCBSL1IxMgoxMiAwIFI+PgplbmRvYmoKMzkgMCBv +YmoKPDwvQmFzZUZvbnQvV0xCVUVKK1RpbWVzLVJvbWFuL0ZvbnREZXNjcmlwdG9yIDQwIDAgUi9U +eXBlL0ZvbnQKL0ZpcnN0Q2hhciAzMi9MYXN0Q2hhciAxMjAvV2lkdGhzWwoyNTAgMCAwIDAgMCAw +IDAgMCAwIDMzMyAwIDAgMCAwIDAgMAowIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwCjAg +MCA2NjcgNjY3IDAgNjExIDAgMCAwIDAgMCAwIDAgMCAwIDcyMgo1NTYgMCAwIDU1NiAwIDAgMCAw +IDAgMCAwIDAgMCAwIDAgMAowIDQ0NCAwIDQ0NCA1MDAgNDQ0IDMzMyAwIDUwMCAyNzggMCAwIDI3 +OCAwIDUwMCA1MDAKMCAwIDMzMyAzODkgMjc4IDUwMCA1MDAgMCA1MDBdCi9FbmNvZGluZy9XaW5B +bnNpRW5jb2RpbmcvU3VidHlwZS9UeXBlMT4+CmVuZG9iago5MCAwIG9iago8PC9GaWx0ZXIvRmxh +dGVEZWNvZGUvTGVuZ3RoIDQxOT4+c3RyZWFtCnicXZMxbuNADEV7nUI3MElJozUQTJM0KXYRZHMB +eTQKVEQWFKfY2+/n5zrFFt/w84g038zo9Pj89Lytt/b0clzL73prl3Wbj/p5/TpKbS/1fd0atXZe +y+0f8bN8THtzevw57W9/9trigboE/5o+6un1LPxFo6Zc5/q5T6Ue0/ZemweR/LAsuanb/N9S30XF +Zbk/qjki/TkDLUekN8cuR6SfHfscERPHIUdkIKYckbQ4jjki4+j4I0ckDY7nHJGRfzTliAyd4yVH +ZORUBV9nIldrjkjiVEtmTNRXFfIeYHGEnFJwTI6Q0xD0MVDBoJX/kUJOaZR8ZoWNhlF1hI3SyNgZ +Nkqjka1go2Hku6Gw0TDqHWGjha3UETZKo8RWsNEw4pCw8WBINzLaEL3WYGM0SlyFjYWRtzLYGI26 +yRFGxiPrfQyDnIUgEXJGwd6PzCBnFBxc3yBnFDTfZ4OcUTBdHCFnFDTWQtB4ZIMfKHaIwRi+OWjA +4GHWwtUo2CVe0/t99BvrV/9+09vydRx1u/H94P33e79u9fsV2q+7V7VI8xcg89tNCmVuZHN0cmVh +bQplbmRvYmoKMTUgMCBvYmoKPDwvQmFzZUZvbnQvVktKTkdUK1ZlcmRhbmEsQm9sZC9Gb250RGVz +Y3JpcHRvciAxNiAwIFIvVG9Vbmljb2RlIDkwIDAgUi9UeXBlL0ZvbnQKL0ZpcnN0Q2hhciAxL0xh +c3RDaGFyIDQ3L1dpZHRoc1sgNTQ2IDc2MiA5NDggMzQyIDczMyA2ODcgOTc5IDY2NCA0OTcgNzEw +IDY1MSA1OTMgNDU2IDEwNTggNzExCjU4NyA2NTAgNjgzIDM0MiA2OTkgNzEyIDcxMiAzNjEgNzEy +IDY5OSA2ODIgNjY4IDY5OSAzNDIgNDIyIDcyNAo3NzYgNTg4IDYzNyA0MDIgODMwIDY5OSA4NTAg +MTEyOCA0ODAgNjcxIDY4OSA3ODIgNzExIDg2NyA3MTEgNzExXQovU3VidHlwZS9UcnVlVHlwZT4+ +CmVuZG9iago2NSAwIG9iago8PC9CYXNlRm9udC9HSlZTVkwrSGVsdmV0aWNhLUJvbGQvRm9udERl +c2NyaXB0b3IgNjYgMCBSL1R5cGUvRm9udAovRmlyc3RDaGFyIDMyL0xhc3RDaGFyIDEyMS9XaWR0 +aHNbCjI3OCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMjc4IDAgMCAyNzgKNTU2IDAgMCAwIDU1NiAw +IDAgMCAwIDAgMCAwIDAgMCAwIDAKMCA3MjIgNzIyIDAgMCAwIDAgMCAwIDI3OCAwIDAgMCA4MzMg +MCAwCjAgMCAwIDY2NyAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAowIDAgMCAwIDAgNTU2IDAgMCAw +IDI3OCAwIDAgMCA4ODkgMCAwCjAgMCAzODkgNTU2IDMzMyAwIDAgMCAwIDU1Nl0KL0VuY29kaW5n +L1dpbkFuc2lFbmNvZGluZy9TdWJ0eXBlL1R5cGUxPj4KZW5kb2JqCjE3IDAgb2JqCjw8L0Jhc2VG +b250L1NLVkxKSCtIZWx2ZXRpY2EvRm9udERlc2NyaXB0b3IgMTggMCBSL1R5cGUvRm9udAovRmly +c3RDaGFyIDMyL0xhc3RDaGFyIDEyMS9XaWR0aHNbCjI3OCAwIDAgMCAwIDg4OSAwIDAgMCAwIDAg +MCAwIDAgMjc4IDAKMCAwIDAgMCAwIDU1NiAwIDAgMCAwIDAgMCAwIDAgMCAwCjAgNjY3IDAgMCAw +IDAgNjExIDAgMCAwIDAgMCAwIDAgMCAwCjY2NyAwIDAgMCA2MTEgMCA2NjcgMCAwIDAgMCAwIDAg +MCAwIDAKMCA1NTYgMCA1MDAgNTU2IDU1NiAwIDU1NiA1NTYgMjIyIDAgMCAyMjIgODMzIDU1NiA1 +NTYKNTU2IDAgMzMzIDUwMCAyNzggNTU2IDAgNzIyIDUwMCA1MDBdCi9FbmNvZGluZy9XaW5BbnNp +RW5jb2RpbmcvU3VidHlwZS9UeXBlMT4+CmVuZG9iagoxOSAwIG9iago8PC9CYXNlRm9udC9EUFhZ +TkorU3ltYm9sL0ZvbnREZXNjcmlwdG9yIDIwIDAgUi9UeXBlL0ZvbnQKL0ZpcnN0Q2hhciAxNDkv +TGFzdENoYXIgMTgzL1dpZHRoc1sgMjUwIDAgMCAwIDAgMCAwIDAgMCAwIDAKMCAwIDAgMCAwIDAg +MCAwIDAgMCAwIDAgMCAwIDAgMAowIDAgMCAwIDAgMCAwIDQ2MF0KL0VuY29kaW5nIDkxIDAgUi9T +dWJ0eXBlL1R5cGUxPj4KZW5kb2JqCjkxIDAgb2JqCjw8L1R5cGUvRW5jb2RpbmcvQmFzZUVuY29k +aW5nL1dpbkFuc2lFbmNvZGluZy9EaWZmZXJlbmNlc1sKMTQ5Ly5ub3RkZWYKMTgzL2J1bGxldF0+ +PgplbmRvYmoKOTIgMCBvYmoKPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCAzMDg+PnN0cmVh +bQp4nF2STW6DMBBG95zCN2DGBpJI0WzSTRatqrYXIGaIWMQgQha9feen6aKLD/HAtubpc306v5zL +tIX6fZ3zJ29hnMqw8n1+rJnDha9TqTCGYcrbL9kz3/qlqk+v/fL1vXCQBTw6v/U3rj8O/gV9T54H +vi995rUvV66OAHQcR6q4DP9+xdZ3XMbnUiQPRCDBSB5oBsVEHuhQsSEP7KJiSx7okmJHHuj2ijvy +QDLckwdiVjyQB5Id1cvrxdDGyOSBtFMcyAPpoMjkgWhDjuSB1AqiyGtEQWdGkUMTTDokihy6oC0W +OTTB1CiKHJpgo1OhyKEJNvZX5NAEU6cocmiCjZ0scmiCraHIoQm2OjOKoEZwb8U8G9COtOxntyE/ +1pXLZjfCGtemp8J/l2aZF90VJNUPV0+e6wplbmRzdHJlYW0KZW5kb2JqCjggMCBvYmoKPDwvQmFz +ZUZvbnQvRURXTEtSK1ZlcmRhbmEvRm9udERlc2NyaXB0b3IgOSAwIFIvVG9Vbmljb2RlIDkyIDAg +Ui9UeXBlL0ZvbnQKL0ZpcnN0Q2hhciAxL0xhc3RDaGFyIDI2L1dpZHRoc1sgMzUyIDg0MyA2MDEg +NDI3IDUyMSA2MzMgNjM2IDM2NCA2MzYgNjM2IDYzNiA2MzYgNjM2IDQ1NCA2MzYKNjg0IDYzNiA2 +MzIgNjM2IDY4NiA3NzEgNjM2IDY5OCA2ODQgNjE1IDY4NV0KL1N1YnR5cGUvVHJ1ZVR5cGU+Pgpl +bmRvYmoKOTMgMCBvYmoKPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA2MzQ+PnN0cmVhbQp4 +nF2UsY7bQAxEe3+F/sC75EqyAWObS3NFgiDJD8jy6uDiZEPnK/L3mRnGKVKMgbG4XD5S4v7l9cvr +en10++/bbf7ZHt1yXS9b+7h9bnPrzu3tuu6ydZfr/Pjr9Du/T/fd/uXrdP/1+946BLQl/Lfpve1/ +HF3/5Dgz3y7t4z7NbZvWt7Y7pVRPy1J3bb389+iQ4sR5eYbmGkp9qrBWQ2nItF5DaRhpSw2loaft +ayiZzg41lIaFdqyhNAy0hxpKfaE91lAaDrRTDaWis+caSqPRzjWUiu691FAaZtpWQ2k40i41lAae +zegFBct7M1izeEemymDNweu0YM3iHRUM1izeUU/BmsXbsxsZrFm8IwEzWLN4ewWDNYvXLrRgzcHb +aMFKWcoKBmsWb1EwWLN4hzMtWHPw6ilYs3iNvcpgzeItHBlGIaEqDsXAasHLPhtYTbyFzTGwmnj7 +iRasJl4nkYHVxOsKBquJ14lvYDXxFgWD1cRblAqsJt6RQzGyar6uqsBq4jVOED8SngoBrCbeorNg +NfGOuhesJt6eE0Q+CZZFIoGEVORF4RIuYtsdrC5e11mwunhNFqwe8yUReiChDN4L6JMfNDLW7IDz +AGTNDjgPQOI74DwGyhfJAecico7bQeMiKrKg8Zggay6gKUHE+WKqpxIIeoryixAKy0B6CZaA+D4k +WPYZk5GQSmeBUDQy53uF2yRY9hnNlgCoYNAUEY0kKqApIhpkQVQ0MmOv8NpKuFeZAVcE2LM5+KYl +BPMpNo0Ey1QIkWA5QYxRssiMj0lCVUdttOfq4nLjlnwuxW7+3La2PrRKtSq5Iq9r+7dt77c7T3XQ +7g+3klOoCmVuZHN0cmVhbQplbmRvYmoKMTAgMCBvYmoKPDwvQmFzZUZvbnQvTFdXR0tNK0NhbGli +cmkvRm9udERlc2NyaXB0b3IgMTEgMCBSL1RvVW5pY29kZSA5MyAwIFIvVHlwZS9Gb250Ci9GaXJz +dENoYXIgMS9MYXN0Q2hhciA4My9XaWR0aHNbIDUxNyA0NzkgNDcxIDQ5OCAyMjYgNTI3IDMwNSA0 +ODcgNTI1IDY2MiAzNDkgNDg4IDIyOSAyMjkgNTI1CjUyNSA1MjUgNDIzIDMzNSAzOTEgODkwIDQ1 +MiA0NTkgMzA2IDUyNSA0OTggODU1IDQ1NSA3OTkgMzg2IDU3OQo1MjUgNDMzIDU0NCA0NjggNTA3 +IDUwNyA1MDcgNDU5IDMxOSA0NTMgNTA3IDI1MCA1MDcgMjUyIDcxNSA2NDIKNTQzIDUwNyAyNTIg +NTA3IDcxNSA1NjcgNjMxIDQxOCA0MTggNTI1IDI2OCA2MTUgNTA3IDUwNyA1MzMgNjIzCjQ5OCAz +MDMgMzAzIDQyMCA2NDYgODk0IDUxOSAyNjggNTA3IDI1MCAzOTUgMjM5IDY4MiA1MjAgNjczIDQ5 +OAo0OTggNDAxIDY5MCAyNTBdCi9TdWJ0eXBlL1RydWVUeXBlPj4KZW5kb2JqCjk0IDAgb2JqCjw8 +L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDczPj5zdHJlYW0KeJxdk8Fy2zAMRO/+Cv2BCVAi +45kML+klh3Y6bX9AlqiMDpE1inPo33d3WffQw2q8JgjhAcL55fXL67beu/P34zb9rPduWbf5qB+3 +z2Oq3bW+rdvJvJvX6f7X6Tm9j/vp/PJ13H/93muHgLo0/218r+cfl17/WLsz3eb6sY9TPcbtrZ6e +QyjPy1JOdZv/Oxq83bguj1ArTSFagfXSFGKgjfg5yDptKk2hV3AuTSEr+Kk0hTTQXkpTSJV2LE0h +9bTX0hTShXYqTSE/0c6lKbgy19IU4ki7lKbQ866BloJlkQYaE1E/04LGGlGmBREVwsDM1hcJZSy0 +YDXxZgWD1cSblRmslAdjkXhIOE20YDXxZgIaWE28UcFgpXBXNYPVxDtEWrCaeNNEC1YTb2YnDawm +3sQXoSUSmkNAB6s3XqZysLp4kyxYXbyJI3Owunh7pQKrizcpFVilYLJk1Xwjy3Cwepsvm+Ng9car +F4HVG68yk1XzzeR1sLp4ewKicAmp2BwHq4vXdQpWF2/muPElSrjLYHynElrHoeDDlGDZ9gjW2Hh1 +CtYowF6ngIsa6MBu4IuQUPNF2/JYCy4ON/CxcN30eRx1u2tNtYZcv3Wr/zZ5v+281UGnP7dh92oK +ZW5kc3RyZWFtCmVuZG9iagoxMiAwIG9iago8PC9CYXNlRm9udC9XRlJYWVgrQ2FsaWJyaSxCb2xk +L0ZvbnREZXNjcmlwdG9yIDEzIDAgUi9Ub1VuaWNvZGUgOTQgMCBSL1R5cGUvRm9udAovRmlyc3RD +aGFyIDEvTGFzdENoYXIgNTUvV2lkdGhzWyA1MDcgNTA3IDUwNyA1MDcgNTA3IDYwNiA1MzcgNTAz +IDUzNyA1MzcgMjQ2IDQ1OSAyMjYgMjc2IDI2Nwo1NjEgODc0IDUwNyA1MzIgNTM4IDc0NSAzNTUg +MjU4IDQ3MyAzNDcgNTA3IDI1OCA0NzMgMjQ2IDUzNyAzMTYKMzA2IDUyOSA0MTggNDk0IDQ1OSA4 +MTMgNDM1IDUwNyA0NzQgMzk5IDUwNyA0NzQgNDIzIDUzNyAyNTggMzk3CjYzMSA1NjMgNDk1IDUz +NyA2MzAgNDg4IDY4NiA1MDddCi9TdWJ0eXBlL1RydWVUeXBlPj4KZW5kb2JqCjQwIDAgb2JqCjw8 +L1R5cGUvRm9udERlc2NyaXB0b3IvRm9udE5hbWUvV0xCVUVKK1RpbWVzLVJvbWFuL0ZvbnRCQm94 +WzAgLTE2MSA2ODggNjgzXS9GbGFncyAxMzExMDQKL0FzY2VudCA2ODMKL0NhcEhlaWdodCA2NzYK +L0Rlc2NlbnQgLTE2MQovSXRhbGljQW5nbGUgMAovU3RlbVYgMTAzCi9NaXNzaW5nV2lkdGggMjUw +Ci9YSGVpZ2h0IDQ2MAovQ2hhclNldCgvQi9DL0UvTy9QL1MvYS9jL2QvZS9mL2gvaS9sL24vby9w +YXJlbnJpZ2h0L3Ivcy9zcGFjZS90L3Uvdi94KS9Gb250RmlsZTMgODIgMCBSPj4KZW5kb2JqCiVC +ZWdpblJlc291cmNlOiBmaWxlIChQREYgRm9udEZpbGUgb2JqXzgyKQo4MiAwIG9iago8PC9GaWx0 +ZXIvRmxhdGVEZWNvZGUKL1N1YnR5cGUvVHlwZTFDL0xlbmd0aCAyNzU2Pj5zdHJlYW0KeJydVmlU +U2cavjEk96oUZ4gpRGzCUWsXFdHaEVo7VgGtioqA7MgmeyAsIZCQ7ULC9kLYl4QlbCZAxIAIiGJx +AYvTVaxt1bZoa6e1daz0zJzvcq4zZy52zpkf82/+3Xu+7X2e9/me52NhDsswFovlGJyakZi7JVCS +EZe59O9JubGotcuol9hAv7nou7ib8xLm385+gRI6YuDIBkeHzrUru5zRrT+i7lWo7A+YA4u181hC +z6vHA0Nf27Rps48kS56Tmpwidd/m7e3tHi93/8+Iu29ibmpypvtG5kOWKJZkZSRmSo+kZsTn5bo/ +P939iMTb3d89MDE5TxyX878j/935/zsLwzDXzL0SH7+cXGmeLK4g4WTi0aSAlNQg8WvuGHYUW48F +YBuwjVgQFowdx0KwUGwvFo75Yn7YPswT249tww5gB7Ed2GFsBcbCBAx7mAMmY61hJbHml6Utu8GO +ZY84uDuQnPWcQS6Hq+N+j8fgk8QOYmA5d7l1+cMVr63YjAxOVBmYqDVXWffmke88u5Vax681NFY2 +AWFtUEaI6EocArWqsFJCiVJMeFi1shnsBBrEL57vaj4NxGSP+ICITsTBX60IX5p00oRH1GiaYZJA +cvxRzLU90WLFof3Cu7iuKkKeqg0uFDgtboWOgiHq/lBBhzPiLKCShbcQ7sJ7vW3xdT7PVIDPlzRr +YQ/xLACHPWq1VxnBSytA3+F3YK5zaNBuM5+HizAuHxH3ZViymg+2TrV0NvZ0Ejxxb5dp6Nwa5LB9 +ht4j9KYf8h/DRIldySyfzrUk+K+B47KTCdJ0eXzxASAiVA02ETrnwFTZWddgEo5zeWKEz0Zufyck +ZouIYYW0UtutrL4fkPEHNjJQsXz6Rc9NtJB2+2kjckbOv/wDCZHL1p/p1SK1hD9/fRP9Es05sf/d +k0k9IzKRZKrwJswRP1+4MSdk8KrGqQ1mdGSEZUUEexGjQvhFSMaRcfWyQk0+FIHSoKyNaA2vjwJv +8BIfDvY7nOgB9DLw6H/z/cAPDv6Y+AQQB55MzH5NyNv3+B7I8AKBPwSZY4eDJ8U/AGIT6MBPaDl6 +eXpKljAitKWbJB0HCScKLRGNxs6hhmGG6ycLLjwp9Qi9w5dww2ksNpdeD0QWNwLianR1JYbyJmgj +ECAP/BswqVu8iG6klHJ18aVKrUqtkBRHAUF7oByutbbWIkRuXKaiLmXbNqKXW4bWc55ZubzKAvy2 +vkUFfs9756dS7i0heL4F1BDuhB4wKnvHzPpynl1HreEbDQ2VzUD0NhTGiGgDDuE63SENox6dCd9v +UJhgmkB5uG3skqW2oYRsEraqmvQtQPSY2qynZebUuEypb4ToR7ykKiQvWR1QIHCiBGSXxkx5mNVd +zu/fQN43XXib0afoE34pWsvRcsvLi3QVFaUg0ANZpa0heG31eXnV2W67AsN8gmwJ9yNFM2ln8tty +QSyISZeEpYpbugqEst6ibvU0UUh7tnDrGqurmHp5/g1gLO/WMxvorZbSdrevPpy5eSn39FG7iMY+ +lLQqe8EiGBmwTkz3p27vFjqhAXKKcrSxbs6zUT3T9Y2I4DZWGPRCHakv0hUlBsdGFpZqdXodlEBZ +ZbmhnLhMX+Hu7I+9PjncM3VaqG6S5SjIPBAkKS1/EaGzT/ElYc5Q/DaV0XluHu2bd+F5UbmX+CXc +aG3ThAj9Qm/HeV8p8BtlzSSEE7QGB0mJSqXNyhNrMoA4mT44KuKdR3fpjSr8YplRCdEEXYPvuhj2 ++dDZVotFODbG8cKryy+Z7U3vGxlay1RmapeZRWUzxdMiJddWZiKhAMhyspR8lW52fRk16I1lRmgQ +QHtT3RkDYaLDlPhweR05sQE50iOuVXqDzlBcK68troVaqGsxDaHV6LZr36e1df0GRqEB5HTgDOXa +43ztW/Tq1y6889SRj/kKlaZECYRUZxwXoVAcpkr6lD159tiOACC27Inwl5rzu3s6zV3VFTUVdaLy +hop6qCMstq6RSUvmceERnPY4rCiOTczLV6VCGsEL8x+PmR0/1zk1K+S1hNa0y865DUJn85lhZoje ++i0fxCVFMk2uSlIkAyJFMjgmqsbh+jk7emGcWLJHM/WGiYUGXkTRJq4Y8lvF4/RqFOb6LXLssPS3 +2ioFJnq7Eu8vb9SDCjSavBxxiV4jV+erzK6SUfkgtICxpa6/kuEmQdmA90OreiDqEb3BlebS3hnx +pC6tTKBEL5twiaampbbO1GIW3UWr/kq7V+ur9KAXgFxXmlb+nKtbFKeP1fsVm1qHPPmRfsm5gUB4 +HrqH8N+uzn1tb9EmNYpq8+ol7fJOEJzq6ui+5ndhZ0RYfnK8KDxGsh92EfSLdz0Q+/xI64BdaOlh +yr++hJCcglZqhZVleYDyGaU+JvnolSlOKy6vKIcyIJKLGWlRHzLXLVKRQh5SCArx+spaqAdiqIGM +F9GeeKItqymBsQfcg+bQ6+jVX+xAy64Nmy8Mig7hiOUAOp2G1Mrzc8hMILyC76FViDN5+8vLk1Eh +oiVYn6FMG8LtLGoz8uJH7o7NPASBENuXOS0f1p0unyXQLLf4I7Ivx5Zhj+4MhXCIkiemRsVn+YI3 +QQtvvYnwn7+4jrBRIX0HbeY33RkcmoVZ6JG07CCcFpNUdupfdtYg4lJ/Rlw2+ueiF58OotfSG+jo +LTbPK8dEM/4PT34PBApHa5E7in6SeT/4A5H/ZzvtmxjsDhMwIbenX4kY2AL0SghQ78sPLcpR5Eil +KSkn5CEQDSfaUwZCJ9KeMjYMC9bHoxeIs2OTXVeB+N30XrGhOCvrN4bXG0uXaBVjATMdA8OdRjKz +Xdia3Uy2AdHd0d5tjzl19HBIVnS2KDumOLnibcI7/Rv6Ey7s1Wp8loK1xYR7G7RN8AWBPkFOjBFc +hg7UNYIuLcXorwuoELFcmAg7gcb5p8rbKk7BHbjSONbzgc0+Cx/DqGo4qy9hfId1C9OmNi6vjbHq +4kYSfIhnfjjsLCZ364gCdLoD32VQGuFzJk0pmYOlrs6C3G5EbXg9IJzG81WVVVLh7+8Ftyusz+fR +EQbUNvQLf3Siv+0sEJd6k/1EdAQO+0n1Mf3vD4bjjfp6+IxAkfjf4668FRCXezRaiKbxEkOqJqc4 +qFCQVcwpxKsrDVADxFh9cazoWTqTHPqiY8XMerEJP1ZLNjPrGSdlTl1pQr4LzncW/sTY3k/IZymT +twZzlIwam6taKhtA0PM8T5Q4+JDafUukkSb8QE1xI9wiEMJ5T8OQjJ8llUokXVJrX3dXn1Xancko +8LLKnmem6HOpZue5B0j11IW3lgpiZCLjlkq1WgWQoKhW1BO808akpPp0t1iIUaRlpojlcRAKb48H +IYeAW4lT8b2JDeoaGeQS74VH793ufxU5hQul3H46hdPF5fl3VDYbTW5MxJZ26JidlMMjxSNuCH94 +97dvgj+iXedE62bixuEKcXV0+Mb50YLkM8KBdGN2awATr8/Bs/42z+5YZPNruU2VzZXM3bM1qqJE +z7JxOK5S+5cwWLUm3L9a0whXCeoRXloVqkgk9ykEjAgXN5hZKPIBe5j249++2H9qaGLuuzO/AloO +aHXS4zcW4i9md4XaNIWu9/wtKdZ3e95r2g2vwHq1V9YRiX9Gss8xhn6Dk8pIhTSiE0Zu/4r7K/vr +HR3vtzu+gGH/Bt0sctYKZW5kc3RyZWFtCmVuZG9iagoxNiAwIG9iago8PC9UeXBlL0ZvbnREZXNj +cmlwdG9yL0ZvbnROYW1lL1ZLSk5HVCtWZXJkYW5hLEJvbGQvRm9udEJCb3hbMCAtMjA2IDEwOTYg +NzY0XS9GbGFncyA0Ci9Bc2NlbnQgNzY0Ci9DYXBIZWlnaHQgNzQyCi9EZXNjZW50IC0yMDYKL0l0 +YWxpY0FuZ2xlIDAKL1N0ZW1WIDE2NAovTWlzc2luZ1dpZHRoIDEwMDAKL1hIZWlnaHQgNTY1Ci9G +b250RmlsZTIgODMgMCBSPj4KZW5kb2JqCiVCZWdpblJlc291cmNlOiBmaWxlIChQREYgRm9udEZp +bGUgb2JqXzgzKQo4MyAwIG9iago8PC9GaWx0ZXIvRmxhdGVEZWNvZGUKL0xlbmd0aDEgMTQ0NzYv +TGVuZ3RoIDg3OTk+PnN0cmVhbQp4nO17e3wURb5vVfVjuufZM5mZPCZJz2Qmz0mYJENeBJghLwgB +EpIASWAggQRCBBleImBMxMgjKMpDjKDrY2VR9h6diAooIu5Z77ru4sq6PlbX1xHX9REPu0Z3Pwvp +nF/1JIjunr177zl/3Pu5dk1VV1VXV9fvV7/H99edIIwQMqBexKC62gZfPlKPAj0U85etbgtH2/5G +hPDAsus2OOe7ludAx++g/afl4RWrt1R+4UGIvIIQ99yKVZuXR8fr3kfISTo72trf3XDNHoSK4X5U +2Akd5jrDcYSEO6Dt6Vy94fqx57XTOVatWdYWbXsvIKQJr267PsznkT4Y/wR0Oq9tW90RvT7xcyiS +w2vWb4i2iyfS6+F1HeF3t75zHsb/BiFG5K1IC+s6j+Tx8uqDXYbc9Dz6gVq+M15X2ke/Qv9NhzCW +/3cOfJ5k/lefi2/H23EvbsSb8Gq8Ea/EQbwMN0N5M7TWoEfVQUfQJ9iJ47ERY+zGZqxBl3AqTsIx +mEVaaFMeD6sj71XLYTwJfUlUbqHdkJ9Dv0EX0BBSsBGdgbQC0jH0AGpCTTgZp+MSPAN9AbMnwthD +aBCdgjEvwj1vo9+ji1jALfg63I8PEAOZTlpgXBwux7vIbHKJ9SAN3kQseAXzNB7GPLZhD3oa/RK9 +xURG/4DvR+8zOeQ4uh7NQq/iiTjIHGGyGJmcJ0cQCk5qLC4qLJjoz8/L9U3IyfZmZWakp6V63Cku +p5yclOhIiI+LtdusMRazZDIa9DqtKGh4jmUIRtk4ElfeNBiv8TpcLldzzlg74dvtCJMq/ckVQZZv +DXJ856bE77STvtNOvtKeE0HWSJW7vIJOPIiqfh9BMRFsjSD6FBwzG540dlNle5e7cmUkvry9tRXu +qHBLzkjVRd/YUtS5B3Xacnd5hzYnGw1qdVDVQQ3Ghgdx1VSsVkhV5aRBggRDTnbE4o2Q1EqauyLB +3a1QcVfATHAl5psrJ0fP3nr1JQS3jddiojUc4csjGvW5zpWRYFsE7XYOZp/tv/WkhJa2evXt7va2 +RcC5NljjIGJSKzsbKR8raW7tdEZYmFwtHNDjrOx09rspOyo7W6F0V8Bdf7cfusXyph2us46IBc6V +EbM3Mh1GTN9ywcH0V8atdNJmf/8OZ+T+uU1XX3XRsrm5OQ4W3F/phglhssquMiAlzpeTHaVpjAHt +rV30mV1tdJ2VXc7+3R3qWm9V16AOreyEjWn7X43q769sd1e2t7WXRWcvjwQb1RNqbGlSCQTWVTSP +dY0NgCuseqW1otkVZXZNfVM5XZi7rcIR3fYrPa1jPdBROX7RSVdQDRNEnMucEVTf5IahxbToKEb9 +y4pV4XE1Y7ir7pu7Ilyq5Hb2f4UiuNU99Pm3e9rGevhU6StEq1Xuqtb+/iq3s6q/tb/t5GjvUrdT +cvcP1tT0hytb4al1TXDXydGndzsiVbc2R6TWTjwJeE8loKq+KeBwmZvHm3XjTQQiBYKlU8kBLsCv +euwEXEaNTS4nMGpeU7MD+NRE641Qj56pIIHgFsMej7GN8qij+Ap7yseqLheVzt0ng2gpNCK9c5ui +bSda6ngcBX1e2I9WeuXs+BXbPHqld/zKldtb3fCUJxB1qLaIkHblZ5LsMZWdkyLY/g8ud0SvR2LK +mxgHaY7WiIOhNa0XNH1yJNYL9QxvP2zCK+6I5I1wTWcdk5udkhksAN29BnfN3JYmZ2X/FSmI9oxR +SuUARN3d1tk/pkpU6MEUlA268c65g0G8s6Gl6ZQEnnRnY9PjBJPy1rLmQQ9cazrlBNOq9pIrvbTl +pC1UQwXwcSKolxynggj1qldZtUNtLzuJkdonjPdhtOwkifZJah8cAC2AP4JOqUfIWHzp0Mhaw8Mq +x64+VB4yJ9B1SIM6EYcIklAQzQMEwY2OAo7BQbHxDx975I9/b5ZBBILtr+ulwuBv8Rv7zPI5yL+E +/AvIL0H+OeTnIT9y2CPfA/nQYad89+EM+fA+h/zHAZt8dCBevmsgSz44kCrfCfXgAB6A4aY/4QP7 +4uX9+7zy3n0uGe3D9EGL9umkQtNp+bTvNON7BqNT0iliArqfxM6/9PyFSH92/jn4Z6bnKywNO4eJ +84u6L4jv88DntZ8zua+FXyPHH8+QHz9uln3HA8dbI+FI+DfcRxc88oeQfRfoA47/BAihDxp9Aiq/ +7pkgn4f8So9T/lWPWT4L+TnIt58ZPUNMz+LRZ/HgY2Y5/BiWHnY+THbvypX7d/nkXT1+eWdfnLwD +8va+avmWPrN8c98kuQ+mWXPs/mORYxePscEHsLTIuSi4iPkSZtzWEyff1DNT7oXzjfDEbsh1Pa09 +4R5GMrlkuy1L1vAuOT4uS2YZlxxjyZKzc0xZXmNGpikt3ehJNaW4jU6XKVk2OhKTDHHxCQabPdZg +ibEaTJJZrzcY9aJWp+c1gp5hOT3CRC+Zek0kyPfyJMj0MsSEAqgW9SDWhHxQDSatgcZz6FdoFAmO +UkE2TRJkpkSQUbEg1/lxxFKDahrLIjEYzg1lEb+35qSA6iP53pqIWLewaRDjPc3QGyE7YXsaI+xO +kMRG8CEtC5tO4nh6+RbVpUDtJO695bbbHFdqzc3epEh7TUNTJJzUHMmnlTuSmpEXjvUb1q9f7/1P +jkGRPr29vmzwE5Y6nLbIJ+6KwU8/UZ1P5FN3BR679eo5oAqTXmlFf1cdyLtR7d/wN49Tb6LaQqj6 +aBAPKgMn6wmesIhm37l3zqlFXq7L7DKnQoFh1F97OXSJnhFUqDa+hRBv57KRDuUE48l7mNXi14X3 +NEitPcG/p3EawgYS8l0YKimRLqCxc14uprOOJd4+8pnyxchnxIYtxEakkYtEwnp6pk9wK3tIF94F +68sLekzYROKQjGUAwT7sIyUogANER95mfssCdiQ9YIB8oSEkDQ/BM0IidseQLmXgvRfwrhGOXKLz +XUt4ZiWTBvMlBiX8BpFQK9gIRHxcLQcL9ftCyDcUXSCzkt5EeOyE+7Yqp9mfQczAoMKgCcwI/lfC +WAlh6L0nR/8QNIpSEYqjBeUqrMLvAxYHfHm5O7gJ3h3dPxWxC7M/u/yxco6x89a/PKxpglkfGv2A +y4Low4vCwTm6GwxSkU5wCDlCjsHPlAqler95GlMtTDPPjG0SGrJWCpsFKTk54XBayqE0Xua1WuPd +fLwzZbcc1JmLZOsup6y17kIoBxC61hcy+31DlpKSIZ93CPRiyO8LWKAxkg9rCmEvtvIaI3ZPwOlm +fzL25xcWTcUFE9PSJ2B3Cq9x052xTYV+e2wy5rIWNCz697uP/3lO1sJfdwb2e1PcvtTCgaktR6Zm +s+6RKnmJZ+vzVQuX479s+Nn0WdW4KAVXF85ISpOD5RNrYl022cTMUD78kjC+rKIngT9oO9A9gxtC +qWgK6grW5Ip+bW5xUCzXTiuuS2xMrnPP87QnL81br91g3CCtd6xLXF9kSeJ99zjt9oTDTt6iKb2H +j08qsNv1mUCvRHcwULAL6bEeth/oDgHhPguIxxDQDBRTRlCqozSnpKWnkYKJlqJCD6XP7I7SPE4t +vpoRVt5mpZ3AIG5G46y5r92+/Z3aha0ty5fikjerH01Ic9xUf/Z1++wfL1twZ7ChXSmRU7NSPUsn +ZrdmkLzMxFnZrjp8af1LlTPnVNfMx9KzP8W5G8M3WDnlbYPr9MMTSjKyJ/1UuTUlVFcdSky0WU3a +Ce6t92XJSckgHfdAZOoF6eDR7GAugxHeDQJHfSNziOMJZlANWUhIFgmQWrKErCFbCU9AeSGoZDGr +7j9wIRQCGUC+wEh+CMR6hzS04ywGUYTt5bwji5VGcnqEYW9nH7m0gH0CJwEnIYYjCyD+pRYhKWjC +vyUc/1tOw6NXaiEWBNbS6YYCQ99oMVmg9OPraCZv4V2X7gV1hXniwDYkw+o1EGc/GqzniShqBYJv +gg5Ry7DbOI4v4os1NXyFZiHfqFnNL9XcyK/VaBGgAGZ/GEQYaUXMQvy1hcc8w2HCsOAFRK3IaRHH +EXRy9L2gRSsVcS4okEmPkV7WY44SHgLlC1liKd30pC66vLEpKM5Gs7lu1M2xoWYc2iGNnD17Vi2F +s3D5iYA4WyQoBJiQgYRdOsInK+tXjLy5Qukmafhp74kTOEd5lTt/eTWxj3xKreYZ2KOTQKUNeZAf +tQRLa6xNpNG2krTbwvqwYZ1biLFkH0DJUjJpTX4smSQna5L2C0zOfo39Rku2yaRJ7UYnC5KzezRP +TpS+HskH06WK7pDKY7p/a2Ht38gusFsVUhs0bSCrqqB6sTmqwDHfbnInF8xqevXBketI2RNH6+c1 +rOvc92PFmurL6l7rmbywN3Wic3FRWc4P5jcmPnhr6eQc/OKqY8Vlxdz5uEzv3tCqIxOEpKfwr1Jn +WiRGeYE3x1aP/Hr67BgDUW4j8fEN1JquGP2Qu5b7Aijffgp5R/uOgwWznYyezSdHfxKcJ+qLfFOh +EJLiktxMGpsp+ERfktvdTJrZBdrmxPmejcwW0eSLCcSsiemJYWNiEvbqWWdObk5rTjiHzclJ24ti +YnJOFqCC2oIlBYyzmz8xEZgUkr7OV41aSC2AQV4v9nq5FM+3dNtO1TsN9D2NKjOvKrPdTrlTWFjk +N/O0j1nyI+Xjjo41XR1tWD62+K5g+erM7MR5hUW91XP3TS2trp085WB11a5JeY2OjOLlxdW9SUvb +2nDKmUHsXLFslc0c47Mqd8WVOZ3Z/tKS09tvPV1Y5MvyJJXFKffEZ0s2O+gCSAk/BaTEiJLQ5GBW +s2Weo4N0Ga4jmw28fZ/AxO7TmLq1aAsMPSnLclCuk5lYEIlk6WugdDg0NKZxIAVEw7OqFLCxdgv3 +7f3mp5zZu1q5/PjIlyTxKSy0HBpU1l+zoXTrDW1tu3qnrFxKPn5FOdFUNpE7P6V4sfL8a/vPlybZ +Li+Kd03+Od1NWCX7JaxSh6YHE8S9uXyQb+XDgLMiPByY20sY7V4sUJBpkmxFAisgZODFHvyknoou +2Bs/eL0rggvrdV3l59kvL/2CLRipJreMbCUnuPPK+8oo5Dvok7eCKn2oPrkkmCKy+3lGy+zHgu4B +bQ/DkQcQgxnGoJcNuYYgAAo2ZKbzD+dLI8P5CDwaGLe83Ezggpn6LbfZz3x4eWB4mOkcHsYC8zwW +lL9cDoxTeBGewyF30Ar2ZC/gn1YUBj1GGhbo4IHf5igGCKgz0nVfvPQy7iWPc+cv1Y7Nwb8Bc+jR +k6cQA7woA2Fng9R36xw6r45Bol5r0kliolbWpTHZrE/r05VqS3W1YrV2i65P7NcdEO/SHtZZC7XN +2h7Sw7FaytJEo6WI69VLRYQWHNEyoo8NsK1smGVZOiAOulkdYhmNyGh0Ikd60FNGZAQtHz17ApAH +t03zpAEI8IYoFarRp7ZPNYR5uYD4QjgEWgJUgf2nlAEk4d9QtimfK3+GfBCfwbV4Dj7DfDSymey4 +7ODOj9jIZyCSK0Y/4JdzF2F33KgymJ/OZWoydWEc5no0PTqNbZ9WTBCzREZkXfs4xsakMgwTYwKz +lhpIxQ7QV4+qr8NDKBAaCoRUMZaQy4nMavktd2vEV9wtv1zpVAaUu5VOPIBX4OX4kMIUF07N998y +o/qmwvzAlPz87TNnbid/UO5RQviHuB0GPaAsGXFWnOrefnrS5MKJk4tf2HbLM6WlxSUoqoPcbtg3 +Cckg3/EN0nLTRpaJ36fRiHH7gNnm7kloJlVAYLUZLBZCLtkVdJF4TY/4pFMaBgcKouGluqjK99AV +o+xVuRlFSt8xwLurpjW//cN/V3rJ9Xv+taZlibK+ImfyuiVl1y7t8aa6mEvtz01ralGA1Xl5pSf7 +AwstcZxSFudxNo+tmG9SrYaMNgfr9VKClC1NkWZLi6R58XUJq6TlCT2SzizdZJJNfrlcXi8zsk3Y +HzDXmnvMjNls1ey3MSZrWMZhE0bdiXKi1WRyOSlRgqXHCkR9HSUKEIJvKARS7x/TXEtJFCyMnMWh +77gYkB23+WovxOIJxemdlbuvW3RDVkYqYAGv0jWobCN9fWcaGpfdvYcVi+tiJY2yxuKUay4XkpSR +d7nzyfn5911/5JVK0KfVox9xy7nPwYecPoVSRnuDRlAloRcKLlk0FkGU/m/BKqjo4hxxhXiSoxLP +dMz1d4jXiRtjro/dlKfnCfDKnOBlk5gAOG1X6v4k1qnJ1YQ1jEaj28/EOL3dCeZuZ4K6tSJMhVAB +9SK/p/tJAfIYPo66EjOoC8UK8azX6p1kLvDONFd6W8zzvNeYO7xbzRu8+lAzBQsab6yXhJrHPQ+2 +Ihc4H7Pfzl4NpuFXMBFRaw1+yHO1iFNpWa7sVs6eUoauz9qE03e613mySxrqGp+pP30Eb8Sp+7G8 +MrNFubQzd0l2enFLd/1dC378Q/yb3ylD0/Jxx5LleqOlsCBveozV7Zhy/vArWFPiVR6Z0WawmKak +lwYSzM7E4uepxcoEya9RkVh2MAGze3mGQQtxD7ewB3AiKwqSGBR7RCZqVS+MXFDR4jfwjqtRfEqv +4uNS2MFLteygGg+VAcx8gVpB3BQE1MgThhNECNMhvCKCybgFbeQZ3qU1FakwzUgryCgbg8ZWI8Or +2BTsEQoEosw+hXSj7x8HGwbO5X1qyxgnFGCygL10L7o2CBt0gH1jk4qYRqNUNIdMY6uF2WKZtkq3 +hNSxTcIisVG7hrSxK4UusUO7XLdZ6BHD2ut0u0kfu1vs0+7UHSYH2MPiAe0wvsQ5DQCUZSKxPuJk +p5I8tkSYIuZrC3V6sLTvB8Xk/CLihEI73hJpS7XCIqyB0IXAtdeDU2xJRWIWFD0Q9On0NwFnwsBU +QdPDc+AyRc6Ck7gUnMP58WSuHM/i5uNmbileza3D3Zw0BkHHSjwenoMmQtEM5pkGja4YKGKEF5Q1 +ygLlK+UylGvw3o+wBfdgDpzZX33MS5cLwTuNsphmajnmj/4be4K9GZlQLloenG6K47Lj46q56sRm +rjnxGm6l6ZrE61LXZYZzDPiPsuy1pwcNpqL0dPdRr2Q4arfnyji3z/d0vi8fmzLkDJKRoemLfyYP +3AroR4hajXxqBEFKfF7zuCksMOKrzXes2oRYq2AigC1PEahDNLAEYOZkbRBe11cfyy4s0cfFBisK +12QlzU8rWFdx/5vXdrTjjPsGDjS/lO0qwfgm7Mdm5TBO/ZS3Gc3TCtzZVmtMdr99qiUu9n8e2noP +AESRD00PmLHJlPnsSyMsUH9s9FNuKsTqEqCt4qCnElcmLTAtN/VwPfG89aBREpFjgLEL5pvRaZmP +1fUJp5JVmqiLomQFxlwUDRQ1VAVoZGjBUQLM0VhwqvL224v3BE3KUdzZ8C9rX/u9ctvym/2r8tKr +8m6/lUwDj/p4Rloxbx15q6xeOad8dvBBOWnkl0YtfWPZBLuzlt2G0tHOoDuXCYil8XmOIFPJzhJm +ibPiKxw18kL5GvkGpzHNCT7fCoJGAbWRCqMNOqQgKEeuhCUp9i69FPBgDxVMGTo9nqS7kF1CHsnT +42E8vkzsyWzNxAk3889kUCdMI6OQXzV23qi180aRAZeSploqarjGY+KoS4YNjdozgMtGTL7c/2VL +89KVixd+0bv+J41+W6k3c+m0Ow7ft69itSdlot0/71RyVXX1u3fee6Fmell+hnLOkhtrTzpx74MP +yzZrtk05l+GDHWoZ/YD9AnYoBjnR1GDGTO3MhLUS48wyUM0HUbSguLuMEk4+yNnNVtKHnk5x3Cw8 +4wISosIXGKL7RJceyqSC504h5m/WDujmqqWzXygDoQe7zn3dMKPiJ20dN1VggBVpje49e9bdmHft +xlkz8GSsv/2d2poGrwu/eymFpEvGwXuP3JkK66Q7dZndDtFdIro22OAhXq2fTNaWk9ncbG25cZbU +wi3UznOs5K8RW62tsRvIZnGDcYPViv+YmKiPP2qRkCAJDcIyYb3ACQI7oLeLor0PnU72JeNE3Gd6 +Jkl1wUCX/4oLGtcnV/StDOW6exwrmVOjMIm9fPlF4dQT616fmrHlzZuVR5UBPA9ngkmwKoeYrnDn +dgH/e9+t9T7lvbxsnIvjsR1XKp8pl+etXbdqE0igF/D2Nj4ZYvRg0AOYeMCGdYLxqNlk0GoRSjAl +yAlgxQWzvs+0xLDGQAwgNRCG+lTDXeKjWlJSElBfJeHo25Mk7LJRVXEX+EGK6DYw2xxxs7O7arBd ++VoZOHTo7XfrtuVzeo1l1mpx+PJeZs2w/PLLOpFKg9LMfgH6kAYYYF6weI59Ts4cf8ge8q+0d/m7 +hS36je4tfp3NE+e9yyWlmfIOxmm1xrv4RFF0eNJtIB0FE252PAPh8xBFafnAQBRQX/oEKDdp8Jx6 +5cXPNy+7pmDag76Rm6Lvyk3L3Lkf3bHxw4bssjM17d0uOXHaD9o+H0Vzppc937HwzikGHFIG5BbP +nj2bNxV23vSDN6dMLUq04vgEb2qKs73KVjAV9jhl90s1VXO8afmXR/GIwfTDfQ/2plCffAx8sgU0 +wA4Wyo1tMbbJ5rCNxZJBuDNGMiIDBrLicuNa44ik6zOcio3KydfUQI0TBcHVxPHIVvXUhZTvNs6i +HDSarbMr8zpKQS46WwdXPXWO5FTscMKy3JcvgE16tabuN69SP3E/FInqW00Nygu6uB8gXuKd4LkR +MWH2XtTH3YuwhAmuE1vFMECEcXygwngaHxXR9z8W+hyt0odvYJfdj83j9NXDzDr0YrARBEg06mQs +iznYJwZwMQmIc3CNGMJLxGvxaoggu8XtukfIA7rnyOO6l8hXunhCGLwD7jYJskCEmSIWc82xReJO +kquDCAkT5uTom0EH1BmtTqtBAgIAojVxfl25rkG3XhcNqZLBWGqJTstE3xH6DBipASQRmD7ulH4M +/gJRapgUjZfAqqAd0lmvcNbLjXjXsuCXwT0LAIQzMY7yGfwxV6+ElBeWUrpxH75PWYU/2aTs4a2X +l+CLSmKUfmJROZsUtBDo6BtjJNfKhTnKSLqVUR5G+QeDo/dpXgddyECLg9NYO5NoS8yIO2r/keOE +/SmHkHZngmSOlQlrFO+0SiaTMblPPhaL+4jZ0Gc8hohE4MjKRFm5WXVZ4azxQHkkXxoqGR6THSBR +tS9mVXyi9uSqt71qabvqIjusHBQsluqygvYMus7QsRVrjuWu+uXSp55VDmos5pnlOfOZxMsXSF79 +eo/H5Y27fIFddkN1/bLWhZ1vnRtJJXkN66BfviL1QN3fl3rT/4nU2/45qYclqUJPbfo7XBrYdBrN +uoIW24AouQAOmAANpDrAUXpUOzJE3x3Td5xXR6qFhQUT/867JC5NeVb5HaRncSVOwWl4mlLpdnuc +zpaJE+emutJTXM7mkrxmkgcm+HkcwDYci6cqZ0fe8m6+Ztn2jMyUxKz0nSsW7chM97ioVh5T2rmp +wCXqHQNBbwWpMFU46031MR2m9hgAtoli7EGzpDcl38XbdQ4rLDzF6BD79KdcURgD/ApcgTFWulTV +8o0z6wqSiS5+6rzKGU91tm6vomwDKPPrT5TbwpsBynjqMyiU2X1h5py6zFQlmxvdCFjml8rnDx0A +LPMLo3A0uqPMm+wKZEHFJ7A+rCfgTajqxWqlIvZOk0lnEgWErD4r1mv6xFMx4yEnrDAw4o1+i3D/ +jRAybzpjl6fMvq6CrmlTZGZMroXRC4I1bkRilx1ZXk4IlaYlgCK2AJ9y0baglO+rjpvu24g36zY7 +Nro1MgVLLggVOCcUpWawSgkZECHWAaCm8AnCxKNJkoYuNQaaGo3xKGN3ZdycYL7ZlaBRI0WtGinm +h/OxJhqwWK6KFb1RDEWDxZCKQ7CVdan+xT4mFVFRgV/BRI8rP/oeMupcYtUh7BblReWPB4dnuhzT +pxXvmdu1fHJjxq7iuw8A4tXe+PE0ue7cygWbCtuLeoJ7duL2R18rTsEZMTkJsS7fhMxUs2gzZTxy +44Nv+JOUC0WVudkZWTadTUq9j3r30U+Z67mHkAPNDGZrOQdHTLqwjugkg+aoTmtyOGKBViP9kICS +TElYMEh9WmGNhpLp94PjpMRSlAjVgOr26evV1CiYpw5e3SiXeRzpF/mZ6ydtW/zrcwcOgDWcqzxG +TMbpFYkLLclak/nYy8QwDArx3LCyrrTJ7c6M08JzHxj9gBPZZWAHpgYztXwCPytmYcyqmB7NlhgN +sXGiyXwnZ8cq8ouaAwrSY9WXoSA/KkiPWoMx9Afrumo9ELKKykD7j9Y//XPcpbPGzK6cEJ6IO2+Y +Vfv6efL2yKvz1qampqS4GGqnk8Ei2WAlPFoV9EQ4AErxZDrXxLGQ+B0wgGO3M4Rpx9eQDXgrYdVw +1iWaihhaII4wJgLBLv0OKPiEWoEgRoLxECZF3yNG1wmhnRrkjXkSFFIDOxFzNqVW6VTqcTdmMWaX +XbqXXXb5MsNS6c4BT/AIrEyPHg+uFQnPxhM7m0nS2BIcILlsqejXVuNaEmRrxHLtQjKPXSQ2aFeR +dnaV2KbtJmG2W1ynTSS67Xqsp4SwAquxasgw7PN2CE7n4sVcB+7i1uIejt8orNd9E8GbiKCSGQ+K +wbvUb5pGCgwko1MN4PnxAD4av9NXRZS60Fr1YwqU9NOrS0dJdNCf5hHlIWXbRx8o3RAtbTl7EQcu +PEtpJV+N6IDevzI8zZTmZLB8sUCzBt0WDAjcTK6JaeaWMxx0cDzH/hifAhe6g351fUjzlIaohOgY +DRfHpDJerpjp4raSjcwWbgOvI5QCN+wRTzeKIK6Ar6S0cayDENEn1oqE0kT46FahAP1UdNVehc6q +hXBWiJKjxuHkCEZ43cgdypbHlRq8Bd9GXv8rxg+xC2HtdxOJiwWZYpA9qMWvg0Bw0S/BdPbxb8pc +7KVt7I30AzfYeR3zM7Z4DH01BSt5zHEykRmZlzU+4mN8vE8TIAEmwAc0EMNyzbiF64Ids3I8fgum +f9VEaqm/Z1+VeMybgKYlKkKjYQR1XyoxYF3pGzvsYos/Vd7BYaVbPTE/I7NHjpPZ6t/MyP8g1aHr +0QFIz32TcCl+mYhqyvlWup+RmeMsz5aPpU1qupuzQNrIvcy9zE/j/6RJVNNnf5uELuFpsVS8Xbyk +LdOe1o7qsiH9D92L+iL9Zv1LBiekxYZPjaXGXuM503RIR/6fSWdMZyBc/z59n75P36fv0//Hif59 +2NhfrVLPT/+MLgEywB+UnZrL+OtbZswrXDR/Qd3g8eaMWTNr5pqaGooqKmur0zxVvqT06fmTpDmW +gjhjfMJ/9f9A/q87WHSjWrKUPxd9o6NQYlpS9AplNkqFWI9BflSPWtAMNA8VokVoPloAKGUQHUfN +KAPNQjNRDZqLTKgJNaAiVIEqUS2qRmnIg6qQDyWhdDQd5aNJSEJzIGotQHEAbuNRgvoUC6LfEhFE +A3qE5nesa2+7ti27bM2qdvUqwncApvtn/2XnO+Muoouj3+rA48PwlUxOo3868xfRW+QCcjNvoGtp +5vrQ1r+bI+ghyNsh3zOemWL0wX+W+UIUx8ehM9xLaAX/EJw3fTuzi9HW8czFozOaO6OZP4dWcO/A +GMh8GZwfQ6u5DShzPIsaVPbPZK4JzecG0DH2SdQE5xauDjUxbcir1o+jY0D7/TRzi9X6MWETOkb7 +uRvV8cdoZv4K9z+HljBH4L7j6AHOj5I1r6McmrkClPx9/m/OEXQ3zexxpIvatH9wULnnNI8ORh57 +eolp8lfIEVWUf1nV8Bd6fnHvT3966dDIfsPDwn4YK6r6CMd/AMknH0EKZW5kc3RyZWFtCmVuZG9i +ago2NiAwIG9iago8PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1lL0dKVlNWTCtIZWx2ZXRp +Y2EtQm9sZC9Gb250QkJveFswIC0yMTkgODI0IDc0MV0vRmxhZ3MgMzIKL0FzY2VudCA3NDEKL0Nh +cEhlaWdodCA3NDEKL0Rlc2NlbnQgLTIxOQovSXRhbGljQW5nbGUgMAovU3RlbVYgMTIzCi9NaXNz +aW5nV2lkdGggMjc4Ci9YSGVpZ2h0IDU0OQovQ2hhclNldCgvQS9CL0kvTS9TL2NvbW1hL2UvZm91 +ci9pL20vci9zL3NsYXNoL3NwYWNlL3QveS96ZXJvKS9Gb250RmlsZTMgODQgMCBSPj4KZW5kb2Jq +CiVCZWdpblJlc291cmNlOiBmaWxlIChQREYgRm9udEZpbGUgb2JqXzg0KQo4NCAwIG9iago8PC9G +aWx0ZXIvRmxhdGVEZWNvZGUKL1N1YnR5cGUvVHlwZTFDL0xlbmd0aCAxMzc4Pj5zdHJlYW0KeJyd +lHtMU1ccx89te28bKNXSXcFHH6Kgq4q4GRUd2UDloUJQQA2LC4+Wly1lUEHwMZXogIOK8pqDUARR +XoFqUZyoA2UyHjI2p4FE3Jx/iCbGbIK/252a7BZnFv/dHyc593fP+f0+5/v7nkMhkQBRFDUjVG/I +1ptTE+OXBZkMOmfIj5tLcfMEnFKIick+ZM+llWhL9YQbp5IiLBViqej8PBrcoUMOp2bAwZlIRFGr +w7ZXLI7ZtuPDJUuWrjdl5GamJqeYNSv8/f01Cbmaf/9oNuizUpPTNT78JFtvMGUY9enmiFRjwp4s +TVR8epZmi8bJ8F7kv2T/Lz1CSB4YlJllDssN16dGGZcu91upQcgLLUBRKBrFIC2KRb4oGG1CK1EE +ckMzkRyxiELuvDxIhALQJfSSyqBaqF6BqyBE0Cr4RRgibBc+FL4SmUWtonZoltmTsAUUIOfCLBRX +CIvYLrKIBl+GlNiNNFnLkMo3RhqWMdeBD+8HOUu2Mc/hIu3cCHLYyg9/kLuPgxbOwkIyAxZ6KCbH +Z8FD5jd8u6rT2mm90I9/wPd0vf5dEgV377sLl/vn4BuZ3QntcdadVQFYQsYY0BI5C6uZEWt6zPak +9GA1Wc0QuQhCGMXkrxfTwiP0aUFqEsLIuNnYws0BdbrFfQA0HgrrAGdlHVbQgE2siBzv6Bj/tryo +oEYFXuL84mP4a7wZR8UbgyQKvymxjOs2gwAmQUB18RuiQSPkjnMCthCYj0eINw+iXBVMhMkVhpps +dc3e6iPf58G6HZ5thyoP4T2SNF3OpuT005W5qv0VRyuONvKrmZPE5Y9wWIMf4N4qW4utpf4G7sY/ +p1zdUEs23vTUVR4uxWclTS2W68OtWbHFKhk8Nk/B1AT1iC8NPVwDGwDeREO8g31HyO/MqqvxT5vP +nSg9p3ohPlCYX3QYS5KOVHSp4dqYWAbN2GLfaKEGQCuEVLuRJdo3RtDyinQT01/2mXzzVLwURORQ +EldOSRNfBnY57tBF4gLxTr0u9lB+cUmuyktcW1BZVI3b8OXT9eWXqqrr6gYh067wlNnvv81/F7Sc +r7OGgRtiwcMxRPNFgOWGaMcQaO1Gki0mHzhGiSc3ShPzOwTza/CagBmvKa4WstniSlyCT+Oe/BsH +Lya/WHmHULy2y5cSEQkjgc/mwzJwezEy1awmKiYvTpe5Eyfi3dU5TQctx+oLb0qOT7Bl420d/Txk +S57F9E3OqewTSZJpAbgCyyDIqWGnfInO02qcrWfsRhGvopyfyezLzSDlIaTUVVgAPbBQyL3iTrJ4 +eH9nsi22Z22jF4+y3sefeBG6NxoWm9R/5rzcazXhyNkRUUl+3tuujB1TER+mjPi9XgURWAKRIHwC +i0G8tY/MbVAT5qym1lCLu2ffut42+rw7MbBEJfvbjUfzBVfelH2gJmreXJ+9HR6Ktr53Bh0VK4bv +ttv6rjVmxKmIYzry3jfnLp7c3E9QyOdZUfGqL2/GNIZi3rjhODF7V7RkeNoD4EMN8t0ZBB+W+Dwu +EOOQjJTIryRR4o6SCxXna23NZ6x4TAJK5+IDFgp09i9YkvDGQA8zkGA30NN3QMpVAE018gQ6p5IN +9hT2U7xpd1xkQvReP0yUmMirP2qNuRw6on+ER/FAc2efrcfyFIMnhln7nqTeiv8p2LqGF5IWtePG +nOqkM8bSAKzFn+SvO2zaF280J+IkbKrJaz/QlP8AP8OPSh+WN1Zdaaq3YQkPwL83SpBQ8KPzAtZA +AxvIhRJ//qFxBNPEBaxkBU+24r6YpIGEJeEMhMNtmj+PzFzHWcsgtDKxjgEXF5jvCi5lUinML5e6 +IfQPirrcsQplbmRzdHJlYW0KZW5kb2JqCjE4IDAgb2JqCjw8L1R5cGUvRm9udERlc2NyaXB0b3Iv +Rm9udE5hbWUvU0tWTEpIK0hlbHZldGljYS9Gb250QkJveFswIC0yMTggODU5IDcyOV0vRmxhZ3Mg +MzIKL0FzY2VudCA3MjkKL0NhcEhlaWdodCA3MjkKL0Rlc2NlbnQgLTIxOAovSXRhbGljQW5nbGUg +MAovU3RlbVYgMTI4Ci9NaXNzaW5nV2lkdGggMjc4Ci9YSGVpZ2h0IDUzOQovQ2hhclNldCgvQS9G +L1AvVC9WL2EvYy9kL2UvZml2ZS9nL2gvaS9sL20vbi9vL3AvcGVyY2VudC9wZXJpb2Qvci9zL3Nw +YWNlL3QvdS93L3gveSkvRm9udEZpbGUzIDg1IDAgUj4+CmVuZG9iagolQmVnaW5SZXNvdXJjZTog +ZmlsZSAoUERGIEZvbnRGaWxlIG9ial84NSkKODUgMCBvYmoKPDwvRmlsdGVyL0ZsYXRlRGVjb2Rl +Ci9TdWJ0eXBlL1R5cGUxQy9MZW5ndGggMjA4OD4+c3RyZWFtCnicnVV7VBTXGZ9h2ZmpwiJMBrTA +7ooPFBHwQUGpiAiCBJR3BAUFXYHILshLULAGjUav1GihIhIXUR4SX9WiqCgvTdSCQFWyG+XhKojG +VlqSfLO9y2lnIWlP/u05c+bMvXN+3/1+v++7v48kTE0IkiQnBSpScxRZKZsTjCs33pbk7Ux4exHC +Kv17vVJsTwSXD5nzUjMCmYmQmWml3a/MrOCxJZRZQP4UwpQkPYJjTsyJCv9o7rx5zivT0vMyUpKS +s+QLlixZIk/Mk//0R+6nyExJUslnCx85itS0dKVClbUmRZmYnSmPSFBlyoPl4Yqk7NSEjF9s/i/e +/3cCQRB2K1Rp6RmrMrOydyTk5m3eoghNSk6JTI1WurjLZxGEA7GWCCXCiAjCkYgkoohoYh3hS8QQ +sYQf4U+sIhYQgcRqIohwJ0IID2INYUFYEyRBEfaCeoQpsZTYSTSRcjKeLCT/ZjLbRGFSKnISbRLV +iEZN15p+aToiLhS3il9TYsqW8qbKqQs0Q0+mj0CdRO+K1LBey7upSV4FaVwPThOPUrhY0BybUbh0 +TCn+O6WBNDH8QcvhfArMYEAs4ZuRmg9/kqy26tZ498Pv+2zY8918BWeo6Id6mm3/sa37RUf95mAp +/ncfL6d1QW2zpazbMhSjjPNlXtICPkvDO2vISzpo1ongLH+Jw44LHbAf9nvpAHPBcfB78IHVi0fx +PNlhb+5Nmze2xhZhy1xdwjXAgtVd7bBMCIJValip5Z20QiItxkTu6GzYoRas4vqhiroe1ZjZiRiw +fQUkeIGfO5hgmYwt9UPh27aEMN/S7B+9KXYr7AzmXn+9FFviyWuWui0KewYWYHHv2UuZBF4ILHPV ++9VWXUJwG/Z+108Uz9Ko51Tj1dqqU2eP3jvMDNCsW1HBvsN7bKNQ4rb1yxg29K3AEQRl23uhoJcc +HBbBhzDAwUgvHoECXt5rKBhTDlMS/rMJHW7qoFAn4oN4CXfonwH3sDlisOS3wU5L6rfAFKVMm3uv +oDIHKabFxn7sG68oPZ0j3V32adn+y8wi6gg27wwDe4Hn1P72Ee3GazPOyrxOBZxUnUaXp926Vtf5 +6JIqskgqgbqsJ7xTJznQJ4JjAg93mOmJZ/oF/NUgp6IvKdvV6qLPa6Td9J7Pdh/ahZikT0ouywC/ +GK/VkxijDlbtfXCkz6fHhs3lc6z5Ck98m2Yb5BH+i1cnXH0o5WlPwxx6cXvEP6SsnwY1Vjd2Mb60 +RL91XESSv2MNLnyFeD41w+A8k3cWz6IcDc5y4cOVAmdDhfgNNcK7/mBwFY+fyLtpyHodlPaJ+C8b +ucKDB9B+xKh2lVXJ4D49HHAbc8uDs7ckSzPTP1Ee/Ijpp4795U+1WsT01KfFyLJplJyTv3ovnpSf +d2Db7jUZqRtQAOPcsfaHjubKlq+kR6OrMltQOSotqj7G4NkQwKG0vTszslJSE3fFIiZIUdfcernm +Vans5fEvjtSUMkKdJkhAA5zhwA+OCjSwFQ7HVhAudqZgJS7BIVgtfkvBNIgDGxwnfmesLlb16j8Q +uE8VBMezDM741wLfhRT4Gyq3ee7emluQjKb9DhUU5R1hfOjywvIDp1E1qi0+fbLqVNnpk/VQoJdM +/W+T1Akdsg1GuAN39pzfUZvUGFzrK7TJdFdsin3xskE5OIDltz3wQYnMgyrw2JTghxjXyB6YAjYt +2qHu64m+JcY7k6WNVPMhWvBWW1XpoEm4uY38Xr2S88RnqOTmiBp/IabdQkxiL+yvwyRMf3y7ur1B +xuavekrjnXwCN3jXC1vK2PPYPMxrkeua5yAByf3nQ9LxSw2BnbBYQ/IlsJtDzz69lX8l5YVX01wh +5uz5Qp4+2GdoOjiCWV8nUBVCnlmrNiQFomgUfybt+o5z+84damKKOrlj77562I+Y3ocB7gfRwUMH +ZRM2Vd8Lxb3k0DC8eieCYHjAQR51FzWUX7l4/eqpm+gRA/ZLNXimFLcYLxdvawrFEE2/al7v5RW9 +fuGEYXSDpVFMwTBqddCosWHteDehOMtp9t2DhHW1gbZ42gLMYG/3Sv9rMbIrG9u2t6IOdKPmZgeT +TiO/wk05quzUTXnrkAKllGR9kVu298T+OuY3VPEcTShYIC16dPZC/dVbZR0ILBgheBDNpuLcEG6w +eTm2wZZRyxe5RY5bWJv2lexnHxWKQXb3CTYq6hYqMabsE0zUaKHV1YX5aumZnSUZaCszYaUvg1tn +rYjP+jBWCudoCWSM9+X77606+j2FUg6Dk0DG01DRR7EjeqWph0M/NW5EerqXhBOCDf2ot+Vgb6+h +awnsG7MVLMgYQu+vJjv7ReAsnO4xphQwRr2Nu7ydNRwVZsEcCscbxvDH/JjYkYIyYSpI9E9/MQPS +jY8Ne/HnMdBLs4++ab3f+eCiIlCKx4wbxuX9S1tWG5e8Pf0mqmmuf0JOaKw0tS3hTABiWDd/FLc9 +Pph5KjCrQ6OkblQEEaPcjBmj1Hjngk4LrjqS9xoU8en6GM5gQkUbrMXPqT83XihvRczbr4McZoWG +zPPecOVZjmwRdTysJK1i+9Wox6nPBH+c8X4UnEDu8h22i9m8W5koq4FYMdwSJKiT/Mt8hzq3G+K6 +K7ohvtuqtgs2dsEc49uGbdoD6/UrOBdv7/nzNd5vhjWa1+98vpkn8ze92xAfHhkXHxkRd6O17UZD +q4x3ecMZZII6HRQvE2QrNdgYcS4yNmmPEftaq3n9nYCVTmCjxrENba1GrCSrkq8og/DjkZWUdtLA +ZO3nZmYDxWbmBPEfzdNoygplbmRzdHJlYW0KZW5kb2JqCjIwIDAgb2JqCjw8L1R5cGUvRm9udERl +c2NyaXB0b3IvRm9udE5hbWUvRFBYWU5KK1N5bWJvbC9Gb250QkJveFswIDAgNDEwIDUxOF0vRmxh +Z3MgNjU1NDAKL0FzY2VudCA1MTgKL0NhcEhlaWdodCA1MTgKL0Rlc2NlbnQgMAovSXRhbGljQW5n +bGUgMAovU3RlbVYgNjEKL01pc3NpbmdXaWR0aCAyNTAKL0NoYXJTZXQoL2J1bGxldCkvRm9udEZp +bGUzIDg2IDAgUj4+CmVuZG9iagolQmVnaW5SZXNvdXJjZTogZmlsZSAoUERGIEZvbnRGaWxlIG9i +al84NikKODYgMCBvYmoKPDwvRmlsdGVyL0ZsYXRlRGVjb2RlCi9TdWJ0eXBlL1R5cGUxQy9MZW5n +dGggMTkwPj5zdHJlYW0KeJxjZGBhYmBkZGQPrsxNys8BMfV+SDP+kGH6IcPc3f1D78csVlkGn3mz +eX/I8jB08zB387BM/p4j9N1N8Lsz/3cHAQZmRkYVs+TQoHCF4Py0kvLEolQdBef8gsqizPSMEgVD +S0tzhaRKBaB8cEliXkpiUYoCxKpiBR+EMiK0MzAwMG5nYChhYGJkZFH83sf3I+FH23zG77U/Zomq +Wlmrq962ev/+9u2P763vaMnz/TSdz9bN1c3NwAAABXJLTwplbmRzdHJlYW0KZW5kb2JqCjkgMCBv +YmoKPDwvVHlwZS9Gb250RGVzY3JpcHRvci9Gb250TmFtZS9FRFdMS1IrVmVyZGFuYS9Gb250QkJv +eFswIC0xODAgODc1IDc1OV0vRmxhZ3MgMTMxMDc2Ci9Bc2NlbnQgNzU5Ci9DYXBIZWlnaHQgNzQw +Ci9EZXNjZW50IC0xODAKL0l0YWxpY0FuZ2xlIDAKL1N0ZW1WIDEzMQovTWlzc2luZ1dpZHRoIDEw +MDAKL1hIZWlnaHQgNTU4Ci9Gb250RmlsZTIgODcgMCBSPj4KZW5kb2JqCiVCZWdpblJlc291cmNl +OiBmaWxlIChQREYgRm9udEZpbGUgb2JqXzg3KQo4NyAwIG9iago8PC9GaWx0ZXIvRmxhdGVEZWNv +ZGUKL0xlbmd0aDEgMTMyNjQvTGVuZ3RoIDc2MjA+PnN0cmVhbQp4nO17eXgb1bn3OWcWzYyWkWRJ +tuXYkizvkqPEtuQocdDEW7wkOItt7ATFS5zgmIQ4CyHb0+SWZqVkgQJhX0sKt0+jOCHYIYUAt5Sl +9JJyobe03EILKfQSSIFLaRLL33uOJCcp+frd+zzfP9/3MJNz5j3LjM78zu9dzhkHYYSQEW1FHJrT +Mj9Qhtgx+WXI2hev6BlMlCdVIYRvWLxurXvWIzMIVPwOygeWDl634rFfrpiLEFkL6fh1yzcsTfSX +4D73gv4lPX3v3LTkGELlB6Ay1A8VaqH+IELCJCjn9a9Yuz7Rv8wNz+tYvnJxT6Jc9AuEdIMretYP +ipW8Bfq3QqX7hp4VS5Lj+zFkmYMr16xNlMvpc9yDq5cMSoOfadCfjueCmCPahLPCKX4zH+XeRWaE +xv409n58fbwv3sn9ALngnjvRk2gEvYR+iVLHCfQCu65DQ+gkeg1devwT+gF6HP0CvYM+G687gB5A +/4xil/Xbx2ofQ0+gn6Aj6Dh6Eep2ov1Q+0P040v6rUQ70F50L3oIvYmzk3UvEhtOjOBjZCCn8Bq8 +BzmRH9Wia9Ea9B20Hcb1Mp4FddOhbg7Urkbr0W1QO4JeRt88pqN2FEUD6AZ0GHo8z+pKoLYV9UEt +rUscq9BGtAs9jA6iZ2BcG2Fk+9E9V3jePxEP8aC16EO481V8B3kJ3ugg2ibakAK4n6Ko8lGGLRp7 +H6F439h/IcT1ki/JI2Q/OkQG0CzN3tZaGSoLTCz1F+S7bGlWi9Eg8MTvjnH5dd46b0//bnddv3u3 +t7a7ttTfPK+jrjbL4+ks9buhutYdw93uulj9uv6M3XW0Q8zqi5H8OpoGYtot3SB4az0eD7SkXWwZ +Hjv5/Uua3MtiWk8M3eI+7D+5+/vDZtTb7TP0eft6ru2IcT3wW4cRDKa/tYOOiabufneMh7tZlgU1 +ySHStv5uyL21cNcV66FarunY4TmZFbPCtS5m8cVmQo+ZGz/I4nbXZSxz0+Lu3TvcsYfmdlza6qF5 +Z2dnxmUw1Hvru3fvrve663d37+4ZHtva63WbvbsPNzfvHqzrdsfQnI4Yhvrjt2TF6r/fGTN39+Op +8Mr0PerndUSyPBZ4isdD3/eWYQ31QiG2dW5HouxGvVlDSAv4OmOkm7acTLXY22jL1lTL+O3dXoZ1 +TQeXReDBzfO9zXMXdLjrdncnB5ysmZIoHSao+rAX75x7WMM75y/oGAHFdO9s7RgimNR0V3cezoO2 +jhEwCRqrJbSWVtKCmxZQMwY4hojE+meNgMZvZa08q2DlxcMYsTopVYfR4mGSqDOn6gjU8Yk6jdXR +A16G1LR2XDpqSHTsQGqwl5I+Pg8hg//89tFV+ttpzWVHO63hngat1KHrkQC/YUYBqEVEGRsDO4tH +UOvYSS1nqLgsZB5yD2lDc4YGh7YOPTQUG3pj6L0h5eTQ2SECfNUGn0rPCLlqsdruaictbV1tZGUr +frD1UCuZOz+dnzffwc+fZ+ebGufx9Y2V/MzGMr4BUmMwzFdFyvjpken8VREPXxPJ5qsj8/gZkDRI +kWAZX1bex5cHK/hgRStfEczh36h4r+JsBTc89umRo/kNoeGx944cNXvh+qlmPCqroaPOBn7dke1H +YFhnjxxhPc5pY0fkvNARWwO/a2caP7h8cD1R7/v9A0S735EZ0u5zZIW0u9JBujM9K7R9W5pL/Z66 +Td2j7lX3ub7n2uPaG9izddvWnXv379u2b8e+nar2XdkcUle7VhNtlWwIqSuw+2Xs/jmOvPTZS8T9 +M+1nBPVi1GvuJVrPQz1EXYhLbRbeb8vnfbYwX2JL44ttdt5ly+E97hrebaviX3HW8c6smXyWs4p3 +2sp4O/RLg+FabU7eAmnQhjXbjJqQaipxIREbX2x2GV5odiknm10yJOFEs4v/abOLG2l2kePNLnys +2YWebna9+EKJ6+RzJa6fau0nPK7jIx7X08c8rhde/BfjcyefN5746bOGkePPGI49PWwwn9h6gmgj +W0eIeixyrOXYlmO8eiwA4koQnzv2r8fGjkmKXMkbjATsH0cIRmSOgIfxGI5Zm1Fza3UsDcN1fvVh +uczXHOubV73t1luzY3cC+2NbszuHJegDuh7DezpjUvP8pIh89Fizds0a3xWOGFcXE+v6e2Kit3YN +LZhowQQWx1QXU6msemt9OGar64/ZQPrGQ9akDt+aZGPih1iGbrzSb9KxrIUc2glVFx0SQUXgYnta +JDyiKfD6u6+zbPIkj8VjyYcMQ69zWwV0nl4RCFT7bo/vIRHwlhwKagVOXIJ9JIjCpA41kDbUSfrA +Nf2MMxDCtfPgiYgTzEcgWh5A5i/LApMn4aiMvWkkEj99209w9ugqspc+824ymZPJaXimW7PhahUM +kSq0oBahC3UJ8LMkUB6IokD0DDzAE/Rw8ug+MkgmPwUtaNfY+/xe4TOkR170hJYbwmF9hWGadVpG +RU4dbtTXGpqtzRm1OQZ7o0w8jZyiDo99fVSvr24D4cJRg4EJXx4zGEib6kGgXkdVFd4E6rRCvR6k +DNqEHshX8135JEuit2bx9L4sA23J8ohwk5ZG7xLNsgy5gd4nHsgzfwXQn4EUHZdQ5EwE3iKKzcTj +Jhaz1eO24lAoWFFQWFDgzRV1omi3OdIdjvKyEL/3fPzr+Jd/PYdlbPhr/G/ezMw874auRZvycjMd +eZ4NfYs2k4/jK+O78Ga8G9+KN8W3XHhq7m/vOfDe1bOvvrql6dM99/1q/tXzrgaEsQPmokp4G6no +uJZpZC9hYrnRTF/FxHKeImI0VreBHbqghakk1IuigTNxDVhSLS4LEYhLxapqMLF3NxkNBrHN5CYR +biU3yHGcwWwm9O73ND3Fg3NQPDiKZTbFhMuhd3Gi0Qi52WgUIadP4AIpokbLAaVwWSAaKI+iyGhZ +pDxAJz3R6IG5t3iCZaHKUKiy3OLhqy68g0PxVyP78icG+XvxpAPc6Z12W+bsGedeAFY9DO+8XziL +3GhUmzvH1e0iAidaHJzdkmeZJkwxBk2R7EhO2NUsNBjrTC3ZLTmNri4uykeFhXK7pStzUVZ0Qld2 +V84A1ycusfTaV+YMkrWWLc4tE7bk5MNLfXSUjh0s8kfaZCoh1ayWSoEJk1RNFVWNMUozwEtSGWim +6pvSCHE1YclFpBQLJQp1Jm2XPA4DBc1hoKA5eAqYg0KXSZ/kcNCfcDjcD+Squa5cAkDf7TF/BUjR +jMEDyFnDDLQz5bQmOnkSZDgKsIUoZEAyyjAvlMqpMaZko/88/P4L5mVvLjy55+5dC/9tiTLzzMoP +Me8rKVzWfP0HiznPqQVHO4//dsvam7XqX3mnvvvTtturr1rfuOxnrYDxQdC+zYDxdPQHrUOvFwJO +vT1QrC8IFFdV6YO2ybkVgSZ9na0mtybQjjuFTn1bYEC/NDBQtV6/LrA2uKnKWTG1diqZNhWwx6WW +UlJaWtzkkicT1egyEqPR0iQr3hRWXorVBIqV11PJCFjJUypVihSbypyJjlRPB+2ZR3s6PNzEnKlg +4jkn456B8e2hiBpxRYjhnqvMp6Pm0z6fJT1sBvwCgUACSEQxjEasYXoJjIbDUaq0DkcCNW9uQWGw +nClp5bjyeoNQvKjICZipKtN77A4Hb5p0VVNN82sbNp+drbadvj6yxz+xtLy0dGvTgvoDT00s9vVe +1fV2F0V/xeM1DU2Hbpq0mbzu++51S5+M1NdM856a0lRS7B+YO2dZjiv98S0bQ3OdTlvtVae804r8 +k3Yu3DySYZLKwR7OBtYfgXWAgoy4QlsmMS2XWY5ZTlguMY2XWY5ZTlgu8VTtZZZjlhOW80abMc9Y +Yaw1DhpFQwZF0WBsAPYYRJ1sbMQCjZcyabUgcDqOkyJKi0IUVXWpRGcAy/LlUYo/CF9oJtqNdyuy +UWwRMR4e+0DTU7ZjhXaB8rmjdFoxjX7KaF+MVdElRkROLKAGRiTM2GZcYmwZG0Q2LDGQMiVMiFrD +5cyohKPgQyIwpQFf1WiZNRwGu7LDPMqf9OHopb4Sey1esDK43FLusWD+yLsnRyvJqeF344tHn8OP +xqP40dNcw4XV5KHRbuq7ngEN2AZ4l6BXtDYPwyqX5YrklHzSdClome5olmotC6TW4gFpo2TIznY2 +Umei5XP5Gu2Z72nKF3OIqrgAMcXUJCruXEkPk5HrbsnG2cNjn2gZ9C2zHfQts00UnGxmOLNtKcbb +KOOz6AzaPMidLSPWFz3oV/0uP5Hv9SWIbgkneM6QOeMLXOR5wBcdpR46CsYW/+9ZDsy2eOweS4rc +/LZZ1Q0/v3njH642zfvdwMxtFf7SYKDijms7Hp3GbR2d4Vvg2XBs1pwO/Jv+Z2fUN5fnvVnRWFTm +W98ye8Bd4MowkLFD8bU8X1xR+ZOkLz8onEG5qBINa+Wi0WEM55dPLq9szK+eXFPZhduNc9xzPEs8 +N042Obnixuy0tPSmbE4lQXDsTn/AermpUBKmAlllcOefXvTrjGyIUQZRcLMooOi+sBp2hUmAqUeA +efiAR6axAb1RPjAFnPgZ6stPU/AsCRyBRtSlW8OAXeCMNUzxsyGKXAEJVlgrQ3kUJruXIod0KdB0 +V3T3B+Nv/eaGo3Xt0bZoB3aMTJtTrExYNe3XY8je+uj1XftndXS+VhmZODi97bbZhMwIT7w+sv9x +/Mc/xt+vrZmPrc+/hMtuWrVFMT6nZsW/+LA86A1OP35rdGOp21ZU4ih2PfB00F98mDL2HrAQdwBj +RXTDCOIAMKb9w0kBHNt5LcSMBlZIHm7AzaSDbACdxgi7Ia6DoItrEjgiqZJL2kQ4DhHCq3TNxdMw +DfTLGqaKNmoJB5iKndlxElNW+TD20vCNv2N00dvk9Qsx7jz/+XmTkHuIxqIbx/6Dv0/4AmWiIlSJ +rx5BBWAyjIB8/nBSyEsJ3pSQS2ezjUqlvgp7eW5FYUV5rX1Gbm1hXfkc+8LMBVkLXK25Xb5Of9fk +1vLWym6p19Rr7c3s9nYXrjOts27yb7dmi+SJgscDpMChBHgue6aZBBuATCkiOSmRzAbQUqcbpeG0 +NBRQjMWp1mLaWkhhK/YgR4E7qXX3J6jkZlRy8/Rut8dIB5tOuWQ0lrGWMkayMo94F3AL2AQGixHs +g5SawsVSHlh1Jhk3WtPDUVgXazmd/l1+Uuwv44KB4kDIW+dt9/Z57y4QnW4vV5Btof1Y1gl0TNg0 +ysm8YEWoMlhQEKzIS/p/8EocCwoSJEwPhdIYMwsZLSkn74u/+cHn8ff33bx+Dba99XusfGfj939w +5odbv/Pw3Hn5t1QvnuWauy4wGF2w4vje2w7hB58fQ+de3PzKNFE7sPpH7739wyUvVopVMdJy/Zb1 +SxuWFVunplXvGV1z7copjoLcyT8a2BG7E7R+1dgfWQRPtf6gViHxmXwxX5Vf5QtOnJU/y1czsYPv +So9mzMsaxJvyVUt2WaOtuNEmZidtZdAiX1ntZSfT9gDTe3Miik9MjJ/B72fw+z1OFrU7edrDeSdV +83E9T2p5mIVVAWYmU0pOdCJ/0UJaKxP2kqKLmJJbx5V8XMPBivJ7OxcsjH86UnFtnpI9MOPd87bo +Yz3X3tHc0Yn9/758uK7t2le1KYHlkX0HQ1rp8uqrH6rHHFf9YvyFwdWb9QZQbSx/PGVSXsX0Ezd/ +gHNqaubHzz9274mK0sKjj3atL3XZS4rsxXRV5ERIWAQ6roM44N80Mw17wIezXJOps/6aBa9iStBR +pNZRqUms0xFZViSyA2PgjQ7JCreDx7xNEMTN4hod4SoUjbphRaN2c5KiKYMKp8iKyOGNAhYk1YAh +JuAEA8pDYVSNFqABWBTqELrBAE2K4BNCwmyhTVgibBJ0Qp8ePBMEsWA50qndiFZFwuEA0JbG/VFw +0NGTJ08mLtJJ5qkRNSYeL+fhwJykYSwsevO20c23vUJysLQ5fj5+Dj8Y7xFOXVhPfjuaD5blZcDC +B1jYYTzleJpmFQx2Q6GhjbTbt2SKVou/IocGL2bKk5wcXXaFxJVW6CQaTGoyiybtVr867jhUN4vs +h8c+12wUALWALmRoLeSqLj+1rMyn9xvp/fl2xBZGQMfTKS/00dGk+/mcxTogfHCUPoc2ablsObEq +qAa1IMkZZyuYEb9NZ6KP0tFfoaMB4Z3EYksnURrrqKejjwbhz+zRIPyFPZoKx9hkL69gC1J2jPp8 +ZdFUkS0hEvETcD1pdaDiDIuWosm4ABZhlwa2OBn/Qi2leMKEsE60KPhaZ7a+cu/oWTzy6CNN85qW +L7jrJ/EjeUWB7Ys/wSh6QyBQuCU0c9Ku3vgrWPzu48EpFfjVlU9WVk8RTmUU+HYsGrijVHK9RvhQ +U3qWMT4vLSena/SeBQP5mero21l5hX3Uo60Z+1CoFz6BGOwW7QYBG2XR5sBZss2ebw/Za2wLpQ6l +w7TQvLCom+uxDZJ16qAtzeFwVlhJSUlBhag40CqIkzANlQL+iH+lXxg33TCRbrvBQEsGiZYMNgq7 +YQIF29DvSyBH7QWAWMXCKZooWvliIorKu0IscJnnrywX6is7G6bvbX8k/tfe7uX9vV3Y+Nj6z25T +N32+e9VTM+tmt9XUP9O/99wK0/KMkvS0rIU9XTj/hWGc29ezdGrjf163qHF284d33v+HmU0ze3tB ++ynjh4DxJpSN3tLsYWujdRnpN/IOoHY6UHsdwnQbREtj+yB2pDB2iiwsGh77w3ikdJS+JKJESpL1 +Sy2fkXStS3UFXBqsqfl0hlQ6Y2f6/x125lxk55nU5gmTo8ntE5ywvwkm8hdtrdeSsLLC0OHbl55/ +Pb4Tr30H484DT/7rxg0dL+0+fnzvW50rV5I/vRY/tjACBItUdsX/5e1DZ+vKCs/fXBKe+RFwCbDj +7wfs9OiBp+UgEs0iEal5mMTWHCIWgoRTgljikYQltMaoGrGYWF7JDAPZhhkGOIUBHscAMwxwCgOc +wgCEjxkGVGAY4OWGb2hoVbRqXB9XAQgeDwvEWeLvv+Dj3rrwF06lSTgVi/fHRn+deBvhK3gbA96q +Xdeu4ClkihBSVpJubqXQrWwhg9wWYVDRt8ntygI918et5W4Ey60QThYJIjzbuOB72QKQ2Xxeo6/A +M8uPeDNfy7fycOj0ModhihU9JxBmAI3JkJKtOOlmtZEiQGwoJ2kJv9S6EmF4wj0zprH1H3Kyh2cw +orHlOlpvUk0u0xwTJzAVFNj6SmCgC2y3RGDBvMCz9Weazvw/J+GfUyT8NElC42Uk9PkuIWKixpIO +UUFVpMrKvBUcEJodreAHeBLtBHGoj8fRTvBplK6rUXS1x2uB+JeuLTH2CF+9FO9dF18ygk34VrwV +pwnchbu4ZedGwW+9yE2HmdsONo2ATZuEq0dQAHSRvlPpcFKYSAF8gEoZjG3pLHew3M6cjY0pNcyL +C3mzJJurWCrKyHPlBcJSyDwlLegKlTRJdebGtDpXU2FtSQdpy2pztZVen7k0a4lrqa87sMkx6Bp0 +ry1ZW7rd6pU1k7lSohnQwuIs4rNFjye/goVgYD89RWwuipi5LLI72bYfRM5nn6LoOi0pIlhoeKan +nSx25HHKzCEmbcxZTWWzv7ZMLRssI/LA5NTWzPiSlebjFpYGuDQYtndYrinqt1xXtMGyrmiXZXvR +XZa7ixQa+sKMja/pbSlTDOEaP75PU5gKhqlVzrsYBzscApnbOOetOx+Oj20zrcJF3x1+vWdx86He +l57DVV/cj8Ulprb4f+5/8PnuDdon8x7/EX7imienaQ1V075etHT3msWLnDanreS1R5/5rMr/54au +7/VHByaYiuz+IeqrakEjpzD78iFdfY0m8BA4muuHofww25hh5RvxRh1ReEFx8nbFz3uVSnk2X610 +cF18h3CNPEe5Rt/PreD7hevkbuU6/SZ+jZKut8GPyDZJJ3E2golgAy8k8Dqs6EUi0VUb2CviIAUk +RGYSQZYypWIpLDVIApF0CoR5IjEiBypAITQTzYE14lKjJIuZYrEYFhvELlEUl4JpipbRBBoQCESj +bFclPZxc66X+QZTG4JeJl677cDkEalNG4wR/GB+Id/870cWFD/B+fI9watQ9qpIlo/eSj8jHo4+S +KEVJBCt8GlCSsGUE8Un6cCkegUH+G9uollICnzI6bOu6m4VK2M8X6YI6DWu8ppuj6+cHdYpDzJQK +xSKpXeyUlogDkiRRuESbwAsEGSFhxCMdx4Mx4wlb5CoupUXZovBoIdZhnhlwG0+dJDOHKVMCQpy5 +TZ6GdsxG0k8JlP58Yj9LZILGDBq/sEXYAtqdsj9CwBf9cty0hM0fJCGNJkJgCieOsrCXkZkaEYon +f3r0y5dGP/8tvgvfC3bjxOgasp7rHF1K7oEYoH/sfT6bXw8zWY5/OYJyksv7bKpp1SyQUXhvpmL3 +8j4rHZOf5aUs7zTNzbnWv8zUnb2ydJOy0TaYvcmvEKlo+iSLZiEWi1uaMDz2qpZOH9MyAU+YkBFx +85NnSAqWVLZh9dXT7LcshcwHGP/OGZxNcD7IfAlJxRkktUdIBY1tdxMnytaDC6Yew5qMTk5rFuYx +2O5f0lckQm4msC8P4DLYezA3Y5dlujfP3Ml+CKldwUiQm5gYV9KQZtJbJkr0lonMt0xk228Ts/R0 +ymqYIWX7jHqJ3qNnwZ/ewGSR/rDeQX9Ez/ah9Qr9KT1ba+lZ4Kjfdkm8Pe5PkhtJiQMWmqNJsaws +QAMd6urLwbNYqH9JLDrp3EcRXfsEk6FlAV3Sh/Iqr7jtzFnEZJhJV/LZz2S2FQU2zrvrVyuWLMU5 +j5WWFA1ObzrWo1S+sWTdIS1S/Uz7x7Vz+9betPixmyzTremul+/dcn9pqVvK1loz0s2F+c+peYWB +ibctj2fjSsGWlt7T1t0zm+rqsrE/cV/wNyEP+r02S/W2eIkP55pKHHkZU3HQNNURzGjELUqtqcUx +I6MTt5mW4SWmjXiNKc1stkUMvMfjjHCy6mXxhZd9Nhnfm/uPo2zyQNDmsQm81ZvOJiiduZpk7Mmm +ID1LltjWNYNcZpsAMpsuWaLtMptAmbkmWaSPlYEDx+hT5W25l8wPm51k+dKAPsoi+uQi34wuieUT +CLOPUtwXi57o2vBqQ+McXPrX7pHZSvvT1zw08tRj4XWB4ga7Ul9aNrOh4Xe3YyueEio8VdPw6zde +/U1Ohj1gARxHwOZ1iTbkwEu1NM7usN9o58xGqTqNN2FslC5VpbMX9+ySOvVNHfqaYUcSHzeZLlFz +k4y+LmgWpk880yVD0gdfSDnjuKZnipWb0qqjTKmoNtSzGWEf/pCSUKoMV0Z3BjHrGf569hlBz2ZG +b0goClMRiakIs396p5HOLR2LcfxjoZF1NlKLSn8bhK/Yq4Dw54RSG9kjjHTFQJ9CBTZ/xp3pl8zf +uB5Fr6B0dCetKhJJ6BNEZBc3tWHtkNjUtvNdJ6wZmYuaZ/9o9okTHScWP/Us2Tx7R0FJ8axpF54V +baOvN8575/XEfHGr+SiyolOaDRnNRreRM8gqzGKNooJnvXS5f1abygBFNs02aCMGHcNHxxDTMcR0 +7PV1DCsd46eOYaVzyims5HGsZNZZTkEk0y8lFsb1PAqUrKT4zYAC4W8Jou9MuyJQFvqpBExO1WgZ +xFVsf8t7ERZ7wqJwq5WSltA1jzSfODH4z52T/X5unyLPnn7hT3z0hwuaBR372xvXPzwb0XXsPIfX +QgDyGXeQny0goRkCi88vP3XrpWXSX+S98leXn8qbF0/9c6nTMM/wxeWnqQjOX6RO9bFvnubSb89v +z2/Pb89vz2/P/zdPRL/0JP761YY4esFOSLB2Rtyk2rb65izVnmZzTjBn5DmK0vMLMwtCVdOu8Cfl +/x8ePGplOU/xOescG4Mc05wt8On35kmoFrWhetSMspCK7CgNMHSiCciMMlAecqAilI7yUSHKZHsh +VSgBHIZojyD6PzBE+kWrfcnqvp4behItCO9DApL+myP8u35n0dmxyypwqhseT+QN9D9LH6PbuUfQ +3akkONAuwYEdcH0Y0kFIsyE9k6hH90DaCGnVP0zrkVPYjF4W7kRrxBK4qv84ic9eOcFztn8jbUK1 +/CdI/Ifpl6ifJR9a9vdJMKOR/07iBiB25/4P80PxFwyvH44dOt6lVv0XykpM2JPfqS2m11d+/MrP +z28fvV1/u9QPRZlxAo7/BTw7yqkKZW5kc3RyZWFtCmVuZG9iagoxMSAwIG9iago8PC9UeXBlL0Zv +bnREZXNjcmlwdG9yL0ZvbnROYW1lL0xXV0dLTStDYWxpYnJpL0ZvbnRCQm94Wy04NyAtMTc4IDg1 +OSA3MTddL0ZsYWdzIDQKL0FzY2VudCA3MTcKL0NhcEhlaWdodCA3MTcKL0Rlc2NlbnQgLTE3OAov +SXRhbGljQW5nbGUgMAovU3RlbVYgMTI4Ci9NaXNzaW5nV2lkdGggNTA2Ci9Gb250RmlsZTIgODgg +MCBSPj4KZW5kb2JqCiVCZWdpblJlc291cmNlOiBmaWxlIChQREYgRm9udEZpbGUgb2JqXzg4KQo4 +OCAwIG9iago8PC9GaWx0ZXIvRmxhdGVEZWNvZGUKL0xlbmd0aDEgNDc4OTIvTGVuZ3RoIDIwNzU0 +Pj5zdHJlYW0KeJzUvQd4XMXVNz5z7/Z67/aibVrtrlYradW7pbV6tS3JsiXbcu+4F2xsYxtMNRA6 +CZ00E3ACkmxj2UAwiVNIYgLEQCqBNwVCYgIpdK2+M3fuSHIh7/s9z/953v8n6+zvN3PL3jlz5syZ +cmWEEUJGtB/xaNbM3mQRkn4eWwcfc5atX7KJph89jRA+uOzybcGh+0+/Ahm/RUiZsXLTqvUffthl +AP4xQlrPqnVXrKTnF8P1c7jVK5Ys/6dlzI7QSTgfla2GDON3LGsRMtsgnbV6/bad8vfB/YWP121c +toSmb4Tv9c9ev2TnplBnNA7nV0BmcMOS9Svk82fBh3vTxq3baPrkM+T4pi0rNn302bIX4Px+uD18 +h/ohhNJ3oqk/s9BatBXKux9dh25Bd6Ln0G/QUnQA2L3oEXQIPYaG0PPoBfQ6+v/wJ32Fcj0y8MeR +ClkRGv90/Fz6EMio0jQl505IWRXByZxxYfy9C/LeS985LqRHVRakk641cq9A7j/x2PinXB1Jj5eR +NHc9cLN0xQfqh9JPph+9QAfdaB6ajxagQbQYLYHyL0er0RrQzGVoHVqPNkipDXBsFXyuhNQiOGsZ +nEX45Fkb0SaQLWgb2o4uh3+bgG+VU+TYZim9He2AfzvRFWgX2o32oCvlzx1Szh44sktK7wTZi/ZB +zVyFrpYYQ5pzAF2DroVaux7dgG78j6kbJ9hBdBO6Ger5S+jWL+S3nJe6Df7dju4Ae7gL3Y3uQV8B +u7gfPXBB7pel/PvQQ+hhsBly7G7IeVhi5Ogz6IfoGHoCPYmeknS5DLRGNcL0slLS4SbQwR4o4YEp +T0z1t2NCW3uh7KRsB+WS7oT8q6dccbmsR3LmATiT3oXWA7nLlRdo4jYoA+WTJaKpu6XyT+ZO1cp/ +ymX6eGCKZu6XUoRdmPtF/B70ILTAr8In0SphXwNO2cMSn5r/0MS5j0jpr6NvoG9CXTwqMYY05xDw +R9G3oG0/jg6jb8O/ST6VUXwCfUequSE0jEbQEXQUavIpdByNSvn/6dil8o/I+SMTOSfQSfQ0WMh3 +0SnwNN+DfyznWch7Ts49LeXR9PfQ9yFNzqKpH6IfgYf6Cfop+hn6OfoBpF6UPn8MqZfQK+gX6HVs +BPYy+gt8jqGXlH9EJjQd/PRJ0PMDaCFamGpZvmjh4IL58wb6+2b39nTPmjmjq7Ojva21pbmpsaF+ +eqqudlpNdVVlRXlZaTI/Lzc7GskKZwZcNlEwG/U6rUatUip4DqPcpnDz4uBQdPGQIhpubc0j6fAS +yFgyJWPxUBCyms8/Zyi4WDoteP6ZKThz5QVnpuiZqYkzsRCsQTV5ucGmcHDoTGM4OIrndfcDv6Ux +PBAcOifxLokrolLCCIlQCK4INrlWNwaH8OJg01Dz5asPNi1uhPsN63UN4YYVurxcNKzTA9UDG8oO +bxrG2bVYIlx2U9UwhzRG8rVDfKRpyfKhWd39TY3eUGhAykMN0r2GVA1DaulewTXkmdFNweHcUwdv +HhXQ0sUJw/Lw8iUL+of4JXDRQb7p4MHrh8TEUDzcOBTf9UcXFHnFUG64sWkoEYabdfRMfAEeUkaE +cPDgvxE8fPjc387PWSLnqCLCvxGhpIgTaoLjjCN4NnhCKF8oRJ7lptEUWgqJof3d/TQdREu9IyiV +TAwMcYvJkVPsiL2PHNnPjkxcvjgcIlXVtFj+vXy1a2j/0mBeLmhf+o3ALxwPDvHRxUuXrSa4ZMXB +cGMj1dvs/qFUI5DUErmsTcMFSTh/yWIoxBqihu7+oWR405AtXE9PgIwgqYM1vf3SJfJlQ7aGIbR4 +mXzVULKpkTxXsOng4kb6gORe4e7+E6h4/M3hkqD3SDEqQQPkOYYcDVAp0aaD/ctXDgUWe5eDfa4M +9ntDQ6kBUN9AuH/FAKmlsDAUfxO+LiR9o3QVlO2Cs9nJpOTqiCbYz3n5AVJbkBFsho9wfQ0cEKC6 +pCSp0fqaYD/2InYafIt8BmHn3QcSfKShlRziyaUNrd7QQIj+/IdH8srPpIwMaabcS4CMiWei3/OF +j0bPJg8UDzataJzygOfdVCk/oHy3Sz8nR3QhfzFcoSHV2coO8RFouZDHwW2kLFKLruAQmhXsD68I +D4TBhlKz+knZiK6l+u3oDXd0z+uXalu2ktnnpejxCpoaQiE4zBJcA9hgc8LLqlVKt0jpiWTrBYfb +2OHgQU24o/cguXlYviEKQguCQquibUtuqrCUQNNsBu8Wbl4SDgrB5oNLRsf3Lz04nEod3NS0eHUV +uUe4bfnBcG9/jVd61p7+K727yFdZUAfumF2flwu+p344jG/oHk7hG3rn9Z8QIOa9YXb/CIe5hsX1 +A8NZcKz/RBChlJTLkVySSRJBkiB36oGERjrfeyKF0H7pqELKkNLLRjGS8jQsD6NloxzNE1geB3kK +mpeS8sgPVJJrNagY3G1TcDmpnj0Dqw8uHiCNCzmgKuEXD+FwLRriwrXDmFMZhnThFfVD+nA9ya8j ++XU0X0Xy1WAY2IFBOcQnHVwcBj8FBtWPvJiaIk9uGRwdH5/dHzrjPTcQAlNbADKvf0ibAN+vjLTD +eS1EFkN2y9D+ZUvIc6C+fnKtOtK2bADMlt0QTmkb0sIdtPId4Ixm6RpijnDRMqgbqEDp+v2QGNo/ +MDSQIF/av2ZAMmdhCLWGq6Da6T2VUfJFyYGDlnCR1DahKegi1xPQwrOh3n6a44UkfNkAVZLaAE++ +LAyHli0OgrYVaFkvmDr1pTovzVkBLlERXSGJzisfRKRYfERv1A1p8+GG8Eu4Pp80SWVEPTBAH15K +XS+fAN8tDOnhiaJTVClfANqBQ23kWeD3enhUcurz5Dbdo6gnvBM8C3lo6U5qODxkjLQtAedPr9dD +TriCXawhPkIv3+M0zVWTkhtA73xk9uj4o+ErQlN+8nLDpHMghom8J8Cw0cDBCzOG5ifycjUX5hql +7IMHNcZLX0D1pTFOIMkMNkGvASfCmFiF0gif1j3y2aefPqL9G8mZ+qOoJTnmOA4iAWIzNbQHASUR +jE7FO8bHoXbwiJYPjnLXHNW6cDuQA4xczchVjOxnZB8jexm5kpE9jOxmZBcjVzCyk5EdjFzOyHZG +tjGylZHNjGxiZCMjGxhZz8g6Ri5jZC0jaxhZzcgqRlYysoKR5YwsY2QpI0sYWczIIkYWMjLIyAJG +5jMyj5EBRvoZmcvIHEb6GJnNSC8jPYx0MzKLkZmMzGCki5FORjoYaWekjZFWRloYaWakiZFGRhoY +qWdkOiMpRuoYqWVkGiM1jFQzUsVIJSMVjJQzUsZIKSMljBQzUsRIISMFjCQZyWckj5FcRhKM5DAS +ZySbkRgjUUYijGQxEmYkk5EQI0FGAoz4GfExksGIlxEPI25GXIw4GXEwYmfExoiVEQsjIiMCI2ZG +TIwYGTEwomdEx4iWEQ0jakZUjCgZUTDCM8IxghlBMsHjjKQZGWPkc0Y+Y+RTRj5h5GNGPmLkQ0b+ +zci/GPknI/9g5ANG3mfk74y8x8g5Rv7GyF8ZeZeRvzDyDiNvM/JnRv7EyB8Z+QMj/8XIW4y8ycjv +GXmDkd8x8ltGfsPIrxn5FSO/ZOR1Rl5j5FVGzjLyC0ZeYeRlRl5i5OeMvMjIGUZ+xshPGfkJIy8w +8mNGfsTIDxn5ASOnGfk+I99j5HlGTjHyHCPfZeRZRp5h5GlGTjJygpFRRo4z8hQjxxg5ysgRRkYY +GWZkiJEnGXmCke8w8m1GDjPyOCOPMfItRh5l5BAj32TkG4x8nZGvMfJVRh5h5GFGHmLkQUYeYOR+ +Ru5j5F5GvsLIlxm5h5G7GbmLkTsZuYOR2xm5jZFbGfkSI7cwcjMjNzFykJEbGbmBkesZuY6Raxlh +YQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ9mYQ/ewgiL +fzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCL +fzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzCLfzALezALezALezCLdjCLdjCLdjCL +djCLdjCLdjCLdjCLdjCLdnDDEUIgah7x1wYgZh7x2wGupqmrRvxVAPtpah+FvSN+A8CVNLWHwm4K +uyhcMeKbDrBzxNcAsIPC5RS202PbaGorhS00c/OIrx5gE4WNFDbQU9ZTWEfhspGMJoC1FNZQWE1h +FYWVIxmNACtoajmFZRSWUlhCYTGFRRQW0usGaWoBhfkU5lEYoNBPYS6FORT6KMym0Euhh0I3hVkU +ZlKYQaGLQieFDgrtI942gDYKrSPedoAWCs0j3g6AphFvJ0AjhQYK9fTYdHpdikIdva6WwjQKNfTM +agpV9PJKChUUyimUUSilNyuhUEzvUkShkEIBvVmSQj69Lo9CLoUEhRwKcQrZFGL01lEKEXrPLAph +Cpn01iEKQXpdgIKfgo9CBgUvBc+IZwaAm4JrxDMTwEnBQTPtFGw000rBQkGkxwQKZpppomCkYKDH +9BR0FLT0mIaCmoJqxD0LQDni7gZQUOBpJkdTmAKSAI9TSEun4DGa+pzCZxQ+pcc+oamPKXxE4UMK +/x5xzQb414irF+CfNPUPCh9QeJ8e+ztNvUfhHIW/0WN/pfAuzfwLhXcovE3hz/SUP9HUH2nqDzT1 +XxTeovAmPfZ7Cm/QzN9R+C2F31D4NT3lVzT1SwqvjzjnArw24pwD8CqFszTzFxReofAyhZfoKT+n +8CLNPEPhZxR+SuEn9JQXKPyYZv6Iwg8p/IDCaQrfp2d+j6aep3CKwnP02HcpPEszn6HwNIWTFE5Q +GKVnHqeppygco3CUwpERRx3AyIhjPsAwhSEKT1J4gsJ3KHybwmEKj484wF/jx+hdvkXhUXrsEIVv +UvgGha9T+BqFr1J4hMLD9GYP0bs8SOEBeux+CvdRuJfCV+gFX6apeyjcTeEueuxOepc7KNxOj91G +4VYKX6JwC4Wb6Zk30dRBCjdSuIHC9RSuG7EvAbh2xL4U4BoKB0bsKwGupnDViL0PYP+IHZwx3jdi +LwPYS+FKevkeet1uCrtG7MsBrqCX76Swg8LlFLZT2EZhK731Fnr5ZgqbRuzLADbSm22gZ66nsI7C +ZRTWUlhDr1tNYRV9spX08hUUltMzl1FYSmEJhcUUFlFYSAs9SJ9sAYX5tNDz6K0H6Bf1U5hLH3cO +/aI+epfZFHop9FDoHrGlAGaN2Mg3zByxEfOeMWI7ANA1YssD6KSndFBoH7FBXIDbaKqVQgvNbB6x +7QVoGrFdD9A4YtsH0DBi2w9QP2JpBphOIUWhjkLtiAX6dzyNpmpGxAGAagpVIyIxjUoKFSNiC0D5 +iNgPUDYizgMopcdKKBSPiLkARfTMwhGRFKxgRCRtM0khn16eR78hl0KC3iyHQpzeLJtCjEKUQmRE +JFrKohCm98yk9wzRmwXpXQIU/PQ6H4UMCl4KHgruEWEQwDUiLARwjgiLABwU7BRsFKwULPQCkV4g +0EwzBRMFIwUDPVNPz9TRTC0FDQU1BRU9U0nPVNBMngJHAVNAqXHz0gCRtHlZYMy8PPA58M9APgX5 +BPI+hryPQD4E+TfIvyD/nyD/gGMfQPp9kL+DvAdyDvL/BvJXOPYupP8C8g7I2yB/Nq0K/Mm0OvBH +kD+A/BfIW5D3JuDvQd4A+R2kfwv4G5Bfg/wK5JfGywKvGwsDrwG+alwXOGuMBn4B8grwl42JwEsg +Pwd5EY6fgbyfGdcHfgr8J8BfAP5j49rAj4xrAj80rg78wLgqcBqu/T7c73sgz4Okxk/B53Mg3wV5 +1rA58IxhS+Bpw9bAScO2wAmQUZDjkP8UyDE4dhSOHYG8EZBhkCGQJ/VXBJ7Q7wp8R78n8G39lYHD ++r2Bx0EeA/kWyKMgh0C+qc8LfAPw6yBfg2u+CviI/rLAw8AfAv4gyAPA74d73Qf3uhfu9RXI+zLI +PSB3g9wFcifIHXDd7XC/23QzArfqZga+pFsVuEX3zcDNukcD1/KRwDV8ReAArghc3be/76rD+/v2 +9V3Zt/fwlX36K7H+Su+VHVfuvvLwlb+5MmVR6fb07erbfXhX3xV9O/p2Ht7Rd5K7Dq3krk3V9F1+ +eHufYrtt+7bt/L+248PbceN2XLAdc2i7sD24nTds69vSt/Xwlj60ZdaW/VuGtiiqh7a8uYVDW7Bu +dPzUkS1efzNgas8Wo9C8uW9j36bDG/s2rFzftxYecE3Fqr7Vh1f1raxY3rfi8PK+ZRVL+5ZULO5b +VDHYt/DwYN+Cinl98w/P6xuo6O+bC+fPqZjd13d4dl9vRXdfz+HuvpkVM/pmQH5XRUdf5+GOvvaK +1r62w619LRXNfU1QeJQhZAQzeIE8wIwMeBLkxfUF3pT3Te/7XgXyDnlPeXmL2RPwcHGzGzfMdOON +7n3uW9282fVzF5dyxXObzc6fO3/v/LtTYU054/nNyCE4gg7eTsrm6JrdLGFdI8XCUqmsXY5wtNls +x2Z7wM41BewYiW+K74u8/Tnh5wJnNmOzedzMpcxwutkUMHHkY9zEp0yF5c1mY8DIkY9xI+9IGSGH +3DFmmDW72awP6Lm+Ov1MPZfS1zU0p/R5Bc2Ix0GMERYAeA2cexTbA838s5gs6CgRxreh2YmOUQ3q +6RjSzJo/hG8YivSSz1T3vCHVDUOob978/mGMvzQwjLmG2UM2sugrpa+95Rbkq+8Y8vX2j/CPPOKr +H+gY2k94KiXxccIRnDKQWLh1+9ZEYttC+Fi4dVtC+oUU3k5SCZJJfrdugzT5t11Ko8R//KGnASza +Cj/bWOa2/3zV/99/8P/2A/y//zOMyGaF6ePcNWg5dwDkapCrQPaD7APZC3IlyB6Q3SC7QK4A2Qmy +A+RykO0g20C2gmwG2QSyEWQDyHqQdSCXgawFWQOyGmQVyEqQFSDLQZaBLAVZArIYZBHIQpBBkAUg +80HmgQyA9IPMBZkD0gcyG6QXpAekG2QWyEyQGSBdIJ0gHSDtIG0grSAtIM0gTSCNIA0g9SDTQVIg +dSC1INNAakCqQapAKkEqQMpBykBKQUpAikGKQApBCkCSIPkgeSC5IAmQHJA4SDZIDCQKEgHJAgmD +ZIKEQIIgARA/iA8kA8QL4gFxg7hAnCAOEDuIDcQKYgERQQQQM4gJxAhiANGD6EC0IBoQNYgKRAmi +mD4OnzwIB4JBEFqOIQ+nQcZAPgf5DORTkE9APgb5CORDkH+D/AvknyD/APkA5H2Qv4O8B3IO5G8g +fwV5F+QvIO+AvA3yZ5A/gfwR5A8g/wXyFsibIL8HeQPkdyC/BfkNyK9BfgXyS5DXQV4DeRXkLMgv +QF4BeRnkJZCfg7wIcgbkZyA/BfkJyAsgPwb5EcgPQX4Achrk+yDfA3ke5BTIcyDfBXkW5BmQp0FO +gpwAGQU5DvIUyDGQoyBHQEZAhkGGQJ4EeQLkOyDfBjkM8jjIYyDfAnkU5BDIN0G+AfJ1kK+BfBXk +EZCHQR4CeRDkAZD7Qe4DuRfkKyBfBrkH5G6Qu0DuBLkD5HaQ20BuBfkSyC0gN4PcBHIQ5EaQG0Cu +B7kO5Fq0fPp+DO0fQ/vH0P4xtH8M7R9D+8fQ/jG0fwztH0P7x9D+MbR/DO0fQ/vH0P4xtH8M7R9D ++8dbQMAHYPABGHwABh+AwQdg8AEYfAAGH4DBB2DwARh8AAYfgMEHYPABGHwABh+AwQdg8AEYfAAG +H4DBB2DwARh8AAYfgMEHYPABGHwABh+AwQdg8AEYfAAGH4Ch/WNo/xjaP4a2j6HtY2j7GNo+hraP +oe1jaPsY2j6Gto+h7f9v++H/x38G/rcf4P/xH9eihRBfovRW/hWlCfFIjSpRF5qB5j+DjGDSDlSF +jx2zNzZq8tTfBXPlUBAMXgMBaUPKrOCMxz2euvDxUtUtvNgGA/ijdepbwJXXjb0x9mJy7I1zlsrk +OZz83VtvvCV88KJYmSx+6+xbhQVYDImS2EycWm1ThTPzudJYtKy4uKiWKy2JhjNNnJRXUlZeyxcX ++TnexnJqOZLG/Cufz+Nnjqm4veG6OcVKv8dsM6qUXIbLklcTEXrnR2ryfWpereKVGnV2eX1mx7qm +zF+rRZ/d4bNoNBafw+4T1WO/UZo+/YfS9FmDYt1nd/Gq6gV1WfxXdBpOoVKN+l3unOpQ2xyzVVDo +rYLo0KgtoiG7ccHYdfYMco8Mu53ea6wL1BIe/1SxV2lDmSiKHjyBssbfOWoQcGd4VCbR0fH3j+qB +6BmBcdX7KQ9hEYF8GqVPg/SZysYRcjhXj7uywtHIvwx6gyvTF9YZsUNhQAbBwD0Zfi788zAfNoQN +Fl+PpU/Zh+rq6iyVlcnk4KDorBSBisXCuSKxGDSeGKTVDdF6xOFQSSqP8SHexIczo9Gyckz17FSH ++ZBiuwYLkUAgYtUqNo79eS2vs4YzfBEz1uARhdEd8wdzPCbFbvx7/L1pDq9JwasNWlydfkFr1CqU +Jq9DMaI3aXheY9bfMrYbgU19GyEFBuvyowSqQD9OeQIuAXcFBDP5MMKHywAfQSgrWQtJZXvsKThu +T8Fxu12fS07OJSfnkpNzycm55OTckxD3oPFTx4CjaDFo+gicCfj+EbOMRgk/PGKQ8J0jeoKckDI+ +oj+l5/Se2L8KC9VZ0uxLd8ko1g+rZ6O6c3WS3Vbi5OBbktKKziYogexEopJyUKrNpAiHMqOlYklZ +cQi0Zyf27OdxST4XDovEmK2TVIEDFTOXbW5LP+GMx504uu2uZUWOxPSc0gVN2ekxT8W89pHTDT1l +7hmRlsu6X/y0ur8hirdOW9VTm2MPxBRXxwK5s3d15c9uqbDoSns2cDjZWZqRHgxXzxz7XVV/TSBd +kVHeA4PFJePvKwxKP7TipUcyUHVC1kpC1grg34hWAN8jWknIWkl8F+JIE3LhJAqhKM4dsfYqnsY5 +qBQV4Pxh7Rxo0mfPEcFJWnzhtdOFBRGbSTWlWarscjMlDdhu83Ok3MSsFAZOqbGlFu1u2/vTW7t6 +73l5X8Xaec1ejZJXaPQaU9HMzTPn3LK8vHTZbfO7tnaXmNU6FX9ccFlMtnjMO/sbHzz41c+fXGAP +5nhNVo/FlmHVxpKxpuue37P72X3To8moSvRDCyRWditYmQUF0I6Ury6ErcRyrMRyrDYos9UCBba6 +oLTWp4nlIA/VjUfWjUe2GI9sMR5ZN56nIbbVgm4MI6Zu7yiODiuplTBdnGUWMUg82nkmoZ5iALfO ++eb7h9LvSdUf+dY7D3YfK9n4+HVPDu95fEsld9+3PvtmD63ouV9/5941x65p/1ys3f882fUJJeP3 +QMly0eXDnphcozH5qWPyU8fkp47JTx0b5cSUVmsNWoPw8J5RrEkZ90fxqSh+KYqjUZWbTEQau2MA +w6oJqx/cvAWKlZTciCBbv1TP3EWWHg6JF1B+j0Jn1IzdSUrIrdQYNUolfKRVeEQDrkGhBT6Dwxqj +TtFi8Vo0tLQai9dm8Yqa9FqtkGG1eAR1ulAjeqVyj3/Kz4Zyx9CCYbVVLrdVLrdVLrdVLrdVLrcV +yn3M6EN+nxqKdsRqdatGcfaRzG43cZByj5Q8LVZOlA5fVBjW27Di8rOhYOo0aE8NDy/xlMYW9Lgy +bRooarOUe9qaAaVoVQteu9Urasf+pDaqlUr4UDxBSukjJZo//p5ipzKI6tDXUr6MDLOLWKiLWKiL ++DaXzkAYlMJFas+InovhYCwVWxzjY2a5/Ga5/Ga5JZvllmyWy28muyCTJbjENYp1RzMzK5O1T2Md +9PE6HB+p7LWN4tzh5BxS39CaRaoO2c+dHRw8PeHoZL2c15rLykViBaS1S9oSiQecbP8KxU6FxqA2 +VCw8MO+yxy+va9r12Iqa3aXps6Ko0EIfcb/eYdFZqhYsXV54z9++PmfwsXO3tV+9osmjUyy0+qya +aH50xsHvbtxz6ppGnw9fkZkFatRohAxL2uqJ+jJdhsFvv3/XfZ8OLfGE455Mah+KWdDnJtHo0bpC +HDbIKjLIKjLIJmKQTcQgq8hAlJvhzNIT7euJ9vVE+3qifT3xD3rSRzhRyg4dS8pKPgQR4vkUHEdO +MkUIBwg+BcecOT3QgeSmzKcM+CUDNpzfG0ODOleHodc4S9Qqm9xkwxqMTJjaVKujXtMOeYwqZmls +IZcnaNOMHQHmJpansWW63CGbhuuSbBGYB7QPJmfQcLVj32Nc8WvGxj7lVIzL7Qv3g/7saNbxOudM +55NOHskqRLIKkaxCJKsQySpEJ8En6sZPHQdN6IQeqbhQzAlHGLmoMLifPbfWHnK6pz7t5BOSp1KP +v4f/CE+VjfpPQPf+P38cHzyOiLt8pnCP9mlchKzgsvOHlXLfBY0+MaXnJk+nYuGkFHdOPukfMxo3 +9mSU52fq1UqOhx5K4w7nBzILggItglWLm7v2zyvUmkWDQXRbHBBLmi1mMb97Ov8QKQ9pBbL/+hhK +UoyWpsRC0qwLiHUlCQvpZE3r5KLp5KLp5KLp5KLpiLEa7LGekE7w9giTcV4d637AjuCTajwajeFL +GJIc3tltKjXGDgf/sdqW6Q3nOtTprAutCf9EJThDHk/QqjZa0r34RVGdQVy5StBx149dMeHUJq3q +ea5Oa1ArlJBh9DjHxsfu81jlXqsDSu9BrSeQnRbWLhfWLhfWLhfWLhfWTnYmI625xz6KE3K3hJNn +WL1N6Ycmmghxzx3Qt2jHTjvjE4V4iQSjHTavVQu9zBPsUT/7qlbMkC1flYCepQZ9OyUsrt1UyxkL +CpzJpC7f5fKM/g/DAlIx/qxCg0FH/IiO+BEd8SM64kd0pKZ1xCwhQk25iY1mlXXrXU5j0lWYrwpk +dwf6mJuos0C4XgwFZXEmxOzCBBMrpyWLi0kUP6VVhTGJ3CGGx+HzeispiMfFpL4l/agSGlvA7QxZ +NVy6mNfbfTa736bn0i0YfIbbBZWc610dLMhyafEOJb5O7wlE3evNXqthsnGu+uwutU7NKyAog2HS +vRP5h3KyDJ5s7+dz+UP+HLdea/XZZZ+8VymiaejaIzGz2SYrU0KzjEYJ3yfKtMnKtEnK9Ovy84uI +MotcZvIBJxYJBsLglCJyioD8FT26fHNM4SY9OrEQSX1EeRfpLlksmwzVFLSNsMNhv4S+/LyzODrF +qhR7jXaPsdwTC4ft6dXB6Rkcx2msAZcrYNHkenp8sYBPxFW+sqJCF4aAxhpwO4IWTYsNxoV6X1GM +e7PyyurWe9o//+dEa3k8O1PnjAfGflyybPFgcubhmdx3YdQEMRE4CvLW2vg5xTvKELisGNqT8tiI +DmzEoGwkcLWRwNXmomoqTmmDqED6yxh+Wbl+2VL9ckjgl0MCv6xc/9MQ3OuQGwIAc2+YtCzlnPMD +2MELPOPEQFuKX6dE84p32u984647Xr2psf2uN+669ewtTcdi87+yadNXFsWj8768ZfN9C7O5ex78 +fHjR3EMfPnLvp08umvPNfz624dmbZsy++elVW07d1DX71mdIrA6e8UfQ/jJQHO0czlLJBVHJBVHJ +TU4lNzmVXBAVMQGn6CPq8RH1+ASDEXf6yGjQR7bYITECUc8RlcoAxdQfsXcbpgR91ECE8+O+8IXB +nmJKyM7/KLXjOzvv1FpDbuJVcjzYntO1Zn1n/Fj13MHch++fsao5i79zyQMbatL5E+0CqlrtrFtw +xdyZa0tMY59ktyyjNTxdeT3UcAxVoy+lfLqQJZuUIpuUIptUcjap5GxSydlQkpQOBTMKMvZn8BlF +snKKZOUUybVcJNdykaycIvIejCWkM+aN4vhRZ29EUU6q2kiq+uwZooTKyfqeiPMqCwuUsgZiqqmD +OXk0q8QXWACUQmdQ2Qa2XVNbeM8yZgk3/eLWVmu8NqdtQ2u2TZP+9oVGscUZEFWhunk1/tw5hz56 +5L5PiGX848Huu67ZlFfTkGm2hrk3Nzxz04zeW06u3vLczWAmzyJqJwo92EkZakS3p/xCvliugaKW +E62VS3VfTrRYTtRWDuU/HiczB/E6kegKmCjrTJQNSpQNSpR1JpINixn5AoyOntqUwqmUcxrYzbFQ +t1N2zdKY6NyE4qbMBFTKvkWaSMnnLzIkh9PPyxMCTqvDgUuisWiUDQX1KluW3xOy6RU77Hm1s6u3 +MhODoaG1cLqnY+uMWLh+QWWwJC/bts2kSY81znLXFd/+rcZl9QFwzRBiaMExFpbMrQuP/WrC9GCg +oeSNFXM2NkxfNbPKZkrUzChM/yHLx1/bucapVqU7Q9WzwEe3jJ/jl4EttqG3T6Dp4+8cNQu4c7qs +oumy6qbLHnq6rKrpo1xuKlGUstpwZ1EK4qysoqwig9dFrvWSbs8rCOQDLvGS6vCe5ApJ33fEK4Vp +p464ZbRRfMpMQmpD/tM4hsphcBJN6cVgOS5P6Q24UySr5TrCysVy0VEDI7lj073KeK8DbFv2XlAF +50QyTk0kBoVzAmngkzG2hR64wK0pzgv4SiYCwAsnLlT8soYdXx2cvnFutVMPwZzGVDxrc3vFYENW +Uc+aDat7iqvX3D47MberxqpScLxKr9YnGwerymaVeIp6125Y21uML5v/pWVFjmCmKxJw+CzqzOyw +v3xWcfmM6sLi2tmbZ3bvm5NndgesetFltWRYtRlhn6+gPlI2o6aoeFrvZqgjM3jI18HyM9GK464U +GRuKRGtHSfD7P3aXJPwQx08dI5avspBhsE/2iEUQrH8gKecHCeF0YmIQPDkcYZ5ACrBelwbvd7FY +EZg8uOevkYb20tj3s4cmDHGpRsywWun0KIm3Hof+7QqIBRPo3pRvcR4OklYbJK04SEwnSCKmILEa +8kZaSpw68gJLQw65wA65wA65wA65wA65wI6TnEBGJWR8RratpLRwC120R+jxTtqNNByT/WBi0kQG +8cVhs+3CoYHiiqb9o9svG9rbSIf/Vk1u7/a2ju3dCUk1IRgZvHH5if31tVc8tYMPM3V8/o951w3k +5fZfPZd3Th3pZIJ3Ww1ayUIbUr4s4tiys7CHYNSDs504asS5bpzrwu5RuZFKhLg9F8shJGUhWW6X +2xWNBHpcSgsdj1kq60QLpg2BlBANDuLBwcHEYCIiBY8KEhKVlU0JGYscDpWaO64wuWM+R8glGtR8 +ekCDLdmZGSGLVoG3YryG14DrCmQZeY2fTPNiiPv1GsWINBGsMeo+e05RR/LJRDAp4zSItN+EMtag +VUeiNRg6q49TDaRhR8AENYRkJ3FEkHIiONNFSDwTu4KE5BXivAKcl4Xzwri8J6cnXKDnpw6vIe6r +g5qDHzLBLf+LTETGPGMXFvP8AisPKISMuD+QyDAp0h9wn/ImTzwYys0w8+nHVViMBgNZVjWHwxjb +eK0t4s8I2bQ8jnPYx6usYZ8/LGBl1CSSaE408S9/nmRccdjpIVox6T87rajSm8nA0Kz/7IeKah1w +pcnjJBoqgJb+oTSLUZDyxZM4no+jLhx14pgDZyMc7wnrRV+POGXgB611UPqZnMrHeGImf0ppJ4qI ++T8alZZ4ZjDLrlek30z/TmmwZ/lDUbPSiJeknzSoBXBQUYdOhR3YptRZM32BmKgwpIdqHR6zEobA +Wo4fG4NglVeaPQ6ul6tzeM0KXg1OIQP/UWNUS/U99gNSnmoY990FniuOPMOZ4iiOHvF2G2KjOEan +TYvgd8pIjviYcjzF2zjsUq+JgfF3SeM6hSfI6yxGrm9sRGcimjXpuJe8AYVONI09we0ULa1Wr0UT +DEeMDnfAzh/SiF4LCcUDwZjg9vhtny/MJLHEAuj16vifwGg8hYZSQXN9oD5Zz+u1zhIDuJAS4odK +iAsqEUi7KhnFH6VMKBYzI2xAxFOhKrlHrJLHMFWy16libbFqlNOkbKLzB6hEKOGqT5VgVIJLSvKn +54xib8r8UibOzFT43s1vn/ZbQ5cCJdmcqzQNN7h54SALyE8nFg5WyvOvRRBoLISRH6loGKOUTgnS +ikvl2EzOUUg+Sk07MQeZruPrhAyvJ2Cqvr27ZWt3Xu22b63Z4yicUTltSVuhQQMDELW3fs7KkiU3 +zI5+45bG5fWBgVnTN05zGQwQQRvm1TVHmldO79zUHmkumVXq9YV9GsFtdvs8YZ81t2/v7NPOvLp4 +c299I2j3XtDuq8rNKIeM/I6Bk9WFymTvXCZ76zJZXyQt6atsFH+c8toTJPJNBMmqBNF/gvQNCUFa +rOB0KS2y68pKQwplwShWPhVt9zYLnZVAh5VdkjcHFTorJ0Z/kzqb8Ocx+8WOnToBNrhRiw6HFO6/ +WrzstsFEW3NzTGPx2sGGVGpr0OWGsV12R2tr9tKb5mY/YS+ZkwrWpppijXsaavvL3fjt7U9f0yxG +q+IbwLcrFODblRUaOgmkGftTvCIszDgwtL3p6uXTLDn1Rel7e+fWLNsN7WQeaCzIv4BK0Y3DGVJk +RCe63pQnuN45SiYNLjHd/9750/zj79Lpf06fMiZN2OR+O5DSGVsDWaOYO2pt5/9aSOIGrbG1MHcU +q4a1XWQ+LHFO+piY+j09MdF/wYKOioZFqqnLOXyQU6rdNR39ySX3rCidvvnegUR3Y6lLq+IsRnOs +pq9qx75QarCmck5dwkCmDr4mukWjO+KzpHYf2X7tc7uqBU+my2R1WWKBUHbo+BNzD/QnshJhjdVH +2uli0MsDyvUoiirRTalAXTXWeytJ66wkUUIliTIriXVUEmOpfBp/ghBKUq0lZWUlZWUl5RablJWV +JAals4aa9ZUxr8KUQ7ZWu9qhqSuOmLqUnSQwksyp7oKVHcmeJiZfpjZBCPMnrIqPRqcOlMr5B9Ri +ho0sFrfcO3/ZzXOzi5bevmjmgZTaFiA2pT3UcGVjHVgQWNT00LRUc8zNDGhH15yuA8NLtz19TUtT +A6dnswhjTWA7S/ekGq9eAbbUUEi0NQjauhe8WgKVoCdSOcmyurKNZbyVtCZrkCyTWEO5JCbPJdqi +C6iSfwNb+ORYY+IbCY4sDR4jra1EIRufQrYxKa2XkDo4BdFfKJT7o/2K2xTcKQV+SYEViozkb6Pt +rncXmzaZOJP23QzJwAanrifRRvm7BDU2aRVVaqCqcGiKWdnPNz7OHiuTFKrm7425x0b8zZu6U8vb +kga1XsVzvFpfNmdzauOjW6pqNj+ybO3di/MO8VfsmLagNpPjuFioY+ecfLvHrja5LUar2aB3u6y1 +u0Z3bTtxVVPj1vv7rVffld+5opz0V5HxT7nrlDshQlk+4hBIA5Qanlf2Wl7mrbyyO/PKxuQlL5EV +5ERGx19KWcj6QER3rqzFEz1X0BrsFFql0WMRmWNJnC7+gLax4tMXrKrY5VnZqaPHsLzCUsxWVbjr +IMZSqe3+uDdSEjS9AL2x0mJ+QQOuyRW0avYJAnE1+8Kt69vD9VkGiL3MVqdJqdVrXcXdVUvVosea +Ffz8ryRMI8utvD2YZfWI6sGF18+JG80Gq5es0Zem7+Rv5H+MatEMtAi9lLJb8lpIK2vRQJFbgoIV +d7YU10H0RlRQJ7cvwDefIofq1DOBpoxmC+6c6VWYC/hitZpYjyDp61TKCCSvWO31qovzFETHqRKi +5H7yFf1BAS7rz4mk9IARc4Gar2j/taH3Hbt9cQX/l5rWnGD9ryra5/8qOFNepqyjC1evUdefKD5D +lOuEQJeEuiJkCmcS8JtgH0TroGOHg3YF0ZgK/JnDKY/Qmc2VQ/daUiZ90pYNIQguiU50p2Q5PxqL +mXg5xd9oNV8Vziga3D+jfJnX4pxe9teGTT35JZcd2rz+3qW5QqgwWJgsigSyShZc1RlvCWBBFNPp +FYMFLUnnivmFrUln76LuvwTjLu01l3esqPXy28KBrLnJGTt7c30OS74/nM/puNC0geraTX2FkdRA +Sai2otjt7sydtjgaGazv2jU7T6sJpT9YsCpY0ZY9sDJQ3jq2sKqO07jz4tn26Q2+glpi3/dCfPkI +9MxF6IqjdSU4Z3KhVDbsKSuo8ooqdMtOP10OkxbGpDUxyW3oyTEdXQnz57gF6FGO57VnNbs7Jfcp +TZhMrLTQzrjy/OUgqTdRX2KNggatdv4RjYX2ua78toLaPY2QlCaqWVfcclvbvN2dITezZ87ctbAx +q79v7CaWM7X/7WibtvLGJcRTXjv+Ke5WJpEdhdDNx+vCM8Mbw7xDjuXOG0laJXzzghEnHWE+zW1G +Gcj+RcsXskrtoKandAGyg4W8TnXULbRJ+nntXEL2hnLPcum1MivpdokxghXi2gsVYM2trkoQmVAB +fw1bdcIFVTnxShAo8fir6TvxcihxFipA1x2ZWUT2FEnBAuA/yHNHmGMnm41IASLkzfKEAcnnTVlm +o+WaWG8D35fSud2oKJ+UMR/KeCQ70GaDnnRYKbVSKKlYXMziWVpaKKvyvIkYx/mj6/OK3e1PLW8J +5rlg2MmrtWpV2BlK+k3M6REd5CSqq3PMy3fPTmh0RtFiJHsHlLa81jb+8MXqoO1gD7SDEnR3ylBX +huOFuDBlwV0QHr0kFa5Q7v4KSekNEkrdX+HTXAxlIoOsgy9eVYam4XHk5SGiEtpEHJl6ZXZbRrPI +moc0CQvBFkT3Up9Q9Cazggkz+B8t4O3RWDM93rDLrEpfc6F94NkaizvT5c60a43m9Em8waiXpgxh +uKbF/0gbL24mn7+CL9cZtTx0qlqDS0ifTEdEu+w7cC3ozI5S0grxRmmF+NJLsJM2gj8+qhOapRLL +BnDpFeGLLNt98aPJT6F8CWKcWejdlNdCVk+lXTxRadYgJk0ZbOrBzRfvBKEzmVN2jLw74d/8fgdZ +KfEX0dU6ad1OWrKT3JwO7Pv4LDL3NKv24o019LYXbcB5Gn8MTlbAqpGOdgi+VSnj9Pba5ryKtrxO +95T6n7rwUinPJ4uVbHGaeEvplZr/5DK/yIfa5YG/bCzKl6grtWpsuY35lVubSOtxhqxqR25DfuW2 +Cc+qsmQ4HT5B3XlrW8VAY4GQ193RkjX38rbApI8NV17gYy/O4a+BwITntXrNjr6ZnuT07MLGHCs4 +307WB0ENFqG7UmZag+RD7o4urKUv2NdDBot+vSCwXknauDFlzwb++LjcMZFuKaXLa89xZ7Ux1ZOo +YXIPgHCetv8H3ZP9v+ueJpT45a7/pns6T1GgoMWkdyKjwTdAQ2QF8FupjLo4zrbguEjmAKMGHNXg +qBrnSLNOl1j1e/OSq34kWPcndVg3ZTkxeP5y4klOR+boj5tR1yaoJjd5n9TcHoaRozy8JiNEWWXJ +iUXCQfbz360W8m9Ubf3Olo3f3FBWufXbWwHLn/DWrp3ZtqYx5K1bO7N1bWMQ/2nDies66vce3QLY +Drin7eqllSWLru5qv3pJZcnCq8ncQvou/lXQDZlb2E/mFkJll9gtQb3P5LYJEsTY6bSCNMEgrVTQ +GYZLziu0CTO/cF7hUtMKl7CRL55WuGNhduP0VNYUY7HZvRZ1vLOrO2/pQTKtUCxNKzTHGnc11A6U +e/BfLn/mQIuQWRJO1zJfqPgL2AxPZuOuyKmN2zuveXJ701XLa6zxhsL0fb39Ncv3SONn0NYDsrau +S3lBXQF9gjSYhM7AplgkJ5cgY+ccVEzNZsq+2XflfbNsPy3bNwtjZ3ukTT8tEVAI+WTs7GmvIGNn +oYv0+ZceO5+ns1KRzsgye3GWfvHYWUuaWcCmjre3tsWIioqW3b4ou7mpJYdsvbZliOqLxs/po0xT ++Ey8MmxmY2gxUh1fz1SX/jcdRNMJGRhES96Je1SaGVx2dFMpjpplo5rcUicbl1m2OjMxLsuUBQpi +ZcgDNhdJaRPtUbM92GbvRLK7lzr8xEQsPHUAeClHIxmRinuUU2k1Gqcvy+4uKK0KX+hmItOrKn3G +UJbPoOAxv9ThF7VarcaW31k+NnSxozlQ1hgz8xqdTmuSdlZ2j5/jXoQSt6EXU4ZkR13HzI59HU92 +KKcsAn4oL/5JRjGdTE9ZL1gclBYF8W9TAboSKK0BEhOTFwLJEJn4HO9J/KG0CUZHwiJDSgqVIBmF ++9UZnjRwhvzflev+Ks4SF4ubRJ4u+P2GrPa1O96hjXFiqU9e6BskSzdTFvomY+n/24U+7sXihVfP +KJjbVODQKchCXqJuTkVOY5E3lprV152KxXt292S1VsXtah6iI51Km1nWlsxJxe3ZqZ6+3lQMm5rW +QX073basgBXiT2/QawmXRaIl2YHMRO2cmtIlbbkGi10wmB2C6BbUDrfDGi7IiJVmBzNzamaTugiN +/51br/gOqkILjsaRGM6TdZ4n10WeXBd5coPMk60yjxihwWnMOxdu9RnPOVsLSfStpm77DDG7Ynn2 +6sxpOrWnuPQEw/nTEA42HcOt1wjBeL6zeXnKt9dsIat9V7JA7W0yd2wxv13e4szKsGmUWqVivi9T +MGlVkY6tMzgTnWF4jW1xeY3OQaR1g4u0Oq3S5CLlvovM8/HPQExwRyoAkYA+RiwoRiwoRtbAYpKT +iglSyIU/eYq2tICslYCsFcCPpbZJyBHpFQK5sQZkGw2QsYrWmtcW0yvdbRCYKScn+6Zuo5swqUtO +9l2wKFhWPjnt94Da4rM7faKq6x6p61fb6BjFmWwtqN3dpLYFoOVatBMRwY6+GTWrblzKZbLWOfav +mYsaIv193HaWI68O8rtBP7noDydQeBx6MxLoBqQ1s0gA+ynxY4dcTruMtsnwV0LLxF6H8fdT5WSj +BEQVIo4JOFuJM7MhY1omzsrEIULrQjgrhINSbhBnBXHMjC8P4RCZ5NKK9tZQEFptiKw5asEUQ2SG +kaRITYTI/Q1ka2N2W0jvadNTBygttybImyeDUuSQoL/SChbVO1m1S0jvAk1sapvSRVid5Vb5JaDd +mOO59BmF0ZPt92e7TYr0iwol2X7l9IWtWkVawX/G6awhr9MvqvmHFVqdQf35Y2QxUqEx6fi5BouW +hzEhBx/aMY/BwP1Za9DwnEZPtF0KY4xrQNtN6I0TqAXc0zQoWgWZ/IpX4HKCkXwcDeFoEEcDOOrH +UR+OZeBsBY7zuKoaV1fh6jxcQ/4HCDvuEuTpA4IpHZirEIQ7CGY5m2DKQDoSkm2e3iadR5RZJ8wU +Ngr7BIWQsjhaheK2SFvVbbk4lxzLJV5TsDpaV+XuyOWaINfZqSVKfpVocvB0Xd0Z0CTV9+SSL130 +pT9U0aoJPfMx9ZQ10kuofApVXqNQpj/ijc5sfyDHbeCf5bgneaMn7g/EIJX+RKmA0YUzI9Oi4X/F +cT/itBYw+4BFw73O4dc4rTXkcflItaht5slK4W7Rase2TlaR2abW6qGGYKQ65tFqoYaM4HjJJlMX +S3EaHamvOLSODqivJLruBCoExYhkfp/4jXziMarzsQvs8SmynufCTtk3OFiWA2uJteaQcSu5pgbh +ijAu02N9kAwvSK3o9YUF8Tay9tomTgwh6Ip6cmI1nRgvtd9ExGFjr1Xxl1iLtVon12IbNNZYwB+2 +6xW/fF2ht2dm+CIi1mJX+iMNtsaCvrBNpzjzkkInBry+iIXTpj/JNVkNShidq/GK9P0AvNJgNeHj ++FGT1ajgVTp1ehjPVJFdmnqbOb2QeA+IAveAfrJQzwnkhbKWkpbvxXEvdkmDZxeOmspMXEyLPaRL +rvJgdwVRnBsH2tw6a5uuQzETdciDVrLKnqCNljTeEE+LWm4l+42jJROr61ZpVsdhU3PFO1WFRZ6g +yKn2aAU+/ZxGyPL7M21aJcb8xyoxM5iRJarSxwRRabCZcKXCouMX2F0mJa8xG8fyudeseiX0ExYo +yQAEta/zx1ECVZ9AApTEQXY7RKXdX0k4XqJt1HLaiAiDliPuVnNMGrx0yCvNECucGST7oy9acJ7y +GgNbcIY+73WVxqQZe83uJfaIb0nvE6xkDZpT6EWDmuSlt+NDGqNW1Wz1iuqMUKbJ4XAL3NpQxAJp +lckhBk0up0cYu0ctSJFWTvoNvBW9ibxIN6J3ZiDh7Bm6+q1W05ZXbp14qXGryuQUb1QarW6r6NRh +xbV6V5bHneXU3xooyc9zv6jWaaTGgK37vUFBpRKCJN5vTf8e38LfDSPHJAoNZ9me5maiKBzYfUwX +SBQozSh5Br4Uermzb/3w4g2e4qUf5RatOzsQzIZW58oOBrLdWpXRKd6gNFrcFunRDhicWW4XPBof +DOZ69XpvbjAzj2DeWJf0sD/T6NQKEm9jceJhOfT0+Efys8aQdxjZRrndx3X+MIzRza2o7kzdGRK0 +FF36Kc97//Oi57swffFzZYdoRiiUB87fk0dq58vwPBugdvTIOUy2VZ16imyf0vLQ3OFREs+Tqpoy +J7khWVuTT2R9SzK/CYSsnNwz/pHiffQGuQcKo5znkIvbg/zIwO1GFqiGPcdVIbvWayb3LC4+UwQm ++Rb5d/6tlV/A8ZpkTVU+Efz9fMKqoZc5zfLWNSfzGy8hULKb+e34rHIn2J12ROVogfKAVs9b7Sin +Dsmmxp0GV5ab2Bm1P4PVbbE49QpF8z5vUFSpxKDXX5Kf73pRqlJ571IO3H+rfH+9U77//6VZK6OB +4mSe60W1QXLyWmzd5wlaVCqLZNc38Dv4fOkbypHxqCrTUQTfAgq8ZDlg1P0FpeMO6Z1hlyvToQcT +Fq5XGsCEBYcOK9POSxwAn6xo2Ss/hcdfDJZ8hhU7fe4LDpCnTfA7uJcnnlYfcxZPPO2EVqLRkkm1 +KC+pLO5l8jA3KIwWF3kY/hqdM+x2hh369H1TDsDjK6Qj5OmVsQA8jeuMRk8aHGhRBC1K1eb5ogNQ +fzj9Nq9TfhfZkWZYUKJksrDAKT+MPNes/pbCaPPZ3SGLQsUNKoxWvx1Cf4XyA6NZo1AbrUbVbqNZ +C+W3GeF+Tfgol89NQ2ZkOorU+nMKRLZcyytvIWrOkofNt4jphRb4wV8DP6rEn8T8gWjUrxI9CI9/ +iM8pOG4v3EUcgbucwBnoi26k4KzWz+usFouVf15r1iq5smg4HI2EtdK7g+OfpO9UoHEXMiLzMaTW +/UVBViUuvo9DgQTx82mixSLy3xfE9GvhoD+cmUk0dG36UfxP5U3QpjNTdp4EFTwZzvJSx8PbA/pr +UV0S/BXdYKqC8ZPFObEfK5+XrJBqEv990eCi+Ups8rktHquBL+upyAhU9hRjrZDhcGYInHLpC+mB +115Pz/upQdQrOZVGufLlX/5u8+bf/uqVVQqVCjp4gbS5XfBEb8MThVDxCWSh0b5FHi0SPEaezCJt +rtVL8xH0CRNFE3tg1SwyKbOUlnCxqBzwOSz47YyK7jLeYPVYPD4jVi5YuHChghMynPYMUcOt2s65 +N//uly+vVGpUnBK6wp/gR19/DT/6glbQwdOpFGfSM+H5HuIe4Ocqb4B+yJUy+bMDsaRTbRZUOn1Y +DwZmccLACkMApFLFYlYH8XHlVrWKbIsuL4+RZypzOvko8XpqvrzMAcpUq/k2E+d0+gyvZvDB/Pwg +n3HW4Hc6semDD0zY6fQbzrL8Vw0+p5MzfcA/qgrHsi3a+9OfmgWoL9X9Wkt2LKy6bK06HItZtPdh +pQA/6c/ug/xoWL0W2u5N/EruPuV2aAtxZDqm9EZbBGi8dWemdkQ8m+K8IMdh5w6oBKfF4jKrnDpb +yOkK2bQ4ff15eQVR/rqJqamfM5YuPD9PEMDY0fh7yoCyHc1Gq6X/OzGZ0rVtLfHvdM9TmzeMYv7Y +jK543Fw5ilXHGruW/83czN7clSbfCgusxOyo9U1u4uedtXzp5Gif5sEgVloQp/E/3RGKbdLqAdtX +xrPpuHweTsDr/KlVbdmVESFn8I7V/Vf1JaKzDwxmzpo7PxdGvAa1EHA7AjaI9Av9eQ3JgE5n0YO1 +GIIeW0GqrzJncM3WhrrNiztLYeBkDuQF2pbVeO35zYWlbUnHtnDjyob4jJaUt2TV4oFIUUPckn4L +95UvG5ybW9bf2RSu3Ty3ONq8bFr10gXzi+ID8+Zme5u6ZsWzdEatglObje6KdasWZmcV+A2cxuV2 ++806jSlck59ZFXc64rUzl/Kct2JacyLelEpl+UrjLm9ezVh2yZy6sOiLO/OWLF2SH6yrS/HXQn+O +xo2qncp8tEn63zvXHtl8wBUZxetThfkGV14F2u3qc/Wh5mXb3gpkBwr3vifOe2/WrA614UD+5iyl +GIB/C6e9t+6a7o6/LwTPVXf2nDRDBXVTJFYmz0l/j4FMYT1/mmQ/L7z8mlhZ+ZZIXifA8gyNXBds +Q5+znIbXal5F5mYUcuWctyOLbp3JksZwKql3keZTFfJOhXKs2ilGa+ft6Io3l0XU2R2tTaFEfXGW +S2cKVvRu6QxWlxV5REVG1OI2KbkBoaAhXl+U6dAltzx32+WjNy9vynGoi/ee/Wrb5XPLdCrwtVih +NlQuuXrG0+mxr7fqAxUD+77z+1u+8fcHOseeic4qzmksCju0pXWuooq66Gef87jxS9ftmFdszaqM +ZFdmCWKooKY1J7Hx8s0D5eZgQajfZFKoYQhTMrc33jy4al3R3Ad3tJQMbDtw475NsY2j17WLVlFt +doomi9mgs9lM/d/485dKrr/34a9cv6Jq5m0/P5VqjE/vmdMdaJ8lhitjfA+06MvGz/HPKoOoBLWi +e0+gdhgfOs1c1+J2nNheh1fW4YY6XFKHs+pw3SjXkLIZMjIMu0rx2lLcUYqrSnGiFJfCgac2IUy6 +AjJsp2+fvnMcboMKDNgwOv5pSgcJQ9V4QYEyOorRiHWgcRTbh5WLJv6GBDjfwbMwQhx8Sxp/W8im +TomRd38TUyYrFRdOTqovWEtgKyrPlqw7tLl7z4JpEcGSP3PHoQ2RzlSuSa3gsFqv1UfLuooHr+uL +857pXXMK19w2EH3CWTavPtLeVOcJ1S2sSy2s9eGv9z18RVt2+7qD31jY+/hDN62q0ZoteqPZarJ4 +BI1JNHXuf2yB2e8yV664cXHVovosozNgueqJNXkF3StIvNsDuj0pvclUjlrw1SdQGZlwE8l2TiCk +CyodlXNKWU4JyylhOdJygzi57NAmvRICVdSGC9g5BWwqb2qOtCRfMMq5U25bttQXZ0sThTIP0heo +XCmP3xz2+8l7hDbpw2/z6yqkcyrIZJbdh7sqpAvlTHJhxUmuAdr/2SOkkicrfeKdFXmH5il5/fuU +tFGsnswk6Mg96gvgpvXsoevZQ9fLD11PTE3UkdG2rnSaMm/MPdA0NmEslROvT5+l02LnvcgCIExZ +iSLWM/GHF6cOli52/XzJxP5NZ1kZ+YMkbAdTGX+yZvOhy5Y/tKEqu2NDU82CVKhw2b0rl946mEu2 +b7Zs7Ij90lfRW7puo7dybs2KdTmZTasa6xZNC1x7zf4DuHP2gXn5OT07u6atnNORGWjqXlDWuKO/ +ONm9oa544ey2YLi9bxG3KKexwL20L9ZQUxko2Tv2tfyO6dNCgdr6ttwlay8jY1ewpR9J7z0m0Lsp +9wVLnhG25JlHZr4ixDry8JTFTLKCbyPzxTZSeTbyh2Fg9Ev+p7QgnSoPysYVlNe0gvKkMeA7ZKSX +FcTk/4FKaXXklcoU4qW/yaMlO0d1M3UckmY9pdd6qUGcklo80iFdXq6X/Olecy9535C9Tjn5tsVg +YhAa+tSVZqnK/sO6qWLK8peC/1Fy/dBVux5dmShYN7R/N+CQyZuo6SroWzvN4Z++orWibxqMdbmD +d384vGTuYx89ctdHEn57yX2X95W7Z938zLrbf7q/Kqth4ZZrwX09Ac32YaUT5aM/pbKy/DjLh7My +cNiLszw4yy2/bRCXdG8h818F0o49ou4CjIhqUVxee4jLCo3Ls/BxWaFxeYItTl7QNPld5CKXnnzq +RbkdAUrtSpTb0ZT8U/IreaB6uOIREYtWyyiuOxLuiQujWE3fAy+qGzsjrfyQnzNkMyV7f4k2hslZ +zkF5roe9UiBCxElnN8sj8s4IUZpPflilM6rHFqgNepVKa9Rg06dk3ySv0mtxjsIAAy0XDPfe1Zi0 +ykaytqMWPFaLR9Tyv7xbpzD6naJLMKie4xUK6A31qs9u1cIQBrS9BbT9ANh0LborZYyX4YQfx31k +xjg1yrqhFHYQK3ZInscRlGYmubyniiPwD1XKuq48ye1DeqocPZkf1pP9DmJFZTBYCcaX/1SxQ5Xf +K0AomM00RNfJktSZgAM5M/FnXCQdSTPB5ymHTO5e8BKBasJ3qKVXvx5QwuhqrNRkN6t5ndnw2dw1 +lZaM0lkl0isEahhackqNq3rgsuqFtwzmO1qu23iGK9aY9cp28l6bWvA7bBCwG7FuwR07lyYSXVWZ +mdmZGovfbnYIJntW2FW6YFdT7e5bn9zymtYizZitAp9wB+ivHytPoHmgsgyisnm4UANKKSQNv1DS +WyHRW+EoV5rSzeiNzpjhsuKuFFmZiMIpUTJhnoLcaIo3eTUCW4uUrvQGpe271GS9oPlj0iSwtOee +tG+TbJom2dpNpOKsUA2marK1qzolTT1WY8l0ZROmPUC1WC06ykaxHqL23tx/BoPKNvLKon7ilcXk +uUph4q1FcN1J6u9lXy9tYSXbgSyVk35+8o9VlE1Z0aQvtdN1PJZzqUq0Qw9wR+22xy+bvrm/yqxR +8SajtrR3Y2P98sbMRO8VXbuhrtQqvUm7uX5NW8xT0l1ataSzSEfmmGEcaq3q25iad8P8vGDtvOqG +jbPy8JaBW1eW230Bk8nms2dlBCPBzNq+ovL+VCY0D7vVbVZnpgbKs9vKAuHssNLsdZDAzQr1nD97 +e8u0Nd2Vek5dOov4fvLe0y+UNpQDfumzVBVZXsnDsVycFcNZURzJwFEvDksOKuLCESeOOnDUjqM2 +HBUwVHGWEmcpcMKLJW9lod4qz+EC4ggK8g5OunPzzeNkZ2dGfr4wOv55ygdnCKT5keEhfJDVGdKJ +CGSIL5C/9RRDCuqrFNABsI3wKR3ZCa8oSMa8+VIFKxIhQdCFenT0XTtodcXniork9YGEvPZK/hzB +GQknW+AFP/j87d8TTRNP+ioHDuMQ/wub5Q72VxvG3jUIRiWn0qnxK0qrP9cPgy7hDtGe/iqXno8f +xZtC0fT7bMERCyrB77L63U4jb9GQDeIao/bzH4a5v4xVkRa3AlrcPUoTeKznU8ZYOY6VSRuOeMlj +PUUdVrnslcqlP19HXrwmL5dmg+qzyWvspF1km2YWbSzaV8QXXfoF/ZNcsfT3XOS+9Ji0S9I6SrYf +kV3IVlcZ+Ts6htyqfwXJm1LK3G7XeU1n8BxpOskEFl6TW8zpwbO08VDlEu1e8k+70BAofN4fsFKF +Q/KWY/6e5v3D62rWzS4zq6S/96LW5bSsaW3Y1J0f694zZ1p/NMMV8HHTNGad0mZJ+8JtBRsPbazE +j6z+2sYq0e0yGUSPRfSKGrfPE2xc1V67qC5g8EQ4cyioBSeYlZ2+W8mVLjk4Ps7GJZyK/4n0/7ku +gzbwJGg+gF4/gUTwXToxhDtFQZBfUT//1fV35H7yY8kWt0nLuMIou0oQ6IKjdJUgXyUd1pOV4u0C +aTgqeZE4xGo2hKcEtr+UAlq73CNP2dX8jvxHW948BtfYleIozjvi6dZPvEosdclSLSTkVV22uDu5 +ristiE1dd+Gf5JVaVTpfaXZmeTKjIqfC747dabUqdSYt9w+TXa9SnLb4vG7TZy8azFpeZbQaFe3Z +WVboV1SWDNCmPBIBbf4MkTlYkj4EPUcBqkfPpqzxfJyjxHFphTYniqM63EhcRZAUuxG6EyPrSXy7 +CnFlYVvhmkI+UYgLyYvuWmQyBdEmxNFhAB0OHCUWW036Dbi0msQr0ou326txWXVz9cpqPqsaV49y +iZQpGcGR1D+CQXXZv3J6wYo1w+o5UwaF0nBQeulqUB4RFk21YcmKFRduYyk/788z/J/2zj+2iSoO +4N937669rlvbdW1hP9rZltFugFvYSuoGOnCUzYFjTBn7AYwBsrmhUH6IODY1gsqmMZGASIAsGhLl +xxgBgqDIEsRIJCT+wH/Q/yQiCEMlKL/q964dK9sVOkCR5L1PP9d3v3rv7l6bu/fuvfI3P2s3im4x +ZZW+9NGCYaVjh5vwYGlFrXvMlOxZrdOGc541NY3vVrhGPvuhv3RFdb4rvsMxruaxsdV5KYneynHF +bdz+p7Ztbq3L0xqMxtQkS5JO0Bv1xc1bqlOz8p5pK5u6YakvfdL81e2+lzsaszJL5njyagvSRkhH +3Bu4wM3l1sr1OY58owlsMYZEktihb0l1EmeH8Cru9EJ8kcyu77pu37sIN9fhaygsqhuXai9oKCpp +yE9qM9hHpTlz7IYEp8fhzk6NIxMmNVeMfLh8xeSipsqcUVXLi7zludYUb5m3oMpjtuWVAQkUB07S +5wSPVJ73CSTgbVqolYN8v5Yg9a6/B/O7KBd7Y+aVq3PVN/WEKdXTOgSdKcVkSdZSkb4m6MzJZnNy +LBVFjUZNxbiEWEEjalVUrTNpAfNiYeCksAC36eJNYOBel96pFnOlmneTJvm77oNGupe3QCaYdmUM +sUnd78WqjJCZfezasexbNcDv09nRXlWMTry+T4xPMZus8RjTxMWo8EpWJEVivNUkFdhiLE4rcPlS +u9jra6TnqaVG2qRRNCYnSD3vYSxOIwjBNv3SVZcU2oOQzIj8zNWGcTwILVZgN191gysSgk+RrcJW +VQayrBd1mvpQL6I3Ap1ip2ai5lKQmK960WaFOKBE7IjYgz3EDQ3Dz4jz6+wR2a/3KfBjEENzf/Au +7t5yrj9Gv8wZZRL8EqZYmZJezFnmrnAsJRE4ZTk1qGXQX0EGH+xPYu4dcVSJpFeSK25wOuXJG2xn +MBhh/GTNsTZZN1lP2xJtT8i02/6ORKo9jAKkPozVIb59yHlLWvrxhX2VhKPu38RpcVqGjL5Lzqdt +Gepz5boC7t3uT9Or0mdnpNwV86Kk/bbsCjKMMBgMBoPBYDAYDAaDwWAwGAwG40FCfiaDyHXLJqld +BYbDoIKdcm14GZQTjkwmNqBkBXHL/69bTNoghTxPphM9SSJ7iIG8T96BxeQQzKB+spQuhgLSSJbQ +RuDJm+QIxEML/Z2eo3/AUMglX9Kz9Gn6G2SSLqiDSvonnUYv8I/AInDRGXQmaaXlMJiep91ghOF0 +OW2mLfAojKcb4EU6lV6kleRrUk/fg9FQwY+hb9N1tIJWAQ9HML08gnvSXRYI4JBIQxzncfhg7AXI +6TXi+eAwpgI1wOOzGutr/fXBOYApFECE6EKf5bqhO3DThOA5B17XKzmO7+3gHLCVsI0vgFmKnsV5 +YdJfonQ7bBNioaqv/FX8nJAcPwDfArUk78Z1UTpdWdUPuN2MCE6E2QORd+C2UKEW49MwHibu3wRF +T4E+XMEBH0crvxocahuM6Svvgiwl6eeQx2TKfg/VA5XPgfW0Fn//ohCXrQmXXoHp0cgthLT/s/Qw +eKJROlY9khOwckD+GjjRI/0Aj3lInKeoak7vthT14vkYiL3r1nBHYX241A6l0cjtAPt/JaZzTbTS +jeAQ9oGnr/QFSKebwdHPdKhgMplMJlNJEoAMbggUogc4AdYJq2AtTmuTpvdIK+ANdNiAHQRESW4R +jJekVwOXIng5XG4+rESX36n0Kmy6rR5oFZYA9Kh2Pbji/XFDyCn32UJ0B+pH56FZ6NxQ2mbf7/Rx +G8F7T+0MTLxb8XquMFzMm75QWVfkIJWPCJ8t7NzZsX+mfvRFSAwWqBw40yS1Y4Jv9MvWX7l8rVVz +Vr0XRzVymQ2GfwCBtgSVCmVuZHN0cmVhbQplbmRvYmoKMTMgMCBvYmoKPDwvVHlwZS9Gb250RGVz +Y3JpcHRvci9Gb250TmFtZS9XRlJYWVgrQ2FsaWJyaSxCb2xkL0ZvbnRCQm94WzAgLTE3OCA4MDUg +NjgzXS9GbGFncyA0Ci9Bc2NlbnQgNjgzCi9DYXBIZWlnaHQgNjgzCi9EZXNjZW50IC0xNzgKL0l0 +YWxpY0FuZ2xlIDAKL1N0ZW1WIDEyMAovTWlzc2luZ1dpZHRoIDUwNgovRm9udEZpbGUyIDg5IDAg +Uj4+CmVuZG9iagolQmVnaW5SZXNvdXJjZTogZmlsZSAoUERGIEZvbnRGaWxlIG9ial84OSkKODkg +MCBvYmoKPDwvRmlsdGVyL0ZsYXRlRGVjb2RlCi9MZW5ndGgxIDM4MjY0L0xlbmd0aCAxNDcxMj4+ +c3RyZWFtCnic7b0HfBzF2fg/s3tF1+90vd/pmqST7tS7pbWaVSxbsiQj2ZYtuWHHOO4YGwyG0OJg +INQAoYSWYojPckFgWoIDScAJL3F4ExISkjhvgCBwKCGx0en/zD53KsYkhPDm9/99fr7Rc9+d2dnZ +mWeeqbtnE0oI0ZCdhCedc7vjRUT8XNEIX/OXrR1aj/7LMwihjmXnb/bFW0tbIeDXhMgyVq4/d+03 +3qx/CI6PE6IwnnvetpUYPwTn636xasXQ8nff514l5GYBAstWQYBmd2YnIbq/gT+4au3mC1L3+zqE +XXbeumVD6F9xgBBPz9qhC9a7HNa9hOhdEOj74tDaFan4QfjyrF+3aTP6b/ax8+s3rlif/ej4xRC/ +hhDzPYTI7yIkeSOZ/FwK7utkDzlIHiPfIz8mPyPvUSUZJFeQp8gfyJvkXXKKEiqnZuqiOeRz+yS/ +JF1LNPzTREashIyfHH8j+e3xNwiRaqeE3Ag+qyQ8GTKeOT56eljyxuRI8icyFdGL1+q55yH0BB0d +P8nVMf94GfNzV7Fj8YoT8ruSe5N3T8vOerKRbCEXkG1kO7mQ7CAXk0vIl8iV5CpyNfky6OISOP4K +uYbsJteS68j15KvkBnIjuYncTG4ht5KvkdvI7eQO0OOd5C5yd+oc898F7hbxLDtzL3mQfJs8BLyP +3E8eIN8k3wL/d0D7D5HvQhiGoP9hCLmHfANCH4RQFouF7QWXIPvIMNlPDkCdoT/tGyFPk0PkEeCj +UJuHyePkCfIk1OPTULPfF8NYSNr/yTHx+xlyhPyAPEueIz8kPwLLeJ68QI6Sn5CffqYzP5gIYb4X +yX+Rl8DWjpGfk5fJf5Nfkl+R35DfktfI78Hq3vrY+V9AjFcgzqupWL+DWH8kb0DMUYiJ8TDOr8Wz +r4spHINrXyPHaQb5gHLkFBmHI1Z7t4g1dJtYj6z2WO3cL+qZ1cde8LMa+uZE3TwMOn4Y6pP52PHt +qdr4LsTdBxpM6+/MWvtJqnZQ349DHKYLduZoShfPpWqCpfPkxLXPi+eGxeu+P5HqpEaxhD+fop1f +T9HhH8n/iJpB7eHZSe2xGMchDtMyS2O6bn8P16L22bUsfOo17Nwr4H8Deoe3QNOMfxZr4s/kTxPH +f0qdHyVvk3fIB+L3CfIX6E/eI++D/68QcgJ8Hw89PeRDcH8jfycnoQY/ImNTfGOnnRkjSahjQinl +KE+Sk0eToaJIqJTKoE/LoAqqpGqqoVqqo3oImX5GNXHG8LEz6jOcU4ghmdRITdBfWqmNOqgT+k03 +9VAv9dOsKefsE2d8cCZAgzSUOmcRr7RPXOuFGNYpcXNoAd0K31Eao3E4LqQltJSW00oIyQd/Efir +4FyByHrSSZaS88hJ6evcC5C+CXqVfULzksUDixYu6O/r7eme19U5d07H7Pa21pZZzU2NDfUzhbra +GTXVVZUV5WWl8Vh+XnY4FAxkeW0mg16nUSkVGXKZVMJzlOQ1BZoHfYnwYEISDrS05DN/YAgChqYE +DCZ8ENQ8PU7CNyhG802PKUDMlafFFDCmMBGT6n01pCY/z9cU8CWONgZ8I3RBVx8c724M9PsSo+Jx +h3gsCYseDXj8frjC12Rb1ehL0EFfU6L5/FW7mgYbIb19KmVDoGGFMj+P7FOq4FAFR4nswPp9NLuW +igdcdlPVPo5kaNhtE3yoaWh5orOrr6nR6ff3i2GkQUwrIWtIyMW0fKtZnslXfPvynt51zYieLB2M +qpcHlg8t6kvwQ3DRLr5p166rEoZoIifQmMjZftwGRV6RyAs0NiWiAUisfd7EDWhCGtIHfLs+IJD5 +wOhb00OGUiGykP4Dwg5ZESfUBOfTxwTyBjmE8vn9LC9fGRHIUvAkdnb1od9HljqHiRCP9ie4QXbm +6fQZcy87szN9ZuLywYCfVVXTYOrv/FW2xM6lvvw80L74F4I/OO9L8OHBpctWMQ6t2BVobES99fQl +hEY4EIZSZW3aVxCH+EODUIjVTA1dfYl4YH3CFKjHCBDgY3WwurtPvCR1WcLUkCCDy1JXJeJNjSxf +vqZdg42YQZZWoKvvUVI8/tq+Ep9zfzEpIf0sHwlLA1RKuGlX3/KVCe+gcznY50pfn9OfEPpBff2B +vhX9rJYC+kTOa3A7v3hH8Soo22mx05FZyeWhDF8f5+T7WW1BgK8ZvgL1NXBCD9UlelmN1tf4+qiT +pKPBXVIx2NG0dMDDhxpa2CmeXdrQ4vT3+/HzD7LkTOVJGkpkTElLDwETecL7fGLWMDbLUI6vaUXj +lAxOS1SaymAqtTPnk2O6SN0Yrshg1dmSPsWHoOVCGAfJiEGsFm2+BOn09QVWBPoDYENCZx8rG9O1 +WL/t3YH2rgV9Ym2nrKRnmg/PV6AvQfxwOu3hGsAGm6POdLWK/lmif8Lbctrp1vRp366MQHv3LpZ4 +IJUg8UELgkLLwq1DX6nILIGm2Qy9W6B5KODT+5p3DY2M71y6a58g7FrfNLiqiqURaF2+K9DdV+MU +8zqvb4dzO7tVJmmn7T31+XnQ99TvC9Cru/YJ9OruBX2PwlzWd3VP3zBHuYbB+v59QTjX9yjM+gUx +lGOhLJB5fMzDUpoHngwxvvNRWIDsFM9KxADRv2yEEjEsIx1GybIRDsP06TAOwiQYJohh7AOVZFsF +Kobutsm3nFXPRf2rdg32s8ZFLFCV8EcTNFBLElygdh/lZOqEMrCiPqEK1LPwOhZeh+EyFi4Hw4Cx +EJTD+qRdgwHop8Cg+oiToinyLEnfyPh4T5//qHO03w+mtghkQV9CEYW+Xxpqg3izmAxC8KzEzmVD +LB+kt49dKw+1LusHs00nCFFaEwpIQZFKAWI0i9cwc4SLlkHdQAWK1+8ET2Jnf6I/ym7at7pfNGd9 +grQEqqDaMU1pmN0o3r8rM1Aktk1oCsrQVQwKyBvp7sMQJ3jhZv2oJLkacr4sAKeWDfpA2xKyrBtM +HftSpRNDVkCXKAmvEEXpTJ0krFh8SKVRJhQxSBD+2LEqxpqkNCTv78fMi76rUhHg3vqECnIUnqLK +1AWgHTjVyvICf1dBVlnU77FkukbIvMAF0LOwTIspyeF0QhNqHYLOH69XQUigIn1xBusjVKk0jmCo +nJVcDXrnQz0j498MbPNP+eTnBdjgwAyTOB8Fwyb9u04PSCyM5udlnB6qEYN37crQnPkC1FeGZoIQ +CMt5WLXDVJEeUd5z6pWTVyreYiFTP/zzLESXQ32wknyCyKEh6Ekc1spEvWJ8HKqF7lPwI9zfhz1u +7wj3t2FPFPDhsCcP8FfEB4j38dx76HsX8RfECcQ7iLcx5ijiLQz8M+JNxBuI1xF/QvwP4o+I48Me +BeAP6Ps94nfD7kzAa8NuO+C3w+444DeIVxG/RvwKo7yCvl8ifoH4b8TLiJ8jjiF+hngJ8V+IFxE/ +RfwEM3EU8QLiecSP8bY/wpg/RDyHeBbxA8QRxDOI7yO+h3ga8RSm+STiCQx8HHEY8RjiUcQI4hHE +IcRBxAHEfsQwYt+wqwiQQOwddhUDvot4GPEQYg/iO8OuQsC3Ed/C676JeBDxAOJ+xH2Ie/HybyDu +QdyNuAtxJ+LrmPQdiNvx8tsQX0PcirgFcTNedxPiRsQNiK8irkdch7gWk96Nl1+D+ApiF+LLiKvx +gqsQVyKuQFyO+BLismFnCeBSxE7EJYiLETsQFyEuRGxHbENcgNiKOB+xBbEZsQmxEbEBsR6xbthR +CvgiYi3iPMQaxBcQqxGrEOciViJWIJYjliGWIoYQg4gliMWIAcQixELEAkT/sL0c0Ic4BzEf0Yvo +QXQj5iG6EJ2IuYg5iA7EbEQ7og3RimhBzEI0I5oQjYgGRD1iJkJA1CFqETMQNYhqRBWicthWCahA +lCPKEKWIEkQxoghRiCgQwdNhWwx8cQyMIfIReYgoIheRg8hGRBBhRGjYWg0IIgLDVmbQWcPWKoAf +A30IL8KDcCNcCCfCgbAjbAgrwoIw4x1MeAcjBmYiDAg9QofQIjQINUKFUCIUmGYGQo6BMoQUIUHw +CA5BEUQEHUckEWOIjxCnECcRf0f8DfGheFv6V7FE9AMMfB/xHuJdxF8QJxDvIN5GjCLeQvwZ8Sbi +DcTriD/h/f5n2BIA/BFxfNgCBkb/gPj9sKUC8DvEa8OWBsBvhy2NgN8gXkX8etjSBPjVsKUZ8Ari +l4hfYNL/jXgZE/s5JnYM8TPES5jYf+F1LyJ+ivgJ4ijiBcTzeN2PMekfIX6ImX8O8Sze7wfDlnrA +EbzgGbzR9zHX38PEnkY8hXgS8QTiccRhxGOY9KOY9Agm/QgmfQhxEHEAb7QfMYzYh7dNIPYivotJ +P4x4CLEH8R3Et4fN0O/Sbw2bZwK+iXhw2NwBeGDYPAdw/7B5LuC+YfM8wL3DZgHwDYxyD0a5G6Pc +hVHuxHNfx5h3oO92jHkb4mt4wa2IW4bNnYCb8fKbEDcibsAsfRVjXo8xr0NcO2zuAuzGmNcgvoLY +NWzqA3x52NQPuHrYtAhw1bBpAHDlsKkNcMWwaSHgcjz3JYx5GUa5VNgLPKFr8r6jbfG+pp7j/T7I +90CeBnlKNd87DLIPJAGyF+S7IA+DPASyB+Q7IN8G+RbIN0EeBHkA5H6Q+0DuBfkGyD0gd4PcpVzl +vR3kNpCvgdwKcgvIzSA3gdwIcgPIV0GuV6zyXgdyLchukGtAZiq4j7iTZD7xcqeAq4iXXjJsZM3x +4uFMZlqbEZuGDcy0NiI2INYj1iG+iFiLOA+xBvEFRA2ieljPUIWoRFQgyhFliFJECaIYUTSsY3Za +iChAZCIMCD1Ch9AiNMNQKSNUjVAhlAgFIgMhH9awqpYJC4Fvg4yCvAXyZ5A3Qd6A6vwtyG9AXgX5 +NcivQF4B+SVUyy9A/hvkSZAnQB4HOQzyGMidUBVfBxmhO1HT24cNzOS3oXIuQGxFnI/YgmhA1KMe +ZiIERB2iFjEDi2xGmBBGhkd5nueGBe/9T/IcOQByBITnCeblQkQ31vo8zFkXohMxFzEH0YGYjWhH +tCFaES2IWYhmRBOiEZGF8GPmfQgvwoNwI1wIJ8KBsCNsWEwrwiLcARwD+QjkFMhJkL9DBf8N5EOQ +v4J8API+yHtQq++C/AXkTyD/A/JHkOMgfwD5PcjvoHaPgrwA8jzIj0F+BPJDkOdAngX5AcgRkGdA +RkAegRo/BHIQ5ADIfpA7WO1zY6jjHYiLEKuHDTAVoqsQ56JaViJWIJYjliGWIoYQg4gliMWIAcQi +xELEAkQ/og9xDmI+ohfRg4gjYqjqfEQeIorIReQgshERRBgRwroJIgIIKUKC4BEcgmKLJMK9wHGQ +JMjroNiXQX4OcgzkZyAvgfwXyIsgPwX5CSj6UZAr+JD3cj7m/RKNeS9r2dl76Z6dvZe07Oi9eM+O +XtWO6h3tO3jVDifgwh17dvxqh+yilu29F+7Z3ivZbtrOKbe1bO29YM/WXtVWqj6/ZUtvz5bjW97f +wpu29GxZvmXzlpu2HIMA+f1bDmw5soUfGX9ayNxSUd28c8v1WzgTnOfIFqpjwf4tKm3z5paNvZv2 +bOyVbCzZyFW/v5G+tpFyBRtp58bBjRzE2r8xmN3MYpdutDia9RsLNgob+Q0t63rX71nXO3fdunWX +rLt73VPrpJesu24dtxeOOGGdQtP8xZa1vb9dS8nj3DjRgzzNjQ/zynWHuSSh5B0uKYzTNaCAL4Ai +VsfO7V2159zelbHlvSv2LO9dFlvaOxQb7F0SG+hdvGegd1FsQe/CPQt6+2N9vedA/Pmxnt7ePT29 +3bGu3nl7unrnxub0zoHwjlh77+w97b1tsZbe1j0tvZ0tdFasubeJL/PCCEI88Lfes9NzwiNRDbrX +u7n17tfcJ9z8etcJF3eJk+oclziuc/A6+OLwy+61X2e/277XLtWJB7x6febOTG69YaeBKzAIhhcN +rxkkxHCPgdNdp7tbt1fHz9Ut0b2jG9dJ9uroXu1T2p9q+bnaJdp1Wl6nZX5eL2hjhc06jVcjzIpr ++Jq4pk4zV8Nfp6GCJlbULGiCkeY69Vz1EjV/t5oK6nBO8zvKcSUnKOHEO4pxBTeuoISnPkoJ1QP4 +DKibA9TsbeafoGx7SUoovZ70RNtH5OPz2hMZnQsT9OpEqJt9C10LErKrE6R3wcK+fZRe27+Pcg09 +CRPbexb9V+zeTdz17Ql3d98wf8897vr+9sROdiwI4vE4OyYQpT+6eNOWTZs2RzdF4Qtk8SYI2bwF +/kRQ+AZu2czObN5EIEr0Ez4sxiaGLWKkTVuWbIE04AQEbxKDmW+xGOWT0viPfj6xJP+JD/0/efP/ +tz+2JYuhdZHkJv5XUi3hiZxUkg4yh/Q8TjT0TmIlVfT5A42NGfnyJ8HLER99nmRAa7xTMEo4jdNZ +FyiVXcN3GVrr5NdwPaRu7DevPgtfRzMr40dp/NXRl0f1Y88aKuOjx0YLC6jBbxDFpOXkcpkskBXj +SiPhsuLiolqutCQcyNJyYlhJWXktX1zk4XhTOqSWY37K/+qjuXzTWJDb5q/uLpTSaMjqNWZk8F6P +JlTs07V3BMqyHVJJhoyXZsgjZfWB3q1tWT9R2iIud8SmBLpdwLHvS7Un35VqT50jaTz1OPd6ZV9t +ULZNo+Kkiow7sz3mYKFrRrtGp5FqnVaHS55h0CpzW4bGbnOErEqlNeRwhVhaobFq0Ih1/KTkGamJ +ZJEw+R3re3r7HiXB8dcPqHR0dmBk/HXBw45Cak3ApiEWqrWEVcpAlpL4JAFqCIRDMJwLHkFF1DST +V6sj7mAg4FFqLCSQZZNnuudl9kp7ia2uri7TWllhKDaAZpcsHih2dIwWUXt88YDDdrSoeMdVR45Q +25HFA3hYWACdk3N6Ng6yg3/nboUF0Wh/yGLBeovwfrmWD2SFw2XlFCvLKg/wfsk+tcxSUVhc6VFL +zkk65kk07tJorMQkU9PrZPpAbXF1c8Qg+z59hK5bGsw1S3mFXkMlY1qjSiKz5gYkFxnMKp5XWYzP +jr0C9ribEEkZWKaHREkFuTutXy9340GHymxWEbafmxcuZjucKkcEJjX7CwvlwZFUwYMwERIU+q4S +G/OVsCmTIO+BAkKBonWjUSjeaCWNjxbFR8FIMyvBSJ37PmMyhQX9YNiSgD8rXGooKSv2g0rMzNI9 +PC2JcYGAgZm5cfJQUhZuGFh/yZzkt/z5+X7atPWBDTW2WEO0fKApO/mQraB1xhU3VjbmWxo8VQta +vv5keXu5l17etH5+bbYxkidZlRfJ7rqoJ97dWKJXFs39Av1tpDbHkkw443Vjf8+fVeBIXm/Nb2BP +cOaO/1milgagZX8F9TfsItEnueeIltjoEPGTcKqYYTavNXZLYNL6SGmBWNYCNvEVFPPFso5Fj43W +sS/Q2DEwMufjnzUB0FXIpMUOoCSzrAzMR2ZOtXXWC5hNHo6piJmVRM3LlJa6hVsar3j5ls6+u169 +omx5b6NTKeMlSq1CF2td0dyxrTcvfs6FHc0rW+MapTpDcsQesGdag37LvPvev/cBSr67INMddma6 +wi5PrkMdiAbqtjy4auM3zyv1Z/sybFEC7ZhZ2tNgaZnESzagnp4iRu4OQoiDu4EoiC1VSBvMzQWF +tsspls/J5u2CdIoxUOzsoPl92ivQcrhpliOdYidPD3z37w8lnxetZPbDf3lgfvJEdMnN26748nk3 +LSvkbh8eu6cdDaLr7jfvW3TX5pkfXV+x4VtQ81Am/hooUx5JYImYbXM3CDqF0Wf0QZkcNg3kyPEY +zWF1eEhDO8JhmT1t9nYx35quiJjvCFuTCLLpZh9l5YWGUxmP61kX4Tz0eSSJ5sF9rCkF/IbTDqF4 +Sp1i7HymG+5KhVYplYJRJIvoVQodO9YpktvoS+z4XBgAVKgmpT3igWFAlTyissLAELYqkzeqbBHW +VnaPn+SXgcYi5NGUxuTGEe4mwaJxE49bnq2jHXKbWkNny/UqOHyMnkOM4ycOwbHRaJeNjL+2H2LI +xNJq6WwZrAIPCFlddrFPZUVMFTDKtHbEUCmqTDB8julO2NJUTaVH0bQuoYgq0FI/3a3QqqTi8Sa1 +tygSLvZoQI9DLFRyryfHpk7er7RlezzZDlXSo9KrZDL4ktycF1HZc1Fbkktg7IuTn6Z75jhmNZTK +cjBFVYrKFAnwADCgZk/UrEEVAEYla+68oGgZwcN0GRGIGoZPE/Pr1F41p4YRa9oYJQ5OUdF0aPzY +aJEeRyn2cQqKz5xW2vxElU3VHnZIZghLH0ou0XiKwpFitybpUntQgxpPcThS5FHT4xp3cSRc5NEE +lXqlTAZfnGrsg/Sx5Nn0UTJEf5U+Rq3Sm0GrZpKb1irhbjooKPXzMLM0DtkEw9mfDpiW4XTW6M2a +dIa8RSxDk9mYvDVJ9RI9cD8HaU/fzwwmryIK3TyzqEEz29uY0k5p/Ci7v/CJEaY34Am1MdPrgUap +HNvrz0+pSUNvhQDpFz05TjU0z1vTOTv1jsqeg9qQbYAWWUN+ibkTVJqCAms8rozZbI4RbvmBYKFa +rYSDR0iwrMuuVtkO03yo79j4iQP6ADe7cGT8hOBjR1Y9+9bgtzVeUBiTebO7vL0TRsBmPcx42HSn +qAhtylCsZ1+Gyhnx4mJDMRT74Od7l2mVF6BsUgXTKxqY1mrF+RUtZjMtUZeyDSp3QShY4FJzyS9L +Mr0FWVkF3kw+eQun8sQh3K0qy38oVl/gU1ObhGZpvDkVoX3OiH2KDbhPHdcYlLyUtWjXqT9MhF9a +XKYLVOZ+NMbT3KqgTgtXieMjtHUe6sFFcsjOVN8YlB3mbiQG4ua+JyiIISTaAkwxo/tlMnVgZGL2 +SaMHBHOXeqK3YvOlKNNuasz41y5Md3GB0/s1ydRBk2+87Imd56WagLowmxbGujdv7clLjhY0d+Ss +P7+ut8zFX7H2W5tqkssmyn5NPC631i65ZGljX64q2Zo1oxdK3jlukd4oDcGYUE12Y8n3K/2Z2eyl +CuIqAhzI9Cs1+els54/QRYLK2h2SlIvlKhcbh2Z+qnEcOyqOc5XiJGoUDlhL/gzXgxqkKQVEUmup +dEsTZ51ScdY5ZTIlvVGu1mb411x0aXnsS523/u6W9s673rj9q7+9ba41T8ipHZwZsSiTG30dOweH +Luv0+2bvHGK8MJhnkwcbhurM3o57Tz1856m9i+d846/fOue2y87LKatwaczF3C9WPLh1Zsv2+xas ++c4FdS0XPZiylg6wljLSSO5EnR3Qxww5ysPcszCjKufuGM6pM4hvU8T06YLrYZq9XxCsM9IBM2Cm +fUjwd1nTTWfCBsRJ+zGYaBlQgfs+WypT2l6Ej/EfMymL1cOn5vBWq8VCS8KRcDhtYR0Znqqi3CK3 +WrLZnF0o5M5LGxtM0+YW1zvn7Dgn5hcW17iL87ONa3XK5MNV9abi/POvrOipcGWpdEqJRGVQU3/h +7GJH0jhhg7fmRSS8quycrR0z1/TUGrXZla2x8XCAXy70ZUplya86CxtZr103/gZMfkKklRxO99oz +uVsPBouCRWonWxURdYx1UeVESfMPGcrBWWrSKqkZofmCeqZTmtNtEW3MwramBWnaxmA4rByNGnBa +px9lTVWc442Kk/7Y55RsuiFnxSRp08WdgJgs5T99USDjr5l92XeXNWzqq3aoJDCt0xZ3rmstmF3q +KuhYumppR0HTlrv7Y4s6a01yKcfLNSpVQfOi8qgQNcfnLl+1fE4BvXzl7eeWWLxZjsKYN9eh8mf7 +rbm14by6wmjBjN7NXQO7B2Jam8ektQYc7myH2uV3mkMl7iie3wR6V8MM8U2w7CzSm+oFiQxmiPtt +BllmWg+Z4vzMPaXjKqLxI2NHmaH+w1iTs7fJ+Ue6YYuj55vilPZxNnaykT35uBKnvEr+ejbJldzr +zrGrT41OGJNRbc9xe3LtKjZhg3Y5C6zmfP6/STERaE5qNaiwloxwCw+QSIRUjXBNgt7AW+l7Vmod +UZfQj0poCdspV7DJaUlJbGbuCLUJzteyKL8ja3cWJ2R1Zg1m8bosbxanlmRlSdwwsxO0aiif26an +He6TsTbWEmH5TDtmHBfUHRJii6en+1Gcdg0MLBlgLTkeHdgwOrAB2vaRSraeYC1b0P0fzo3YR7AO +NhwuLZ3S0RaXpvrXVIhE7HrlaKmW4qKycv58UzQ3P8dQvnv+rK3nFMzYdmDrOYbIzIK6ZbOL9SqD +SqZ0NS9eV7365sG8DwdnzC+zz6or7Y95tXq5XK+dVV0faj2vZc6m9mBZbl2uyZXl0jrCVm/QHfAY +c3qvXPRKZrDYXyGUlbB6vXj8DQmRrie5ZAa5JVWvSn/ZYW4QppFR7nIYns3KslK/RFqQNj9YmbcL +mnCbs1k/u1JsrZXsgaIg7Ui31jo20FgrUwM1q4xDnzWNyabORcwfn1DjBpI0pVC5wWIRe1hSsvS6 +hflzZjUFwXw93hy7Ug2znlCBW53V2NiSvWzXOdnJU4bchmJ7QXGZp3SotLAx30Tf2vrklS2GcFXO +kNjHKnUqaUCJaxdl0gjzJO3cK/dvqfzCvEJtVll28heNs4o6V0LLbhl/k/fzL5PS9Ig17CKRJ7nN +4j6Jl3gnttOC7JGpsU3yGG0hhWCNKlimFeaJxc9jz10FRUd6uyM6sWFypCi1YfLvpTRt5yTdR8qw +i5RN3TaBokjltqq2c2Ln3n1eecMF9y/N7mgotSikvElvCJe0FC1d5SjuKC5prwhrFGq5JOEI2HRW +v0Mv7Diw+cpndtZCN2jR2QL2qjiY3q03tHyxLeQNe5VOsR9ph37kBelaEiaV5OaUtlTOysPcYhjd +49xGQWn0N6sqI06JNjdtLNBWWwWFrW1iF631gKDtkM5O935oKXXi/gk2fcVnTWPqnHpqm4UBfcLo ++HB46uyonH9Bacvx+LLtqqZbF63c3Z9dvPSGJe3ba1SiybnUJ8uWlRXOipozcxpLHIXFZb6stHkt +a5sHFrWMmd2MavqHtK2NlTS2FM5bUVrxhe4iXVZ5NtNbG+jtEPS/UVJCpam5pNHoz2PvCUZLJCNM +c34+z5jHOfOekbCuzqqB1bJEL+Fmd0oGJdw9koSEk0hccdAIW0gzCj6IEz8ebrP9lWj1Ws7AaxU2 +Ne1Q2CCC4u+CK21E0WPQvY2merqBDbDeHV08wGZSr8LwHhc1/p+9t9gtyAL+KXZrnm7dnDlSJtaT +nD+UExz7nbN6YGb98tYCnUKdwXOSDE3Vgs31W/dfUF17/re/sP7ulQXv8wuXFMyK2zl6MpZXOTAz +y2g1yjP9dovXotParIaa7Y/t2PrUFc31W+5Z7PvCtuCM7ji0ffv4Se5r0gtglbkpVSsWPYFp1JL9 +Bbkh5Qh17y+b5QiPTO5zeg8JBS2+2fqWiRllUR008yPFY0eKj4i7f8pPedGUrlG0RzNqQTZ1MgqD +T3rMEbUi4b4myVDK5AZ7ltUZcajvY4O/yXif2lUUDBa6VeuNRikErQt2bO2KNGdrFRLJu+6AUS7P +kBtC1dF5Smu2uzw+FlPiJpmSeyle7s62KtsXfnlhTKPT2COEJ87kjfy9/M9ILZlDllAutfqeqyuQ +8xWBtuK2Z9p4bxtt+92PYI2ppuofdVNPN7V10+6/HDVTq5kSs97M6czmwQr+7zUtub68+sfrOVJP +649WtOkWUj2/8AXBNxcHCrCNutGBgczKOnHkZYMweAdeFiGOH06hd+qdVW30n9988t419S/Uc5J6 +qvuH9188mYNpGRhIj2BQKRYLjl9hWHTBOG9NrRDSJlsOs4SSMvEb+xtYRNCS8MSsgD0BCEciWj7l +4++16FdbjCVDX+6JzjGrjcWxX87e2hWt2rx3y8ZvnBs3+Au80XhZNJBbvvTqebkdfuo0mJNPdLaG +KkKZnbPCFSFjdUvdfofXKFuxqHJOgYkfLIjZZvjnbOuOmrWaoMUd4jL4UMPimvot84uCQn+pv6a8 +yGqdG68eigSWts65sDdfqchL/r2l0x6t9DbOteWWj83PL+CkxoDPoy8qsYbjbLVxMcx6X4L5RRFZ +m15tqLglw0W5phFucD9MMKcuvzoEhZDfFmy2z8aOOb3iwjUbVOXwp4s/fVtLHOHkZ9iNEx8fQH/+ +ktpVGAwVutTGYGW4YGlpeq6Q5syrWhfu6MjKShs9HZvZVupubhjbmw6ZOk8Q6mpWfWUZ67PXjJ+k +u6VzYCLlJ03pJwMW7iniImaYXymJl154ULDrWzH3L0PmJ58BfPzcGTfrjGwMZ5YDJkO3n55zY21P +b/WM3p6aibzz22HcgZxCKQpmV1W0zq6uxFqi26GWzKQu1Vp1GjOFSYVKSTWEqiQEaottJDZjdlIb +ieKcd8C5Px185u3Ej+Uq6+NqwzzIFDDCdZI9qfVRs5H1ox5PkZK90d9ZG2Gz0iKin2IAw+1tUx+2 +dQhaYWZbbXN+RWv+7EmrgNXjlIcslcfYMzv23A3U/G8l9k/s7JMMz4yGZ8XJq1mmULsKQuECt8oQ +KA3lLyoDPQWZngxZZcHYoglzVDpyvL5cq7Ltxs7yvqYiQ3ZHe3ukf3u7b0KfnCH/NMP8eAh/Ufro +3M5Oa7QmFK2NGGvO3dUx0VqhDorIpak6yDUypXvERks80PhO7IepptgI1elGqIJGmGsPtk7oKBM1 +lNqpSyv6X7ny07Vg8z9rwRMqu637n7TgaWoBdQxB+22BtZEEtGEkkckneyZuC8xUPfCthMF/4uGU +Q1Do2gK21O6ja+pKZuqTvU97xZSxPT2fkZ62KyeR1GwfuXBrYnPFjO2PXHhBYlNFcsxc1F1X0VPm +tBT21Fb2lDnoGxsfv7qt/uKR8zc+cVXbzItHLq1fNy+WM3fdLGB+zpx1bAWYvFlCoJRTV4D+MmV6 +BXjFP1oBturn/tsrwH+WxtQV4BlM4JNWgDAJXxyZOaPGN2EL9hyvB1aCkfY53fGlbAV40pDTUGQv +ZCvAwZLCpjwzHd361JUtOm/Mm1yU7pkkv0kbxursGTmmjiuHt1aunleoYyvAVxpai7pWYrvhDou7 +I+tT7Sasgx5TUBOHTulVxpW8hleyya+KPcmi3YJSiLaFdWZfq1m0+3SfsoTNqo+kWozyn8c/bQp4 +piYi6kfGHYYZrzLDZPdkmnPzoaGc1kACtRUVLo3HZ1NJJRzfHow5lGzKF6zJGzv28SayrmhmWMfL +FUq1mT3Nax1/g3sXSt9K3pjcUYxN7Cg2CllELYnR2PFyGE6UfzKUC6wjKPeVc7y4DairoTXsKYhT +3Ao8zrYB2yx6tlNDLFQvsbw7YRTsSRvuBQ6Im4FLBqL60QH4m7bRKPj+l+/2GfYfuXcrV13bXbSw +pcCilmSoFaqo0FuWVRoxhWZ0dHXMCBUtvqond66QZ8yQ8LxcnaEIV7YXZBX59OHauV1za8PUM3vz +nIjOajPn57kDZrnd49A6sh2eqM+VlScsqBPWzM5VZ5p1OrPX6swyyc02s9YRMHlzfS5/ntAPtWQd +f4u7VrKPVJEbsZYeMRg01TkkkM9GV+u0xwje/YEWtyYdoGGbDdaWQvaGuCBPKQca51GxayseKzpS +ZMBl4KMk/7Mkgr295MxLlukLG0t6ucddq8oMxMtd7V9syVpjNDGz/ILKjaPA95XiquaZWLXJZzfI +ZSqZdHte3AgTn/DcC+bRH+Ga5Tlo4lIpNPHncFWTHGhtlSvkcnMQtLWN7VPwz8JIuCbVolUR3KTw +cksEnTG/NaKS2ltTD4phLDttO4G1ULHbF1cg2k8T/Ux7D5OTVbHXLyuf3IV4gXVo/hwbDG7zFu3o +8IuFhyadGYIhcKg8vfuQNXVcW/XlldxEQDKjWRwEua50CJTbAjOA/VDuvPQu9bDe7x3hLj8kmP0+ +mT8wwg0IaoH4/NmtfpWjVZXqjuqoPe6wvQplyax06F91jLJJuPOR0yKl2o184lnl5OhmNVrLjal3 +9/ZTXipJvi81RBrKShvCBmnyfZmcqlyFoRz20OR5meyHvMYVD4fiDiV/t1RrsGg/+qXBrJZI1WY9 +HzH5tDIojESqMKjHNtjt3HVqg0IqUerYDCcwflL6MyhfE7k11Qpc7sxYXp4+d4RrEFRufYVWL+Gr +qvQ1I1xU0Ai8fmZrcau+QKVrqRoZf3E/MA8oaNlBlZ63hlqtsxWz06++RaMwboEubMdEVdjjmZVQ +tTb9MdFTWZmJO9MszTNcXYcaksn5lIL4yORhemU4TVdTDqU/k2W8LdX7ZxQW1gb0kls4bpdEF6wt +LJoBvrcUUrCPUHaRS8Xv47gHeY0jHgrFnCp+mOe+w7EJaCjuVPL3qHyeSV1yHoVi7PeTmnX7VUqd +QiJRMsWq1UyxTM065dh5qpRPotCBln1gRbtBy3FyDWr5cZLF7SI2EuRyBUXMBo5YVeoRbkjQCezd +Rt6i8sVJIKCCqf5BFuZT5bQGVAZ3q2FyajjNyphqHTb9q9BJM2vLnHw25BTOeC1rXpb0I7uUVsuN +oNbUbNwo6tFiAe3zV2RQV1VBfrlXJ3ngAYnWXZKbV2Kjig+PK6ijsjCv1KOV3n0Xr3bkR/JKrVT1 +mxIwQSmv0CjpjOQzSo2Cl2otBvoI/XqmXSvjZRpl8mWam6HOkEi0dlNyDWtnyZv5A6ChIFmFGjpE +FQotccB4WX9ICDp8SodthNsEqtA6vK12pbFV2S6ZS9rTa5ApRpZqb+zNWVZ49RmjQ+n9PHYq5cZw +OELDJelyFxvFDQeLSc596TxFZ0d2gY2Tb9WYpcmjGltlPFrk0spf4p+WGfPKo5XOjOQRu0Wutxlo +VGbX8iWBkDmDV9utY3u4IYchI8MSsrN21gQL4Lf5p0mU3JtaUSp1IarX6ahBph/hHj3kNYEjYfav +ByhChvQoYRihbkFpb9FNvOflhilhe2pKWFQnPhAbPYqVXVhAoPYXD0CFT6T9LyUlrmAXD0y+ciJu +xFB/agQSX4QSn+JSdsi9zZ6MjT3qdPMKnZrOSR4xWqUwhnB+rUkjl2RAj3qADipg3niuO8emCObE +Mt1Ol4GTFJS6I1alTO8yF5q8Lpd+bCzDEmEjcvLX9EHqJ05i3qeHFfa1+zNVVhfRHzsKZXy2sCAk +vu6cttSJV5kfzMh0ma+UG2xZDndQT6Xb9VkloUCRXzeSPbOq3P20UpshZfmipruyci1yuSUXZvn3 +jL9HH+P3imsZ5z5iGuFGHlF6ArDw0rWQuqN1cMti9k7F6asOw2l++pjWX5aTU+ZXq5Ha0/28Jbci +qNMFK3KjVUG9Plg11pJbyQIqc3OrGauZfazhi+nfpBdA2U37nHSE271fJbPMIiwfY1B0Om1rrBxb +pklOoaylQSirVi7qQG8P2DxBvURSeWeqqFkRpoPvKdnOpUqvYlqGOz2YutOElvFOTMn0X1SyVBtJ +aVnsCEHLcGurXG5lWnbyVbxVvFc5Ce7Li7F/e8DFbjpwKNOliliL4b7FR8GEXx59Vj/2iXeXnjGU +t8r1DtNOuc7qszp8Oio5X+cp9Ptjbm3yArneabxUprd6rQ6/jkrP13rxjFQfFqrKXE+l9KGm+juy +cpiicrI+6QSrnWp6HVfBDRAdMQwTuepRMFIJiY9S1sOI++645SS2igqLLTlot1js9B61QS2lH1bF +4pUVMaVNfG7RA/OoF6VBUkJayPH06qBt/OlHdFwHaaPRuhFuzwG1y6UufYy7lBD20JWdYT/eUVMd +r65KN+eqEVq7v6BAGk5tQUzdHq8TFMb+RrGZN7KfWwrSJZNL6fRLQ9DUjw1E2fMK8eWhgajzIGRA +x39edwDNwC2mLgwkpy8E5KctVlMref7Fms3fWbfgyqW1Ia0uOufCvReEO+pjugwpx2dolepwWWtB +1/pmH7VUNszJW3pNf24ymZldH3eVlRSYbfFZ8VhTzEYTS7+5rSmn44u77l04+8F7vrpWUGgzNXqj +y+TNsSo1enXNuVfP1rpMmrLl164v7ih1KmFoWnNdTyCrtpsQnswQ64m9q1ROZlFPuqZax58+xOqj +lRYc5tYRE8nm1glKjy7gMYFTVjzG7RErTYmVpuNJ/Qh32QFl6Qzp1PWEUVDY+5tE9TWx37xOU1/q +lSa22sI1HHzhSA51JLQqGqiinipm0gyBKiVUNovKmqmsicoaqaycysqorJTKSqismCpiVJFPFXlU +EaWKXCrzU95HVZB3Hf8v5gfrkojbm1M/VPyetjVTHuOnvz6FL+3jM1VrWRl7bz+9a1/Gvzhja2LT +Fx9cX+GfOVRXPK/KU772/vPW3LY07q2YVzJjsD6Q/I0pWhftmWfOay5oneuxl3aWxppj1hXLlw7R +hX27lhTm9e7oKh/qbvW7ZnYsKptzyUBRrGfLrHh/5yy3r6V7MTcjUBExdTT6ygpijujSsUOhGWVF +DntR+YzAnHk9rEVWQk2/DDVthLH5uXQ956fqOZ+aHuNuhio9NqVKfYchSEmcuB/hTOuRvY8OrbU7 +ZIPQiTfxeqe8tiM2jom6xfrMhHsofFShpJyJcix958hnTBi3nyHZM+2VSabslUn4l4s2HPzSFd9d +mVO84eBlV+xdmZ38UGn25lVkVXfkZ1ribSWRmnyPUc5dc8fJxOKFez78+u2nRH570e5VLWARG7+z +YdfBNVF70ezlF0PfdBM0mYTUSmLkYGp2o1HkUEU2zYhQmkkLxFdNQH9CAeVJzgh3w36PTQUzk98c +hECDMXOE7hAUgXk5Oj1VSfXs57kT78BCoYrqxmBwih49Usze/FkyECWi4TkFW042zYH7TLkVu8On +SY9Z9ABJG3BqwpN+IQWWyDJcXpSHUpvSBnHESchUWsVYWYYWVtBw9JcXrW6DjMvQqqlFqrNFvOG4 +LeNnCp1KutwVYb9wEn8tpeLbNqmkhtywzWvRZhyQSHnKy9WKUz9jr8pT0ge6exzsr5ZmpnSnleRR +CTTZKqqopCphJGWLArWMcG8fKg6BI5WPcW8T1fibaJYqMBtV7ghdfchQUenzVZ7JhFYLmmKLLNat +n9hd7J/ypnERbuxExV/vVI6Kw0N0cmIJOl8sNnenYJyWO8iVjv887zzZ1dDTK4bNe057V0g20c/I +xde6HpeyKanN4jMpZHq76bWGeTGDOac2t3phU0yj0GRIeZnS3rD0fGHFrcsLbbN3bbyVJmH1Jlvj +znGoMqx5AX88FDCfaN60pDPor86ze0JetSueBfMIgy0UsBUv3NFSt333ng13qMV3qnvZWwhQd310 +Zmr1nDGLKpupakG60hbQwhHuR4JmTnd4jhCeMycs8FrnY9wb0KW8foBF0LJn/2IlakGT2qbDdD6p +Jgq6+JChGpylLKXQsrRCy1jTb+3OG6ESweDzSVvZK4K0Y+I9wfnT+gXxF1V6Ub0T7yCyqj0GY4sV +QuKGzMrJCnYKmlQBIOM6/n8/M5O1ne6zZOKzu4kNRC4w+Z5YOuRM1W/28PyhtstH1tZv7q/KVMh5 +vV5ZOHvlzPKeanegafWs9ZpMtVSqMqg3VC2Y4bNEG2Mli1qL1WwNyskUptrFF7Ys/uqyYk/VOZWN +57Vn0wuHbllZanR59CZnjrsg5PQ6HfGGnPyWYpfcEvG6Q6YMZ9GsqL86aveGfHJT2GP3W/TGcNCe +171tdvXKzgotn1HauQLGlyCs/Y9LTSQXesf3Ui3cJI9ReZTKXFSup3ItlWmoSuwkVcwQCkD1MT+s +Cs89EJFISP5jnIJYxt8VNHDS4oxNrN/mH5BAKaMjdMUBwT9PmX77EbRcPBY9ArNq1oDZMgYXdtHU +8O0UyiI6GonRSJSGXTSipxEtDWvoGfIkZuXT3xFrc/osAR/2TyxfSicaM53sWS00QP38cXPmJrWn +IMzeu0gatBadnJdrlPQGqS1aHy9uiZo26a3J1VxyDz2Hbi4ufTO9S/em3B6P+OLhLCP3A4VGIWEv +4n/0QSF3+djDbN48CG00IdWSWvJ6qo1Ky6i0dFrHWj7CqQ9mF2UXad2PcUfEGZxYE9gmq9iL0FlZ +0qlWv3w4r0sxQpc+YrTZUj9Nm7R18ed5+Go0zrOjE5vx6XZmzC2jueU0lRWxF/13bjO915xsStM2 +49ksLDDtl2Cwckk99ecTrVcc3lhz3vxyA8yzJQp1hjKnYbChakl90COsbK1akuu2e7O4FbCcl5pN +yZJAU3j1feuq6P2rH9hQo7NadZn2sIP9JNjqstpKOysK2kscaneEK8oOqB1RT01Z8s8SrnDJbjI+ +nl4DcTL+x4TVUBe0kMNQQ15yV7qGMqnUQFX+dA35KbSG5/fLZGbDYY5dZE7XkBkUZ5ZO3eQA03R0 +qaa+MMxsX3wxa4r+talbQNI6/h9ef1oXld6snb4twh+WyNUZyfkyY1ZppLTWzWXQH4+9ZjazFwt4 +mmnTyiV3u6Mhv/GjkEav4GHNauDfLa/xRF1quS0PdJJab4BOXiBsVloP/qdgZCkg9eQX6VlpY2qd +2EjdMKp8dT/Ratnvv6ZMTatHuG2PhATRVoQRmr3f55NPtadcQZHbPWFKMC2Sz5860RcXhqNHmMKm +LgsbIWmBPSNSQt8+mbigYKnrTxsP/uEt8B5T1oaS0x8alU/7CYZk+lPeMv4pff7cHfu3R3ubCy1K +Hpq7Oq+us7Bnc0sWF7us59zrF+RUbfzO+gVXDc0M6ZKnbAUtBfHGfIsxpz5edS73/bnfvveGtYI6 +02TODvqzLXJtprZm5ZVt7mjZyhsWDd23tT53zrqr7ypac/38oL9mXmFpV6kjwP5x1rvQ0Y5PdO9w +l01xb6Hjr/i4k7imuOdEN/6PnHTOpJNlfip3new6eY78FXQZt0xxH5x1n9UpfvdJTvkllf0M7iA6 +9aUfdxrV5+u0hjO460R3/J87XXiKe12/bpr7/Zmd4XLmMvmUe/njzrj2M7k3zuRM/Wb1hLvToplw +d591Z91ZN8X93PJzq1t086xXp9xbn8bZDP+XuT/a/mh/5d9zjoucDuff3Er3jz03eu7wur0h71tn +3Vl31p11Z91Zd9addWfdWXfWnXVn3Vl31p11Z91Zd9addWfdWffZnfiMH/8HUBPhRV5DZOQC8X2I +cn6Uf4t/m3+HP0Ek9MvUQ8+nDjpAnyU8fw6JEwNp5N8j59Ad9Hv0Gn4BfZrezr/PLySL6Tp6kGbz +G0km1VOOhOkWfgn/F9pJr+ffpc+RWrqA76UvkDyygCynOmIjLtLPf0Ak5Fq4r4T9H6OEnCgfH4dv +yr7BLyHkP5wbIt43E/TDEfafpqoJaRg6b/XSjavz6tedt1w8S+j1REoyyKf7nBbvBDkxPi0g9T+x +SrSTQn8K/CWx/styEdktqSFzzyRSFdk9Vfg/fUp56MwiVU8Kl/XZhV96ZpElPz+R1KNId5BOyaVw +PEX4H5K6M8pfifqsnJX/uLxHZv2rImknF/P9pOXTCMRtnyZy0vZphLua2P//LPzzxPlphOkqLfRD +suZzkovPJLLLJu91RumA+vhXZMq13C+mC19IWj+NcM8S639KIJ/bPq3wPyIW6V9J4HThHyY+/sfE +8jGJkaazclbOylk5K2flTMLpYRxiUkrumRA9WTMRnhL+QpgbfE7CbSLVZ+V/T2B93ANuxr/pKslN +pI/0kiAZhNS6IKSekNReyCd/2Fpd+sSGfYm9jy3R1XxA7Li4P/zni9jvJshLuos7T70ytlvxlvwH +EFch7iHA5/8DEgcnLgplbmRzdHJlYW0KZW5kb2JqCjk1IDAgb2JqCjw8L1R5cGUvTWV0YWRhdGEK +L1N1YnR5cGUvWE1ML0xlbmd0aCAxNDk0Pj5zdHJlYW0KPD94cGFja2V0IGJlZ2luPSfvu78nIGlk +PSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4KPD9hZG9iZS14YXAtZmlsdGVycyBlc2M9IkNS +TEYiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSdhZG9iZTpuczptZXRhLycgeDp4bXB0az0nWE1QIHRv +b2xraXQgMi45LjEtMTMsIGZyYW1ld29yayAxLjYnPgo8cmRmOlJERiB4bWxuczpyZGY9J2h0dHA6 +Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMnIHhtbG5zOmlYPSdodHRwOi8v +bnMuYWRvYmUuY29tL2lYLzEuMC8nPgo8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0ndXVpZDo1 +OGRmZDhiZS0wNWFhLTExZTctMDAwMC02MjU4M2EwMmRlOTcnIHhtbG5zOnBkZj0naHR0cDovL25z +LmFkb2JlLmNvbS9wZGYvMS4zLycgcGRmOlByb2R1Y2VyPSdHUEwgR2hvc3RzY3JpcHQgOS4wNicv +Pgo8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0ndXVpZDo1OGRmZDhiZS0wNWFhLTExZTctMDAw +MC02MjU4M2EwMmRlOTcnIHhtbG5zOnhtcD0naHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyc+ +PHhtcDpNb2RpZnlEYXRlPjIwMTctMDMtMDdUMTY6NTg6MDQrMDE6MDA8L3htcDpNb2RpZnlEYXRl +Pgo8eG1wOkNyZWF0ZURhdGU+MjAxNy0wMy0wN1QxNjo1ODowNCswMTowMDwveG1wOkNyZWF0ZURh +dGU+Cjx4bXA6Q3JlYXRvclRvb2w+UFNjcmlwdDUuZGxsIFZlcnNpb24gNS4yLjI8L3htcDpDcmVh +dG9yVG9vbD48L3JkZjpEZXNjcmlwdGlvbj4KPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9J3V1 +aWQ6NThkZmQ4YmUtMDVhYS0xMWU3LTAwMDAtNjI1ODNhMDJkZTk3JyB4bWxuczp4YXBNTT0naHR0 +cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLycgeGFwTU06RG9jdW1lbnRJRD0ndXVpZDo1OGRm +ZDhiZS0wNWFhLTExZTctMDAwMC02MjU4M2EwMmRlOTcnLz4KPHJkZjpEZXNjcmlwdGlvbiByZGY6 +YWJvdXQ9J3V1aWQ6NThkZmQ4YmUtMDVhYS0xMWU3LTAwMDAtNjI1ODNhMDJkZTk3JyB4bWxuczpk +Yz0naHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8nIGRjOmZvcm1hdD0nYXBwbGljYXRp +b24vcGRmJz48ZGM6dGl0bGU+PHJkZjpBbHQ+PHJkZjpsaSB4bWw6bGFuZz0neC1kZWZhdWx0Jz5N +aWNyb3NvZnQgV29yZCAtIDE1LTIzMTUtMDUgLVpXRVA2MjI3Rl9Nb3ZlIHRvIEVpZ2h0IDIwMTcg +MDIgMTQgZmluYWwgY2xlYW4gLmRvY3g8L3JkZjpsaT48L3JkZjpBbHQ+PC9kYzp0aXRsZT48ZGM6 +Y3JlYXRvcj48cmRmOlNlcT48cmRmOmxpPlBldGtvdmljPC9yZGY6bGk+PC9yZGY6U2VxPjwvZGM6 +Y3JlYXRvcj48L3JkZjpEZXNjcmlwdGlvbj4KPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgIAo8P3hwYWNrZXQgZW5kPSd3Jz8+CmVuZHN0cmVhbQpl +bmRvYmoKMiAwIG9iago8PC9Qcm9kdWNlcihHUEwgR2hvc3RzY3JpcHQgOS4wNikKL0NyZWF0aW9u +RGF0ZShEOjIwMTcwMzA3MTY1ODA0KzAxJzAwJykKL01vZERhdGUoRDoyMDE3MDMwNzE2NTgwNCsw +MScwMCcpCi9UaXRsZShNaWNyb3NvZnQgV29yZCAtIDE1LTIzMTUtMDUgLVpXRVA2MjI3Rl9Nb3Zl +IHRvIEVpZ2h0IDIwMTcgMDIgMTQgZmluYWwgY2xlYW4gLmRvY3gpCi9DcmVhdG9yKFBTY3JpcHQ1 +LmRsbCBWZXJzaW9uIDUuMi4yKQovQXV0aG9yKFBldGtvdmljKT4+ZW5kb2JqCnhyZWYKMCA5Ngow +MDAwMDAwMDAwIDY1NTM1IGYgCjAwMDAwNjAzODAgMDAwMDAgbiAKMDAwMDEzNzcxOCAwMDAwMCBu +IAowMDAwMDYwMjQ4IDAwMDAwIG4gCjAwMDAwNTgzOTAgMDAwMDAgbiAKMDAwMDAwMDAxNSAwMDAw +MCBuIAowMDAwMDA0OTA4IDAwMDAwIG4gCjAwMDAwNjA0NDUgMDAwMDAgbiAKMDAwMDA3MjU0NyAw +MDAwMCBuIAowMDAwMDkyMDUwIDAwMDAwIG4gCjAwMDAwNzM0OTcgMDAwMDAgbiAKMDAwMDEwMDAx +NiAwMDAwMCBuIAowMDAwMDc0NTE2IDAwMDAwIG4gCjAwMDAxMjExMDEgMDAwMDAgbiAKMDAwMDA2 +MDU0OCAwMDAwMCBuIAowMDAwMDcwNzQ2IDAwMDAwIG4gCjAwMDAwNzgwNjUgMDAwMDAgbiAKMDAw +MDA3MTQ2MSAwMDAwMCBuIAowMDAwMDg5MDAyIDAwMDAwIG4gCjAwMDAwNzE4NTIgMDAwMDAgbiAK +MDAwMDA5MTUxOSAwMDAwMCBuIAowMDAwMDYwNDg2IDAwMDAwIG4gCjAwMDAwNjA1MTYgMDAwMDAg +biAKMDAwMDA2ODU3OCAwMDAwMCBuIAowMDAwMDU4NTc0IDAwMDAwIG4gCjAwMDAwMDQ5MjggMDAw +MDAgbiAKMDAwMDAxMDQ5OCAwMDAwMCBuIAowMDAwMDY4NjYzIDAwMDAwIG4gCjAwMDAwNjg2OTMg +MDAwMDAgbiAKMDAwMDA2ODcyNSAwMDAwMCBuIAowMDAwMDU4NzYwIDAwMDAwIG4gCjAwMDAwMTA1 +MTkgMDAwMDAgbiAKMDAwMDAxNTgzNyAwMDAwMCBuIAowMDAwMDY4ODEwIDAwMDAwIG4gCjAwMDAw +Njg4NDAgMDAwMDAgbiAKMDAwMDA2ODg3MiAwMDAwMCBuIAowMDAwMDU4OTQ2IDAwMDAwIG4gCjAw +MDAwMTU4NTggMDAwMDAgbiAKMDAwMDAyMTQ3MSAwMDAwMCBuIAowMDAwMDY5ODc2IDAwMDAwIG4g +CjAwMDAwNzQ4ODcgMDAwMDAgbiAKMDAwMDA2ODkzNSAwMDAwMCBuIAowMDAwMDY4OTY1IDAwMDAw +IG4gCjAwMDAwNjg5OTcgMDAwMDAgbiAKMDAwMDA1OTEzMiAwMDAwMCBuIAowMDAwMDIxNDkyIDAw +MDAwIG4gCjAwMDAwMjY4MjEgMDAwMDAgbiAKMDAwMDA2OTA3MSAwMDAwMCBuIAowMDAwMDY5MTAx +IDAwMDAwIG4gCjAwMDAwNjkxMzMgMDAwMDAgbiAKMDAwMDA1OTMxOCAwMDAwMCBuIAowMDAwMDI2 +ODQyIDAwMDAwIG4gCjAwMDAwMzMyNjUgMDAwMDAgbiAKMDAwMDA2OTIxOCAwMDAwMCBuIAowMDAw +MDY5MjQ4IDAwMDAwIG4gCjAwMDAwNjkyODAgMDAwMDAgbiAKMDAwMDA1OTUwNCAwMDAwMCBuIAow +MDAwMDMzMjg2IDAwMDAwIG4gCjAwMDAwMzYyMDcgMDAwMDAgbiAKMDAwMDA2OTM0MyAwMDAwMCBu +IAowMDAwMDY5MzczIDAwMDAwIG4gCjAwMDAwNjk0MDUgMDAwMDAgbiAKMDAwMDA1OTY5MCAwMDAw +MCBuIAowMDAwMDM2MjI4IDAwMDAwIG4gCjAwMDAwNDQ3NDMgMDAwMDAgbiAKMDAwMDA3MTA4NyAw +MDAwMCBuIAowMDAwMDg3MjEyIDAwMDAwIG4gCjAwMDAwNjk0OTAgMDAwMDAgbiAKMDAwMDA2OTUy +MCAwMDAwMCBuIAowMDAwMDY5NTUyIDAwMDAwIG4gCjAwMDAwNTk4NzYgMDAwMDAgbiAKMDAwMDA0 +NDc2NCAwMDAwMCBuIAowMDAwMDQ4MjQ2IDAwMDAwIG4gCjAwMDAwNjk2MTUgMDAwMDAgbiAKMDAw +MDA2OTY0NSAwMDAwMCBuIAowMDAwMDY5Njc3IDAwMDAwIG4gCjAwMDAwNjAwNjIgMDAwMDAgbiAK +MDAwMDA0ODI2NyAwMDAwMCBuIAowMDAwMDU4MzY4IDAwMDAwIG4gCjAwMDAwNjk3NDAgMDAwMDAg +biAKMDAwMDA2OTc3MCAwMDAwMCBuIAowMDAwMDY5ODAyIDAwMDAwIG4gCjAwMDAwNzUyMjQgMDAw +MDAgbiAKMDAwMDA3ODMyOSAwMDAwMCBuIAowMDAwMDg3NTM5IDAwMDAwIG4gCjAwMDAwODkzNDYg +MDAwMDAgbiAKMDAwMDA5MTc3NiAwMDAwMCBuIAowMDAwMDkyMzEyIDAwMDAwIG4gCjAwMDAxMDAy +NjIgMDAwMDAgbiAKMDAwMDEyMTM1MCAwMDAwMCBuIAowMDAwMDcwMjU5IDAwMDAwIG4gCjAwMDAw +NzIwNzAgMDAwMDAgbiAKMDAwMDA3MjE3MSAwMDAwMCBuIAowMDAwMDcyNzk1IDAwMDAwIG4gCjAw +MDAwNzM5NzUgMDAwMDAgbiAKMDAwMDEzNjE0NyAwMDAwMCBuIAp0cmFpbGVyCjw8IC9TaXplIDk2 +IC9Sb290IDEgMCBSIC9JbmZvIDIgMCBSCi9JRCBbPEVFMjhBQTVFQ0ExQTcxOUZCQkYyMTQyRUU1 +NkQ5Rjc2PjxFRTI4QUE1RUNBMUE3MTlGQkJGMjE0MkVFNTZEOUY3Nj5dCj4+CnN0YXJ0eHJlZgox +Mzc5ODYKJSVFT0YK + + +--=_mixed 005C1243C12580DD_=-- diff --git a/tests/unittests/files/mail_test_19 b/tests/unittests/files/mail_test_19 new file mode 100644 index 0000000..9011236 --- /dev/null +++ b/tests/unittests/files/mail_test_19 @@ -0,0 +1,12 @@ +From: alice@example.com +To: "Charlie Brown" , dave@example.com +CC: eve@example.com +Reply-To: henry@example.com +Subject: Test email with email address as display name +Message-ID: +Date: Mon, 01 Jan 2024 12:00:00 +0000 +MIME-Version: 1.0 +Content-Type: text/plain; charset=utf-8 + +This email tests parsing of address headers where the display name is itself +an email address (RFC non-compliant but common in real-world mail). diff --git a/tests/unittests/test_app.py b/tests/unittests/test_app.py new file mode 100644 index 0000000..5daf2a6 --- /dev/null +++ b/tests/unittests/test_app.py @@ -0,0 +1,163 @@ +import logging +import subprocess +from importlib.metadata import version + +import pytest + +from mail_parser_api import app as app_module +from mail_parser_api.app import MAX_BODY_BYTES, RATE_LIMIT_REQUESTS +from mail_parser_api.parser import TOO_COMPLEX_ERROR + +RFC822 = {"Content-Type": "message/rfc822"} + + +def test_healthz(client): + response = client.get("/healthz") + + assert response.status_code == 200 + assert response.json() == {"status": "ok"} + + +def test_parse_strips_attachment_payloads(client, read_sample): + response = client.post( + "/api/parse", content=read_sample("mail_test_10"), headers=RFC822 + ) + + assert response.status_code == 200 + body = response.json() + assert body["mail_parser_version"] == version("mail-parser") + attachments = body["message"]["attachments"] + assert len(attachments) == 4 + assert all("payload" not in attachment for attachment in attachments) + assert all("filename" in attachment for attachment in attachments) + + +def test_parse_accepts_content_type_parameters(client, read_sample): + response = client.post( + "/api/parse", + content=read_sample("mail_test_19"), + headers={"Content-Type": "message/rfc822; charset=utf-8"}, + ) + + assert response.status_code == 200 + message = response.json()["message"] + assert message["subject"] == "Test email with email address as display name" + + +def test_malformed_email_is_parsed_with_defects(client, read_sample): + # mail-parser is tolerant: a malformed email still yields JSON, with defects. + response = client.post( + "/api/parse", content=read_sample("mail_malformed_2"), headers=RFC822 + ) + + assert response.status_code == 200 + message = response.json()["message"] + assert message["has_defects"] is True + assert "StartBoundaryNotFoundDefect" in message["defects_categories"] + + +@pytest.mark.parametrize("content_type", ["text/plain", "application/json", ""]) +def test_other_content_types_are_rejected(client, content_type): + response = client.post( + "/api/parse", content=b"x", headers={"Content-Type": content_type} + ) + + assert response.status_code == 415 + assert response.json() == {"detail": "Content-Type must be message/rfc822"} + + +def test_outlook_msg_is_rejected(client): + response = client.post( + "/api/parse", + content=b"x", + headers={"Content-Type": "application/vnd.ms-outlook"}, + ) + + assert response.status_code == 415 + assert response.json() == {"detail": "Outlook .msg not supported yet"} + + +def test_declared_oversized_body_is_rejected(client): + response = client.post( + "/api/parse", content=b"x" * (MAX_BODY_BYTES + 1), headers=RFC822 + ) + + assert response.status_code == 413 + assert response.json() == {"detail": "Body exceeds 5 MB"} + + +def test_streamed_oversized_body_is_rejected(client): + def chunks(): + chunk = b"x" * 1024 * 1024 + for _ in range(6): + yield chunk + + # A generator body is sent chunked, without Content-Length. + response = client.post("/api/parse", content=chunks(), headers=RFC822) + + assert response.status_code == 413 + + +def test_parser_failure_returns_422(client, monkeypatch): + stdout = ( + b"2026-01-01 00:00:00,000 | mailparser | __main__ | main | 203 | ERROR " + b"| An error occurred: boom\nTraceback (most recent call last):\n" + ) + + def fail(*_args, **_kwargs): + return subprocess.CompletedProcess(args=[], returncode=1, stdout=stdout) + + monkeypatch.setattr(subprocess, "run", fail) + response = client.post("/api/parse", content=b"Subject: x\n\nx", headers=RFC822) + + assert response.status_code == 422 + assert response.json() == {"detail": "boom"} + + +def test_killed_parser_returns_422_too_complex(client, monkeypatch): + def killed(*_args, **_kwargs): + return subprocess.CompletedProcess(args=[], returncode=-9, stdout=b"") + + monkeypatch.setattr(subprocess, "run", killed) + response = client.post("/api/parse", content=b"Subject: x\n\nx", headers=RFC822) + + assert response.status_code == 422 + assert response.json() == {"detail": TOO_COMPLEX_ERROR} + + +def test_parser_timeout_returns_504(client, monkeypatch): + def hang(*args, **kwargs): + raise subprocess.TimeoutExpired(cmd=args[0], timeout=kwargs["timeout"]) + + monkeypatch.setattr(subprocess, "run", hang) + response = client.post("/api/parse", content=b"Subject: x\n\nx", headers=RFC822) + + assert response.status_code == 504 + assert response.json() == {"detail": "Parsing timed out"} + + +def test_rate_limit_per_forwarded_client(client, monkeypatch): + monkeypatch.setattr(app_module, "parse_email", lambda _raw: {}) + first_client = {**RFC822, "X-Forwarded-For": "198.51.100.7"} + + statuses = [ + client.post("/api/parse", content=b"x", headers=first_client).status_code + for _ in range(RATE_LIMIT_REQUESTS + 1) + ] + other_client = {**RFC822, "X-Forwarded-For": "198.51.100.8"} + other = client.post("/api/parse", content=b"x", headers=other_client) + + assert statuses == [200] * RATE_LIMIT_REQUESTS + [429] + assert other.status_code == 200 + + +def test_access_log_has_no_email_content(client, read_sample, caplog): + raw_email = read_sample("mail_test_19") + + with caplog.at_level(logging.INFO, logger="mail_parser_api.access"): + response = client.post("/api/parse", content=raw_email, headers=RFC822) + + size = response.headers["content-length"] + assert [record.getMessage() for record in caplog.records] == [ + f"POST /api/parse 200 {size}" + ] diff --git a/tests/unittests/test_parser.py b/tests/unittests/test_parser.py new file mode 100644 index 0000000..3185896 --- /dev/null +++ b/tests/unittests/test_parser.py @@ -0,0 +1,94 @@ +import subprocess +import sys + +import pytest + +from mail_parser_api.parser import ( + GENERIC_ERROR, + LINUX_CHILD_LIMITS, + MAIL_PARSER_COMMAND, + TOO_COMPLEX_ERROR, + ParseError, + parse_email, +) + + +def completed(returncode: int, stdout: bytes): + def run(*_args, **_kwargs): + return subprocess.CompletedProcess( + args=[], returncode=returncode, stdout=stdout + ) + + return run + + +def test_log_lines_before_json_are_skipped(monkeypatch): + stdout = b'2026-01-01 | mailparser | ERROR | Failed\n{\n "subject": "hi"\n}\n' + monkeypatch.setattr(subprocess, "run", completed(0, stdout)) + + assert parse_email(b"raw") == {"subject": "hi"} + + +def test_output_without_json_is_a_parse_error(monkeypatch): + monkeypatch.setattr(subprocess, "run", completed(0, b"no json here\n")) + + with pytest.raises(ParseError, match=GENERIC_ERROR): + parse_email(b"raw") + + +def test_failure_without_error_line_uses_generic_message(monkeypatch): + monkeypatch.setattr(subprocess, "run", completed(1, b"")) + + with pytest.raises(ParseError, match=GENERIC_ERROR): + parse_email(b"raw") + + +def test_failure_with_empty_error_message_is_too_complex(monkeypatch): + # A MemoryError has no text, so the CLI logs an empty error message. + stdout = b"2026-01-01 | mailparser | ERROR | An error occurred: \nTraceback\n" + monkeypatch.setattr(subprocess, "run", completed(1, stdout)) + + with pytest.raises(ParseError, match=TOO_COMPLEX_ERROR): + parse_email(b"raw") + + +def test_json_at_start_is_parsed_and_trailing_output_ignored(monkeypatch): + stdout = b'{\n "subject": "hi"\n}\ntrailer\n' + monkeypatch.setattr(subprocess, "run", completed(0, stdout)) + + assert parse_email(b"raw") == {"subject": "hi"} + + +def test_log_line_ending_with_a_brace_is_skipped(monkeypatch): + stdout = b'2026-01-01 | ERROR | bad {\n{\n "subject": "hi"\n}\n' + monkeypatch.setattr(subprocess, "run", completed(0, stdout)) + + assert parse_email(b"raw") == {"subject": "hi"} + + +def test_truncated_json_is_a_parse_error(monkeypatch): + monkeypatch.setattr(subprocess, "run", completed(0, b"log\n{\n trunc")) + + with pytest.raises(ParseError, match=GENERIC_ERROR): + parse_email(b"raw") + + +@pytest.mark.parametrize( + ("platform", "expected"), + [ + ("linux", (*LINUX_CHILD_LIMITS, *MAIL_PARSER_COMMAND)), + ("darwin", MAIL_PARSER_COMMAND), + ], +) +def test_child_limits_wrap_the_command_only_on_linux(monkeypatch, platform, expected): + calls = [] + + def record(args, **_kwargs): + calls.append(args) + return subprocess.CompletedProcess(args=args, returncode=0, stdout=b"{\n}\n") + + monkeypatch.setattr(sys, "platform", platform) + monkeypatch.setattr(subprocess, "run", record) + parse_email(b"raw") + + assert calls == [expected] diff --git a/tests/unittests/test_rate_limit.py b/tests/unittests/test_rate_limit.py new file mode 100644 index 0000000..09cb8e9 --- /dev/null +++ b/tests/unittests/test_rate_limit.py @@ -0,0 +1,70 @@ +import pytest + +from mail_parser_api.rate_limit import RateLimiter, client_key + + +class FakeClock: + def __init__(self) -> None: + self.now = 1000.0 + + def __call__(self) -> float: + return self.now + + +@pytest.fixture +def clock() -> FakeClock: + return FakeClock() + + +def test_limit_within_sliding_window(clock): + limiter = RateLimiter(limit=2, window=60, max_keys=10, clock=clock) + + assert limiter.allow("a") + clock.now += 30 + assert limiter.allow("a") + assert not limiter.allow("a") + clock.now += 31 + # The first request left the window; the second is still inside it. + assert limiter.allow("a") + assert not limiter.allow("a") + + +def test_least_recently_used_key_is_evicted_at_cap(clock): + limiter = RateLimiter(limit=1, window=60, max_keys=2, clock=clock) + limiter.allow("a") + limiter.allow("b") + assert not limiter.allow("a") # "a" becomes the most recently used + + limiter.allow("c") + + assert len(limiter) == 2 + assert limiter.allow("b") # "b" was evicted, so it starts afresh + assert not limiter.allow("c") + + +def test_expired_keys_are_purged(clock): + limiter = RateLimiter(limit=1, window=60, max_keys=10, clock=clock) + limiter.allow("a") + limiter.allow("b") + clock.now += 61 + + limiter.allow("c") + + assert len(limiter) == 1 + + +@pytest.mark.parametrize( + ("forwarded_for", "peer", "expected"), + [ + ("203.0.113.5", "10.0.0.1", "203.0.113.5"), + ("203.0.113.5, 10.0.0.2", "10.0.0.1", "203.0.113.5"), + (None, "10.0.0.1", "10.0.0.1"), + ("2001:db8:1:2:aaaa::1", None, "2001:db8:1:2::/64"), + ("2001:db8:1:2:bbbb::9", None, "2001:db8:1:2::/64"), + ("2001:db8:1:3::1", None, "2001:db8:1:3::/64"), + (None, "testclient", "testclient"), + (None, None, ""), + ], +) +def test_client_key(forwarded_for, peer, expected): + assert client_key(forwarded_for, peer) == expected diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..8c8190b --- /dev/null +++ b/uv.lock @@ -0,0 +1,1286 @@ +version = 1 +revision = 5 +requires-python = ">=3.13" + +[[package]] +name = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "anyio" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.15'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/98/7e457a3b014976887a050561955c0b76e1e7e2d6e27b78ecef2ef80518f2/anyio-4.16.0.tar.gz", hash = "sha256:59bb03251907983d1603d27c3087ddb1e93299ea2163adcdba37899a4fb12ffb", size = 310971, upload-time = "2026-11-01T11:20:07.282Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/16/7757fb84c819accc7d7e9af5291b261e4abb8627ee040f99e7d35ef2457a/anyio-4.16.0-py3-none-any.whl", hash = "sha256:c66ae634e0b8228396b801741beb3294326d4b6102f7bba4041c0dfb58c29026", size = 134521, upload-time = "2026-11-01T11:20:05.59Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "click" +version = "8.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/37/edbf1b0707709013c0cf2e8317e03d97ed29bf4cac709fe328904ae92a38/click-8.5.1.tar.gz", hash = "sha256:9bbfada76703fd1d784b83eea012e3e8c6a001a876543ef104fa56aaaeb072b4", size = 399151, upload-time = "2026-11-06T17:37:01.021Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/7d/164b7ffc8624fe9efb4221bf9af485d5c1e41b9ae118045d2b6dc5457d8b/click-8.5.1-py3-none-any.whl", hash = "sha256:8bb5376d2006950386f8c6427613334a2acadc5f559cb80e638d00b4df957e37", size = 126163, upload-time = "2026-11-06T17:36:59.287Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "colorclass" +version = "2.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/1a/31ff00a33569a3b59d65bbdc445c73e12f92ad28195b7ace299f68b9af70/colorclass-2.2.2.tar.gz", hash = "sha256:6d4fe287766166a98ca7bc6f6312daf04a0481b1eda43e7173484051c0ab4366", size = 16709, upload-time = "2021-12-09T00:41:35.661Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/b6/daf3e2976932da4ed3579cff7a30a53d22ea9323ee4f0d8e43be60454897/colorclass-2.2.2-py2.py3-none-any.whl", hash = "sha256:6f10c273a0ef7a1150b1120b6095cbdd68e5cf36dfd5d0fc957a2500bbf99a55", size = 18995, upload-time = "2021-12-09T00:41:34.653Z" }, +] + +[[package]] +name = "compressed-rtf" +version = "1.0.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/0c/929a4e8ef9d7143f54d77dadb5f370cc7b98534b1bd6e1124d0abe8efb24/compressed_rtf-1.0.7.tar.gz", hash = "sha256:7c30859334839f3cdc7d10796af5b434bb326b9df7cb5a65e95a8eacb2951b0e", size = 8152, upload-time = "2025-03-24T22:39:32.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/1d/62f5bf92e12335eb63517f42671ed78512d48bbc69e02a942dd7b90f03f0/compressed_rtf-1.0.7-py3-none-any.whl", hash = "sha256:b7904921d78c67a0a4b7fff9fb361a00ae2b447b6edca010ce321cd98fa0fcc0", size = 7968, upload-time = "2025-03-24T23:03:57.433Z" }, +] + +[[package]] +name = "coverage" +version = "7.17.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/78/4a/740c3134227763ebc30a226d7f2f29b25e35898d162dd8b2dd792be83fb2/coverage-7.17.2.tar.gz", hash = "sha256:d05a1bef52f4d7f1b484a1cf46a8929e50963f910e51396373f06cd3b6248f38", size = 996756, upload-time = "2026-11-04T19:52:34.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/32/d750d7b10b0a9436349b3fb78491c5bb8f9b524f01ae6994d935d77d6ab8/coverage-7.17.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:882cade9b6dc43b2bc819bb444c0a13e4ed1f669a50e0de74adeec54fce486f3", size = 228978, upload-time = "2026-11-04T19:50:12.782Z" }, + { url = "https://files.pythonhosted.org/packages/63/33/468f8c63aff5deef81bfb8e44771f68ebba328c0aa46c8a6ff27dedd0fda/coverage-7.17.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:f5a875e92f10c6463027d8151459f2d92b4c13527402ed1301eaddabd79d8cf5", size = 229048, upload-time = "2026-11-04T19:50:14.255Z" }, + { url = "https://files.pythonhosted.org/packages/10/91/c8723e48c1497a3c56a3194973a416a6f0fb24560425685f960888e03b20/coverage-7.17.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e8da5e158d13556457f69245deacf6d8401a2c9c31afaddd18bea691e849b5fd", size = 227293, upload-time = "2026-11-04T19:50:15.857Z" }, + { url = "https://files.pythonhosted.org/packages/61/4f/2f57b3dc6ef31e12a99e6dcb820c4ab04d973ea1466f73c856bf920a740c/coverage-7.17.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:42133a2647982db7968db138c0f4a57f5836101d8d504600a87ef8ebfa22a4cf", size = 227599, upload-time = "2026-11-04T19:50:17.418Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fa/967e829238dda21c4bce17aef2f739187678c8e6e6fc880a8454945a7433/coverage-7.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e6c89d63d43738712ce1febddb7758ffeb56de08f1b2be68aeb9a9c7fee712c7", size = 227727, upload-time = "2026-11-04T19:50:18.924Z" }, + { url = "https://files.pythonhosted.org/packages/9d/df/803ba08e8937759dc3f18b93ece82f81b2fb446e3846e4d60a06a4e77647/coverage-7.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f94d465ee00ebe694ca866d66bbe45fa04618b1afcb377de934694f624fa7cf6", size = 227987, upload-time = "2026-11-04T19:50:20.867Z" }, + { url = "https://files.pythonhosted.org/packages/4a/12/92dcd9206e7bb817af42b8663cfeefdbb2c5a6c92cc7069d43e6892bbdeb/coverage-7.17.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7ce0acb27a823e8e5169282f538f0e182854cc8b472b88d45456f09b6fe364fd", size = 259154, upload-time = "2026-11-04T19:50:22.328Z" }, + { url = "https://files.pythonhosted.org/packages/48/2d/6b028df8050caef4ce0df177686c92dba16ab7cf004040e5518f95b57021/coverage-7.17.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:70daa8e4b49541b51c0baeba0d802b0d14d3214daeebc071b3db0b0c7dc84646", size = 262065, upload-time = "2026-11-04T19:50:23.745Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/429b500937ac446e36fcce517d040b0b8bd04a4bfa087bdf864175553fea/coverage-7.17.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:95bd8dc5b356f78f10a967ec50f8902d56f24c623753ac9fce0aba9d6213d5c5", size = 262997, upload-time = "2026-11-04T19:50:25.223Z" }, + { url = "https://files.pythonhosted.org/packages/c1/91/263224a77de3ab1ee42d110b09f1ac9a02638794d3e002a859822638256a/coverage-7.17.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a5565a9dd715a5a94ffcf9a0ad4b6b1501b5441fd67d660e78742adff5d37a0a", size = 265062, upload-time = "2026-11-04T19:50:26.829Z" }, + { url = "https://files.pythonhosted.org/packages/0f/44/99b72f2961f4ba54ac14ccb016f3b212cc9a9dfda4c37e07a208efe01f9f/coverage-7.17.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:091eba4248d31b03828fc657c96d14adfaa8754f5aec7b73298b82894858db06", size = 259201, upload-time = "2026-11-04T19:50:28.386Z" }, + { url = "https://files.pythonhosted.org/packages/be/a7/e97f63a7c345077e4e398d15e3aa5068edc28cb061f997f71fd0e32703e1/coverage-7.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d2742952851c7f88b1484385f68c42c6388153520efb40ff09fc852c3783aa5c", size = 261155, upload-time = "2026-11-04T19:50:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/16/0c/73e470df7db83962e2cdd6c1a7ca7dc8f8632c17a6d378d6d9124ff8bc6b/coverage-7.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1da1999e3c371edd669b48a1029c86dc0474cdc6ff152d58cb3f15cb3337af72", size = 259077, upload-time = "2026-11-04T19:50:31.437Z" }, + { url = "https://files.pythonhosted.org/packages/50/43/db8bc1b92d933b0b5f57d0e3377594c4f78ea31e84e8fbc22627fd17ecf4/coverage-7.17.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7804a6022fcd5e1d4de4dc676e985d6aea0119249e88c041e943f3cd07953527", size = 263172, upload-time = "2026-11-04T19:50:33.014Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f4/3e9e5cc9ccc911f8fb9595053da1ce58b9de8941b27e2f2f7058cdfc87f1/coverage-7.17.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6bdf3821fd0740b5369b9ab58b4e9d0d68a2c5c75a7ee0cd3beb624f9f15e4fa", size = 258926, upload-time = "2026-11-04T19:50:34.513Z" }, + { url = "https://files.pythonhosted.org/packages/72/9f/0d67883bf55adf50424728937cbee54d76fa137817e6bb20f97061d01816/coverage-7.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e09c37817768bb71fe3e70b6ce5e6ac1a0cd7398536c2f30a4460218c7b66e93", size = 261006, upload-time = "2026-11-04T19:50:35.956Z" }, + { url = "https://files.pythonhosted.org/packages/a8/22/71965edc14736073b55a40e521791d9233d5c3194fa6887a94f4431fbbcc/coverage-7.17.2-cp313-cp313-win32.whl", hash = "sha256:c10f2a2748dd084e44811bb9b26979763af9003115d9bf93c1da69011944719f", size = 229602, upload-time = "2026-11-04T19:50:37.564Z" }, + { url = "https://files.pythonhosted.org/packages/47/0d/715cb37f51f908a6f6f33fe8c6fc95ab638b17cb014b1650daae0893c160/coverage-7.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:8dc07ed34bcb206f69d5b54fd3874f7bf39ac941c9f7aec2b53b29874fcfd77a", size = 230329, upload-time = "2026-11-04T19:50:38.988Z" }, + { url = "https://files.pythonhosted.org/packages/39/f2/a5099bdc2a530f29c818a1c7e706669451c10e5f0eb62dcff76ef3568668/coverage-7.17.2-cp313-cp313-win_arm64.whl", hash = "sha256:bb74283661a239fdaf738ac0b07db4ed9b476c7532d3e713abf0f6a072781e60", size = 230055, upload-time = "2026-11-04T19:50:40.479Z" }, + { url = "https://files.pythonhosted.org/packages/96/f9/30d6ff7a66e1519d79940fdee542ead9a63601de60be5cc9fe62c74bab58/coverage-7.17.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:0439f77deb5c023003533ae8909a9aa1e174c847d655327035b1e542c7c8a54e", size = 229094, upload-time = "2026-11-04T19:50:42.193Z" }, + { url = "https://files.pythonhosted.org/packages/1a/db/82c722c37dce98fe1abc953768903752bdd415dfe8cfeb7b744a7236a735/coverage-7.17.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e86a66f96d80c770daeed78394c1d4f6e8d03e5a3e08c5dab5275d56414f296a", size = 229213, upload-time = "2026-11-04T19:50:43.779Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/71b68d870975776cb185f11cd80e053b01739f3646488fe8b9721744f56a/coverage-7.17.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:87b30f3daa0bedda6b770b303410a6def007844772aaa143dc52675b3d95cd8a", size = 227374, upload-time = "2026-11-04T19:50:45.258Z" }, + { url = "https://files.pythonhosted.org/packages/aa/23/ed60f79576175e108c77df2bdc116f46e367aab108542ddeecaab752f0f6/coverage-7.17.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:3f219efbc3ec71c377e278dee201633e1d4ad0d2d9bdaddfd9489b2869d584c4", size = 227676, upload-time = "2026-11-04T19:50:47.095Z" }, + { url = "https://files.pythonhosted.org/packages/10/7e/60a51850d3ff659b82cc211bc98fa126aab2ac9b81bd4ed6abc3e3720a09/coverage-7.17.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:36248fb6c03341501169539bcab35eb3a59159100be1246fad3c14cb73c17685", size = 227915, upload-time = "2026-11-04T19:50:48.581Z" }, + { url = "https://files.pythonhosted.org/packages/77/80/a9539c15076fb9b95d8cbdb7f0caec90857d80bddca3eeca439f5e2e64e2/coverage-7.17.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2a6281011cf85699763bf88ab55e0774f6696f87b390f39152b14ecefadccb59", size = 228072, upload-time = "2026-11-04T19:50:50.073Z" }, + { url = "https://files.pythonhosted.org/packages/7f/3b/0a84b6032511834105fd4f8a8b4e76927783cea03dc4796032d5c4bfec8b/coverage-7.17.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3dfefb1ec16ca1a01e5da40ba162e268ced8bd3624b9eba4e9384ebfa14af7ec", size = 259991, upload-time = "2026-11-04T19:50:51.665Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e4/a3e6b8bcc219b00ea91e36f071c2659b253e5d6e1b258c31eb4524231718/coverage-7.17.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:34e5c7a2da36804c6e6f10b368eae01ad56f5a4ac5ecce7297300a3d46fdef2a", size = 262995, upload-time = "2026-11-04T19:50:53.236Z" }, + { url = "https://files.pythonhosted.org/packages/05/54/a666b65c5bb145d8796b7902ff1c0f60600a6c2a08949e20f2fb7af15de3/coverage-7.17.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6bf531deaebf8f69ba6015bba3fb817cab6694dfb69ac2a708889dc59a3926e", size = 263980, upload-time = "2026-11-04T19:50:55.366Z" }, + { url = "https://files.pythonhosted.org/packages/a6/73/ac9d06da9e0c143b874a68b17d8dfeedc45acdf1bdcee5b22a42bece098e/coverage-7.17.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:88d4dc83b6ad09a2134cad9d8ec780b274b17ac7dfba8c2c6e92e3bc468fe85d", size = 266457, upload-time = "2026-11-04T19:50:57.04Z" }, + { url = "https://files.pythonhosted.org/packages/87/b1/8a500e16cf787383b00b5a86eb50a490b4d8ebde505f92e1aaca515afc0a/coverage-7.17.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dc17707fd463b4dfab53792e41d50a23316ac6b98539007aa2388a1d44a8535", size = 259768, upload-time = "2026-11-04T19:50:58.508Z" }, + { url = "https://files.pythonhosted.org/packages/f7/be/642762c5973b89e2b8bf66c95778bdd80e96ceea442ae8fa753732597b73/coverage-7.17.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:df0a34d445eea64f3766e9ca2ff57bcde600a89c7c0330434a7a37e8d6e2549f", size = 261831, upload-time = "2026-11-04T19:51:00.25Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b1/f7d6c0ef0a4aecf3f91f19df4ab3fa131fec8c89f554187511716584c9f5/coverage-7.17.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:c5a98aff9eb681312ed403ecb7beb5f15fd25d6e0acc2554b9ca4b4d6f0b6705", size = 259871, upload-time = "2026-11-04T19:51:01.776Z" }, + { url = "https://files.pythonhosted.org/packages/c7/c0/3ae087d52cfa5119ad9ecbd193c40089924d1101cef7333f15a86dccb444/coverage-7.17.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:7565c17092f2f4021abbe3f5007300c224f362364a388f5ddad9216dab44b611", size = 264169, upload-time = "2026-11-04T19:51:03.365Z" }, + { url = "https://files.pythonhosted.org/packages/c5/95/d324108991f892cb361ef8b2f91bd4cda9c2563e0954247409e9e6b911ab/coverage-7.17.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:555257578e20a46020c27b2af4ef99059cd906aa9b8e163baf9da9a5afb65a64", size = 259502, upload-time = "2026-11-04T19:51:04.91Z" }, + { url = "https://files.pythonhosted.org/packages/14/b5/13a62eac66cecbaaa098bb753a3693b44454a4d21d53db4f1a0953f35f0b/coverage-7.17.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:460ba2139866e758c3a8e9d9422fdc889942bcbc5ccaf710dc4fbd8707d14aa8", size = 261613, upload-time = "2026-11-04T19:51:06.414Z" }, + { url = "https://files.pythonhosted.org/packages/53/13/9ea31cfa72434449b9a98666760169d1e0ab31b3f6cdb12e68149106668e/coverage-7.17.2-cp314-cp314-win32.whl", hash = "sha256:e72cf9556f799c3fce7597c1bd7dbfc9104befbd08088deb3b9ae9fd98117c02", size = 229842, upload-time = "2026-11-04T19:51:08.61Z" }, + { url = "https://files.pythonhosted.org/packages/f6/cc/aa8f34b014979c973740f5a5ed6861ecfc6009082c70e72030ca1519e0f8/coverage-7.17.2-cp314-cp314-win_amd64.whl", hash = "sha256:205f9e329d9d5e47c320f8712326a01620689edae50531cc8934511e2c5e8f7e", size = 230474, upload-time = "2026-11-04T19:51:10.167Z" }, + { url = "https://files.pythonhosted.org/packages/49/64/16afaa19b3886dc157c3c5ebace5241b84b96a005cb28545584e66b80895/coverage-7.17.2-cp314-cp314-win_arm64.whl", hash = "sha256:a5909dd087006c70c128297312ba67d877123e871100645d9bd73ae021a4d01d", size = 230325, upload-time = "2026-11-04T19:51:11.63Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/acc865e1411c8ebc5c5d230367f3bfed5c605ed54bb41b84fc58f4e7f137/coverage-7.17.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:674bcd023a3743666d4d7a15238e57a00c968553780a36c80d3779fc410b912c", size = 228384, upload-time = "2026-11-04T19:51:13.729Z" }, + { url = "https://files.pythonhosted.org/packages/10/98/02c37c6a928ccfc84b7a43eda44d96d3b1ccbc93989c178754b7e67e7650/coverage-7.17.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ba45dc072bfbf1798e68ec81379b73473fc912174bff9f91924d77711a1d2b30", size = 228758, upload-time = "2026-11-04T19:51:15.394Z" }, + { url = "https://files.pythonhosted.org/packages/28/ab/d503b0aaebb92b171260469463915af5e16a64457b289d4cb844e8c366ac/coverage-7.17.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0d8a5dc709da9b90ad5cc859a9b88c9b801e65ca2fbf7cbdbed5b9cbf457fcc9", size = 268749, upload-time = "2026-11-04T19:51:17.179Z" }, + { url = "https://files.pythonhosted.org/packages/f6/e5/6d6ba15bde22fcccd07e14305be14291d041f732771a73f787297445d3e7/coverage-7.17.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:248873a144c067f981742ff4bbfb48b57e281a8cb7a3821d4e293bdb50b47970", size = 271301, upload-time = "2026-11-04T19:51:18.893Z" }, + { url = "https://files.pythonhosted.org/packages/63/e7/bd6dcec5b8130f5bd8679087a2bc3a50a53c4ee78d5ec449610020088ff3/coverage-7.17.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0332e2b27fc5cc761d6b8a33118b958e6a46be7f00fd30e03a5cf103350c0b3", size = 273924, upload-time = "2026-11-04T19:51:20.605Z" }, + { url = "https://files.pythonhosted.org/packages/55/c1/b3f06aa1f1c51f4295fdfa6500eb7409aaa6273cf5f27bafc25217f3547d/coverage-7.17.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:27fc4384a1154f7df30d304ccddc05ef457368c065670ecbd392606279b3329a", size = 275412, upload-time = "2026-11-04T19:51:22.09Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f0/b68ab3654af3541488b26856e3043c13c782d8e6104fc8149746ecaa83f0/coverage-7.17.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:603140eeae3f9adc562f91b1b98d4d1fc491bd1f66c5082482c568d0b7891bb1", size = 268638, upload-time = "2026-11-04T19:51:23.653Z" }, + { url = "https://files.pythonhosted.org/packages/fd/16/4a9d56bd4ca4572cbd20f9843813623cef1b88b15f979ec4f381704d2f84/coverage-7.17.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:be0fec33b69c40f845c76f67fb4495b62a84da8c31a579dc6e18c5a63fa6a1f3", size = 271211, upload-time = "2026-11-04T19:51:25.678Z" }, + { url = "https://files.pythonhosted.org/packages/78/d2/1c04b38bab92d2b7d62718d170b5bea43755fefee7e29cc056448c433d92/coverage-7.17.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:960e199965e506d78f62252355397a05c8cee8072ad2d82d932745517d566539", size = 268638, upload-time = "2026-11-04T19:51:27.262Z" }, + { url = "https://files.pythonhosted.org/packages/26/c9/2c639e9aee78b0522cb3dc245de09685e34b479bcc45d4d2a277d0de1174/coverage-7.17.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d7a363c0788435ff5324d9582d37c63f215c75f974d755cfd6cfc9fbe0e64b04", size = 272935, upload-time = "2026-11-04T19:51:28.96Z" }, + { url = "https://files.pythonhosted.org/packages/79/1f/11bdaf03c1b12f88094b57420b4238d3974ebec6a7d674b645a54e24f90c/coverage-7.17.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:afd81658f17b1a50bbc1d247a61fa435be0be471246136eb946f9cbfc437a4fa", size = 268057, upload-time = "2026-11-04T19:51:30.44Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f6/43d40d1b4d4892e54c68a241cd5b92efed4d5934109e0e5e24a94759f732/coverage-7.17.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d88fcc24470d73ed4360e910f8549718b913ba56fb8775d9ef929a647835dfea", size = 269986, upload-time = "2026-11-04T19:51:31.913Z" }, + { url = "https://files.pythonhosted.org/packages/8e/33/6874185b791c71684c401fc74abd71bbdb102e8ee41c8f380cf25af41d29/coverage-7.17.2-cp314-cp314t-win32.whl", hash = "sha256:2c42c222939b8699e7bc0e453149627f211ebbbb2f74c1a04331b0cd9834e2c8", size = 230160, upload-time = "2026-11-04T19:51:33.304Z" }, + { url = "https://files.pythonhosted.org/packages/16/e0/9057b4cf962ca6089b144f0d93a748f5e2d13876dd0f33f9d5a2c2ec49d2/coverage-7.17.2-cp314-cp314t-win_amd64.whl", hash = "sha256:b94c509e26603ba7f8cb1bf8bb63967c7be533493be5668d8442cd06ec853d76", size = 231086, upload-time = "2026-11-04T19:51:35.002Z" }, + { url = "https://files.pythonhosted.org/packages/5e/4f/bd626297c942380279dff323e1d8a8937990d553119a4f887358488b1b54/coverage-7.17.2-cp314-cp314t-win_arm64.whl", hash = "sha256:eca90e028932de597e2c50f454ad8cc631281e14d20b9f801a649ab555deb580", size = 230657, upload-time = "2026-11-04T19:51:36.742Z" }, + { url = "https://files.pythonhosted.org/packages/ac/92/ff8badc05ff0c4ed26ca62fb3d155e9014ff65768b76d5f399e63d9e9a79/coverage-7.17.2-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:cbf751ae86ef0d80e719915c087b05776c8d9300141f6c3e56f536d78a62c301", size = 229092, upload-time = "2026-11-04T19:51:38.222Z" }, + { url = "https://files.pythonhosted.org/packages/5a/8b/c5a5392e5a5dceb68f3b1b8cdba925c7997699f351d811cd4a41add9c29e/coverage-7.17.2-cp315-cp315-android_24_x86_64.whl", hash = "sha256:249c4b4eaac9ced6fb85e465027ca26348111c2760108fffc356a16be4f54cd9", size = 229212, upload-time = "2026-11-04T19:51:39.738Z" }, + { url = "https://files.pythonhosted.org/packages/7b/bc/9259a1fc49ad663861cbfb3df6a99d4c8f62a11b242a2db3358822d28b17/coverage-7.17.2-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e2fd4e664a34854cae8db58ca6132fb7b5a7efc67b14233e797194bd0d63b6b0", size = 227390, upload-time = "2026-11-04T19:51:41.16Z" }, + { url = "https://files.pythonhosted.org/packages/20/ad/83f03da8ab846af246d4a47b651e5d90229a4c3314e31e8eecade63b378f/coverage-7.17.2-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:0712a43e39410aa567f2e85846490f8dd6c839820e7edef2142767c5c03162ba", size = 227690, upload-time = "2026-11-04T19:51:42.658Z" }, + { url = "https://files.pythonhosted.org/packages/f3/08/e110687f24245edbbe9c0986a6ccd04f1f9a6e90e329cbd4347e2b81d76e/coverage-7.17.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:298849ca0e385767096995cb57f72059b469f43f9927b8393f29d134f7bb1062", size = 227922, upload-time = "2026-11-04T19:51:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/93/24/7cfcd6adb4a0c18a10de12fd695edbf8cd121fdca0a6a63cea1bffc029fe/coverage-7.17.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:81a432793440edef268dbadd493393bd6f70fa4b87f76c58114f7f77f1ccfaea", size = 228094, upload-time = "2026-11-04T19:51:46.108Z" }, + { url = "https://files.pythonhosted.org/packages/54/7a/af167a0bb6d0564209d35c8039b290327ecf7b3e34f838f9360b56d3a03c/coverage-7.17.2-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d14872ccef35972c4ac290f2432f43d0a7bb230cae2b5ed26871ab86221e8b5f", size = 259940, upload-time = "2026-11-04T19:51:47.599Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c6/4f3931c3ff80a6f2608209181adb00527970a4b43b64c3aa323383c37d51/coverage-7.17.2-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3bd065e75c077d6de8cd3fe68699a8b47be3ec595af6b66e3629926839094609", size = 263632, upload-time = "2026-11-04T19:51:49.047Z" }, + { url = "https://files.pythonhosted.org/packages/3e/71/31a4945459008952061147ea9b85853902507d865a7272a9f64be0c4a093/coverage-7.17.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d3626b9816f7eadd0993c3703a1d8ed124b579cebe5201b446f1c0d551fa245", size = 264713, upload-time = "2026-11-04T19:51:50.569Z" }, + { url = "https://files.pythonhosted.org/packages/82/6b/a4eb258b0373034f8f19aeea4c1bc4c89942b5b228812ee9952f033dc611/coverage-7.17.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9639c2ea019c948b52067a0f74485039eb84b7a2de828ba6d178e663fb2b8bd", size = 267091, upload-time = "2026-11-04T19:51:52.09Z" }, + { url = "https://files.pythonhosted.org/packages/02/ae/9410f2f4bbaa698ff3869c7c09e0fa10d74482a1ec8040063157612f07a0/coverage-7.17.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:19d508b0611486f8e23e28abcba77795ee865ff0e0cd936349ba692c8d0d8ca4", size = 260326, upload-time = "2026-11-04T19:51:53.508Z" }, + { url = "https://files.pythonhosted.org/packages/ad/ee/97549ec1bdf6ff6d17612dbcf4b2205daa74510273ac1efd1460e3db275c/coverage-7.17.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cfe64d2501806a04507217852a3132a9a9076321435500bf3b11943a5c872732", size = 262595, upload-time = "2026-11-04T19:51:55.514Z" }, + { url = "https://files.pythonhosted.org/packages/36/72/76e04605522a6dd81bbf43e1b407ca611f415c04b67e18c123ee440b1d69/coverage-7.17.2-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:4274acd35aae5bbbd0908792260819b9720b171ccc099a8168f7c20ef5d6ab3a", size = 260546, upload-time = "2026-11-04T19:51:57.068Z" }, + { url = "https://files.pythonhosted.org/packages/30/8d/163e027635790ab232f3ec0261d2a26bec34c377bea2096554261444d0f5/coverage-7.17.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:85bccf6fe19ea3747147387971465f6a06197d6b9f6b644a97ba90ca5b09c5cd", size = 264877, upload-time = "2026-11-04T19:51:58.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/35/11dd585a06be350285d42c17aa2fccd0af18d962b6979f03dd1a258eb705/coverage-7.17.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:d5024913651813801fd43b65b6409b0d50f8bae95316c8f1512dfbd8ca96cb1f", size = 259858, upload-time = "2026-11-04T19:52:00.361Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ed/f1f3b4bf6081122bf1820b1f38352377a75a2d5f39bb6331598e165b64af/coverage-7.17.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:99b64a12fe6017c254a8027790e0eaa22eaeec201e7dfda5eaac176a6984ef27", size = 262401, upload-time = "2026-11-04T19:52:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/ab/bb/61e07a606a9f4d0f5391ac9b62b1f008a997f87860ad233f99833fd6e6bd/coverage-7.17.2-cp315-cp315-win32.whl", hash = "sha256:74d91af590514dda16165d5d7cfa94183150c6a6a80a99f61068369ae3959455", size = 229840, upload-time = "2026-11-04T19:52:04.813Z" }, + { url = "https://files.pythonhosted.org/packages/86/40/2d4980d3374a023a34c5ea7cd5d2b93c02c5588a324ca7faf8a0a8c7dbac/coverage-7.17.2-cp315-cp315-win_amd64.whl", hash = "sha256:075566a44289afb634ceaafa7d8d377bb2667a5b4a90fbee2609efdcd015c66e", size = 230461, upload-time = "2026-11-04T19:52:06.727Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c8/b307327b1256f9ed8ffc3271db041913835cfee065fbaf45105978093c08/coverage-7.17.2-cp315-cp315-win_arm64.whl", hash = "sha256:be699e76b57fede8920a0f568eff23b270d9004414b7cf6744bdda851638be6e", size = 230322, upload-time = "2026-11-04T19:52:08.191Z" }, + { url = "https://files.pythonhosted.org/packages/40/18/0912e37f23c101faebd7c5e544c6ba6bd750715f81f2a2c7ea66f83a2295/coverage-7.17.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:ffbaadf8612781358b3f949ad68dce26c5a35beaafcc48125fc231dbcce7d362", size = 228380, upload-time = "2026-11-04T19:52:09.892Z" }, + { url = "https://files.pythonhosted.org/packages/5e/a0/c4ce9bbf82b2e9dbf2e0326004c8c37d87a275f515fc7bb22344a6162050/coverage-7.17.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:d4004fce7b3a8ae5ef2af835670763f12723e9b9d74837697607b89a17f77312", size = 228776, upload-time = "2026-11-04T19:52:11.351Z" }, + { url = "https://files.pythonhosted.org/packages/3f/05/9c7429c87589534755398a58fe9837fdb2870a22d99e87623fcb261e1d4e/coverage-7.17.2-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a838a10afb5b60a6cc6315348b176badaf2409d821208a3e3cda1dc608129e23", size = 269129, upload-time = "2026-11-04T19:52:12.815Z" }, + { url = "https://files.pythonhosted.org/packages/e9/22/d1ad2ea7c8871d66f8453d33cdeec39986e6e1f2a104628e9bcb171f0209/coverage-7.17.2-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0fc17882975fe485cfc95fb2f20eed937e05e0c0d8ffa5048857cda3aa838e8a", size = 271967, upload-time = "2026-11-04T19:52:14.685Z" }, + { url = "https://files.pythonhosted.org/packages/0d/1d/5038de4bf6549903ec3d86959c6f18aff54911616b47aa96f4d6a5660c93/coverage-7.17.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a65faa1ee98e090a5fd7c116f6d3ab5c6a85fcc46849b8494835608715836399", size = 274667, upload-time = "2026-11-04T19:52:16.122Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ea/68a26b4b5eb255d92de906fd66e8d720b1df15e705949ea9a9cef2cc7f8b/coverage-7.17.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7c17f716c837db550a202e7732cdfaa726b8515cba88be42193616913970d223", size = 276001, upload-time = "2026-11-04T19:52:17.639Z" }, + { url = "https://files.pythonhosted.org/packages/70/86/0f4238f09b22bc03a907346fabcabe5449626879cdedbc1edd362ab0e570/coverage-7.17.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:545ca42488c7f0e62324fb2621aa05737db843b75e84e65a271bbf976f496f66", size = 269687, upload-time = "2026-11-04T19:52:19.169Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ac/1885255425900f691c543d88394d9f0dacd2f2dc78422e660c747ca9c95c/coverage-7.17.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:8de787f533b13aeeea5d7139610eadb56f249cc739840b973603d1d18d0fb023", size = 272158, upload-time = "2026-11-04T19:52:20.714Z" }, + { url = "https://files.pythonhosted.org/packages/02/d6/0111601342d91e25d13e22a55f34600aa387c55b5027b90e78d941911821/coverage-7.17.2-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:485b2ed9e13b7e9209276843d7147e2f1cd1c816582655650a64c8f922093c58", size = 269182, upload-time = "2026-11-04T19:52:22.204Z" }, + { url = "https://files.pythonhosted.org/packages/70/48/d9bdc5346a9ad09711f55b6901ee05b57305e6b2b66e6edfd50f81f0d410/coverage-7.17.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:a472e23a7514478e1c8124ea056424d681e3173975650b0a06b6181658f1009a", size = 273790, upload-time = "2026-11-04T19:52:23.677Z" }, + { url = "https://files.pythonhosted.org/packages/98/75/3a4d8ce4aa59ed2e898364acf923b39471689d51876bb978c42e664cdb79/coverage-7.17.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:0a623de5c57c5c3f3aed830c73a3a5aad91dbf76d53bc30ec161be758c8ca408", size = 269277, upload-time = "2026-11-04T19:52:25.19Z" }, + { url = "https://files.pythonhosted.org/packages/4a/11/d15082e504e7852a25848ee0dcb59453579ec923c6d1f3010316e1fb6118/coverage-7.17.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:2ad189c65706306644399e48530ad1aea1dfb311bd21d988df1ace422d09f3f8", size = 270890, upload-time = "2026-11-04T19:52:26.745Z" }, + { url = "https://files.pythonhosted.org/packages/f1/9d/6460101b0191afae9ed84c8d8136cc8cc09675f376ce08acb3118b8c27be/coverage-7.17.2-cp315-cp315t-win32.whl", hash = "sha256:6fd6f218e39a621a30dbaf9543831fa10fe713afc8a44b52fc42cfe277412609", size = 230148, upload-time = "2026-11-04T19:52:28.164Z" }, + { url = "https://files.pythonhosted.org/packages/9a/f2/3462d9616445a8cb36ec2e027d1c0ae82f6f90f224d9851ba0b22b7425d6/coverage-7.17.2-cp315-cp315t-win_amd64.whl", hash = "sha256:ef07aae0a666ef5edcab5bc1bb590468c6f4120a8cdad50a010d042a59ab6e77", size = 231074, upload-time = "2026-11-04T19:52:29.714Z" }, + { url = "https://files.pythonhosted.org/packages/4c/06/abeca0cf853e77aba9464d4ada4603c8b6e744b667c13e1d4eefecc487af/coverage-7.17.2-cp315-cp315t-win_arm64.whl", hash = "sha256:c68f64d96857749a215657c172f7144ed026063489686b901774f271997923c2", size = 230648, upload-time = "2026-11-04T19:52:31.267Z" }, + { url = "https://files.pythonhosted.org/packages/da/91/1805cc144497d76a436f66a21fa57492bee7ed1257826fb992f03b9b2b6f/coverage-7.17.2-py3-none-any.whl", hash = "sha256:e674027ceb6bfd959f1bb035000fd20fa8b717dc6765adaaf8bca347822c8c7d", size = 219280, upload-time = "2026-11-04T19:52:32.726Z" }, +] + +[[package]] +name = "cryptography" +version = "50.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/af/182eb91b0df3fe75c4d9f26fe70684569566745f6ba7e5c9c73a862c5252/cryptography-50.0.2.tar.gz", hash = "sha256:7b46165bb56eb4704e2eaaf86f3c940d19154535d9b0ca7d6d590b04060e00d5", size = 880623, upload-time = "2026-09-30T15:30:04.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/56/d194340cc4a57535e82e1bee9e89667ac4b7c13b5d3f59686deae3094dd5/cryptography-50.0.2-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:fa8f5efb344d6908a1ce62f4a24e2e5780f825d6f53f5f50ec5ffacac72936cb", size = 3914904, upload-time = "2026-09-30T14:43:44.339Z" }, + { url = "https://files.pythonhosted.org/packages/d9/69/c9bd862c3bf43d6399c433caf002df16e2dffd4be49bdf515cda38038711/cryptography-50.0.2-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:79def8d059362e7831389ed3be0ecdf58a89386e1271e35dd9f5af84e81bffd0", size = 4731146, upload-time = "2026-09-30T14:43:47.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/69/64cef1f702bf6657e0cc186ed1a2891d50d29fb41586b254e1c07adea261/cryptography-50.0.2-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:630ebfea3bf689d075f82316324ff7433dc447fe6bc1bfc76524b74b4a9567d2", size = 4719841, upload-time = "2026-09-30T14:43:49.01Z" }, + { url = "https://files.pythonhosted.org/packages/38/6b/61a3f8d8c5e1e49a6cddccafc4015cc1c0021360ab0acb4080e7a423644a/cryptography-50.0.2-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f9f6143a8c75945eb960d9eb98905a441394abfa24afaae239d514ffb2586480", size = 4738340, upload-time = "2026-09-30T14:43:50.932Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2e/7212ca32fd43dc91f2f41db20160b268098874b4c9a0e7be94d6835f5b2e/cryptography-50.0.2-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:a582ab2ae1d34f67112cadc86702774c9ea4374df6bca6afe672817203c99134", size = 5367029, upload-time = "2026-09-30T14:43:52.911Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f1/b474e930c4d910328780e3940da76f5aa5cbc48ce1fc14e44d239d9ea9db/cryptography-50.0.2-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:4061c0079120205fb760c58acab6443e217307dcf05e3702cf970e0689972856", size = 4753050, upload-time = "2026-09-30T14:43:55.272Z" }, + { url = "https://files.pythonhosted.org/packages/7c/52/9af10e80ac16b0fcc2123f9cbd5e7afbd0fd5075bb7a607c592258a39cda/cryptography-50.0.2-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:ac9ed99d81760c62fe89d5f0815cdfa1ba9a35141cf30f1c2d044f04b4803d2e", size = 4376724, upload-time = "2026-09-30T14:43:57.24Z" }, + { url = "https://files.pythonhosted.org/packages/71/37/6202e488cc1eb625ea110c292c6bda92823176e023f427d8d5660ce8d632/cryptography-50.0.2-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:87e9ce85beb6b328ba370cc6e6aea483c92617b4c95b1d33a49297eb662bfb04", size = 4737859, upload-time = "2026-09-30T14:43:59.541Z" }, + { url = "https://files.pythonhosted.org/packages/8f/30/e86d7d518489b0ae2497091a35287abcb1a2ce4037837a34afbe9b1d6964/cryptography-50.0.2-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:f265528741e048bce55c3463ed721fb0aa45a5888d8add8cfeccb3035451bbdc", size = 5324103, upload-time = "2026-09-30T14:44:01.901Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/2c833a049475e0a3444e94c7d0aca0aa51d166374a449b09e92ac98138de/cryptography-50.0.2-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dab55f57c74c3cad24c323bacbbd04be4705ba6eb0d92e920b1fc4837ed5079", size = 4752576, upload-time = "2026-09-30T14:44:04.545Z" }, + { url = "https://files.pythonhosted.org/packages/6c/5d/906970b83bbfc1f5bbfb677a143c181f2801f23b6a7204a3b47c42c97e65/cryptography-50.0.2-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25784ce8b9621c90c643efb9e1e2162ab3b0224cae446ad5e70e7fcb1ce18b51", size = 4870819, upload-time = "2026-09-30T14:44:06.884Z" }, + { url = "https://files.pythonhosted.org/packages/68/e3/f2298d3bb55e0c4a91841ec4d01b3f020ba8c5fbf15ccdcc6dcf03f97025/cryptography-50.0.2-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:85d0d9a31b9098e98534226d5686b47264b95e62ce459dc2e62fdfc809f9fe93", size = 5030152, upload-time = "2026-09-30T14:44:09.443Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4f/adfc442765721292fff86d314ce385d3249d22db42295c0dd057727b60f3/cryptography-50.0.2-cp311-abi3-win_amd64.whl", hash = "sha256:7afa5a6602a9f29af1f3a2965f831bae7c9d5d597b7cbb716d41ab3b7d89879c", size = 3824692, upload-time = "2026-09-30T14:44:11.671Z" }, + { url = "https://files.pythonhosted.org/packages/ce/cb/52eb3770c0d0be2702a98c6e96065ddc0a2877cf0845aa9c23397c142cd4/cryptography-50.0.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f785f6161f202ab04d8ca194158968798e480ca058943907972da5f12e2881e8", size = 3892731, upload-time = "2026-09-30T14:44:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/19/8e/aa1fc533d4546b127b45de8aa024eb5933d23eff9debfe25931e56861095/cryptography-50.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0ecbc5652bdb6fc9eaf89a7d196e20941adfe812f43bc4ca05d9150496821047", size = 4710431, upload-time = "2026-09-30T14:44:15.427Z" }, + { url = "https://files.pythonhosted.org/packages/6a/64/72bc3f75176e7e406b748a3e3830432b8c51297b38368713df04dc04898a/cryptography-50.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ab50ee449bf968271e820086f10a33d101dd060370abc10bcd22279be2656539", size = 4694824, upload-time = "2026-09-30T14:44:17.69Z" }, + { url = "https://files.pythonhosted.org/packages/4e/c6/62c77550edfa5ca3f14bf44a1e6739b9fa09d6e998a11d97ed8213bccc98/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a9f7355e6fab51f6c369b86fb7571cffa05edee2c2121e0380a37fb9ac1cd5c1", size = 4716967, upload-time = "2026-09-30T14:44:19.661Z" }, + { url = "https://files.pythonhosted.org/packages/f4/37/cce70f150c432914460157a6ecc161752e053aa5ec0ef3b3f7dc6e31039a/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:94e5e9f108ee10471288214d3d233fbfbb492840a8457eb85178d643ddeb32c7", size = 5328676, upload-time = "2026-09-30T14:44:21.744Z" }, + { url = "https://files.pythonhosted.org/packages/aa/9a/6f2f0304d634ceafdeaf23e84537336664ac419b5d07611675c2ad3f6b7a/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:241449bf940a5d27309bd317e6f9a2af6932113818bb2b8f5c59ddc7ef16da18", size = 4727698, upload-time = "2026-09-30T14:44:24.178Z" }, + { url = "https://files.pythonhosted.org/packages/1d/de/66bcf9244d118663b2e1aaded8990f4640e3d7b7411870a5765f252074d2/cryptography-50.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d8947001be83df1394050758ce0e745dd74fb134eef0a4b5124208dfc3a68c37", size = 4354821, upload-time = "2026-09-30T14:44:26.263Z" }, + { url = "https://files.pythonhosted.org/packages/bd/e6/db28a28c7b6c676addce89136de3d8db49ea825a8c863472e36e42ead4ad/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4a20ce1e5cb4284a86692fdcba7cb8754185c6b2e5c56fcef3751cf451d3cdc2", size = 4716748, upload-time = "2026-09-30T14:44:28.447Z" }, + { url = "https://files.pythonhosted.org/packages/30/96/01546c7f69ea0e2ab790a2e4f0934a4052fb9b388147fbf83c2fd72f1e57/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:84f964e537f916e2cc85199e5a88742e964939b575ac8598b3f9d6cc416cdaf1", size = 5285085, upload-time = "2026-09-30T14:44:30.704Z" }, + { url = "https://files.pythonhosted.org/packages/6c/01/03263395f74d50b071e9e66daace3f8bef80493e5d410726f2ba8554736b/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:828d49b0ff5a0e3975865571c5d91dbbdd0d38d8289b249a163e9425413a5e05", size = 4727268, upload-time = "2026-09-30T14:44:32.92Z" }, + { url = "https://files.pythonhosted.org/packages/eb/94/2bfe8f29ec0cc9c0d99359c4161adf32858e4934b72c6d100d2ac0bbe962/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:deb9fde5c60e437ee4821bc9bc39ff31b42135c27e1dc61ef0a629389c1de62e", size = 4849503, upload-time = "2026-09-30T14:44:34.969Z" }, + { url = "https://files.pythonhosted.org/packages/54/44/e80651ecbf0e42b62e2bb5f5768916e07eea72e1297338956a61df361f88/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8c71ba2cd31fc93748c38e1b613200ff1c2665cbfd5341fe3a61cfde35a1430e", size = 5004057, upload-time = "2026-09-30T14:44:37.064Z" }, + { url = "https://files.pythonhosted.org/packages/f8/cc/1d33befb3cd7ea7e77d2d73f43f2066471da1b21f24a6156efcaabf6d2e8/cryptography-50.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:78198641e5be9521beea5aa782bb551a58068d10e6eb04c9c680c1b69f2e7d45", size = 3795868, upload-time = "2026-09-30T14:44:39.71Z" }, + { url = "https://files.pythonhosted.org/packages/2d/49/93f6a6e7a87c9aa68d44d3e1cdb5fe8f60c90d5d2f46acae9a56892816b8/cryptography-50.0.2-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:edc3342adf8f697fc5f59c887a304356f147b397809440ed64e2fa6af2f50f37", size = 4133708, upload-time = "2026-09-30T14:44:41.807Z" }, + { url = "https://files.pythonhosted.org/packages/8c/75/32ac2a56243d778805c16ca6a32b8f74fb757df7e28d7ecb560afafb59cf/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d370b8d1dfcdf7130178137f6fbee6140774a1acc6cacefc4b42643ec11d0a3a", size = 4956267, upload-time = "2026-09-30T14:44:43.693Z" }, + { url = "https://files.pythonhosted.org/packages/aa/a4/2c8d734e43d97f0842ee9f1b7b4bfb3d0cf5e19edebf43c2afe6675c2320/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f2f9bd7f90c64fe89253f0a2c05e3c4856072660429ce8831b4235bf29403a67", size = 4966465, upload-time = "2026-09-30T14:44:45.769Z" }, + { url = "https://files.pythonhosted.org/packages/c2/58/ee288c829a6f41f6235ae9dd33d82fd19b45442b65b4c8a3da36963d9f7a/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_aarch64.whl", hash = "sha256:e275096ea1e60cc595cda2836fd4a6c725d1125108b868be17f53684d164e2cc", size = 4959356, upload-time = "2026-09-30T14:44:48.211Z" }, + { url = "https://files.pythonhosted.org/packages/92/20/9ded6d51ddd9897f6b6e81fb9ebea7951d7cc5d6c890b0ed8abf77a51a80/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_ppc64le.whl", hash = "sha256:b13478603dcd0a2479ff8e87e2c19a7d525734686fe3c49542472293a204212d", size = 5548822, upload-time = "2026-09-30T14:44:50.86Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/8df951850d6b31d2a00218f19e2b3f999523437ed7a819df7fa427942fca/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_x86_64.whl", hash = "sha256:58a0c478eeca76fe5e07993c5a0703def34a6dc6a0cda4f5564639b33112ffe7", size = 5001199, upload-time = "2026-09-30T14:44:53.379Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f9/36b3022218ce75b7cdf068fb95f809f9bd0d820e4955ef43b90c255cc7ac/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_31_armv7l.whl", hash = "sha256:d38cdff612d06fa6a32840d5e1b1f7a27cee4a349aa9085d94a67789d6bfd408", size = 4629333, upload-time = "2026-09-30T14:44:55.635Z" }, + { url = "https://files.pythonhosted.org/packages/8c/72/20f99a219f6af47cdd1cbd978c243b92d71496e168a746138af44ded4f29/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_aarch64.whl", hash = "sha256:fdd28f912fccfec1846a94e2e1e8f9b0012f557f0c46fe4f3eb0d7a87afcf90b", size = 4958822, upload-time = "2026-09-30T14:44:59.639Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/196f112617fb08eb4d608a2a6c422373d46f9cc2857f38fc0667033c0899/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_ppc64le.whl", hash = "sha256:cbc8738fd8526d80f35cb3a40d41f41a2e7030bb3b18b09a6778ef63d291c2fd", size = 5506351, upload-time = "2026-09-30T14:45:02.267Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/83378121ef3eaaaf71d4b781577ff794acb39b9e1b87a3f156898c8497ed/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_x86_64.whl", hash = "sha256:e105ab60406787da31fccc883fc0f733af1efd78f0136a4599692c4083a73d0c", size = 5000859, upload-time = "2026-09-30T14:45:05.009Z" }, + { url = "https://files.pythonhosted.org/packages/22/f7/70fd7ae4d1dbfa7ba29b02e1b9068771519a86027756510b700ce81086a8/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:6f8700550aa1474a91e5dc07049c46f98b423b5b1ddd0483e0b51362eeeaf5be", size = 5092151, upload-time = "2026-09-30T15:29:15.932Z" }, + { url = "https://files.pythonhosted.org/packages/d4/be/688367b74de86984bd58d8efacfc7c9e68b89a6a22ced0fb4f38db50254a/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:c71be1cbfa5cd9a41ee452acf1eccd82b2c05950358b106ec8ceb83411d1a020", size = 5286120, upload-time = "2026-09-30T15:29:18.309Z" }, + { url = "https://files.pythonhosted.org/packages/39/d1/55f8a3f2ef5d1529e16835ef10cf0fe3d559ce237b46dddc440c0bba3649/cryptography-50.0.2-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:c423ab384a46c4dff7217b2ea5ba2e11cffdeab6441acd04cf65a369caf0366c", size = 4111557, upload-time = "2026-09-30T15:29:20.155Z" }, + { url = "https://files.pythonhosted.org/packages/23/ad/ac987755d00e1e64273760228d2635ae38dae2be83e3c6e0d3289d91dec3/cryptography-50.0.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:0ec5f09541743261e66e291b4a0cbf0fb2997aeaab6d9e9c740b9dba1b58d1c2", size = 3943588, upload-time = "2026-09-30T15:29:22.265Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8d/6d585339bedf85d45044c85d8412dac53f2bb6f918e8b7777efba1787844/cryptography-50.0.2-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5e67125c7dca78d199ec4e116aa93dbb83494808ecbb8211a2cb09b1bf41dbd", size = 4756166, upload-time = "2026-09-30T15:29:24.58Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f1/1c1f6874e8550cfddd4b688ceb38cefb6ed15ceed224d56f133f3d88c214/cryptography-50.0.2-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee247f5c245c9a2fe7c8e2214e295918838e44e00a45a6718451e4004219e767", size = 4749145, upload-time = "2026-09-30T15:29:26.807Z" }, + { url = "https://files.pythonhosted.org/packages/c1/63/61b15dc1a8de03fe0adbe3fd7608b3ad5c73bf50993bbcb1faaa930afe33/cryptography-50.0.2-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dfe9763530994147d9af1def057a5b9658b00e8f8fe8743d144d1e0911c2e454", size = 4763638, upload-time = "2026-09-30T15:29:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/fc/35/b345bdfa40c9126df1a9d33236aa98418367931b8725f84fc3ae2b98dc59/cryptography-50.0.2-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:58ddb5a8e3179d12f19e4ea34d2d32e9d63a4baa142c875c1eb59f41b7243acd", size = 5382217, upload-time = "2026-09-30T15:29:30.589Z" }, + { url = "https://files.pythonhosted.org/packages/4f/87/ef344a9e616871f2519c22d6afcda79ddd5d35e9592d95eb6e677608d055/cryptography-50.0.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f21e8a22c8605750c7af886bab299a363721264061b4ac0a30efb73cfd58efc5", size = 4781387, upload-time = "2026-09-30T15:29:32.605Z" }, + { url = "https://files.pythonhosted.org/packages/90/5b/f2fdb13cd0b96f6f932c8627bb292a45f11c64d21620a8e120aee9a3b848/cryptography-50.0.2-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:9c8402a82ea0dc4ceeab793db05f0fafa8ca139ca34fcde5df0f596103c74107", size = 4403790, upload-time = "2026-09-30T15:29:34.374Z" }, + { url = "https://files.pythonhosted.org/packages/bc/ce/7e4f662b1e3c393513569e402cfc85ac7da0bd3d5435e122a3140219eb2d/cryptography-50.0.2-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:0ddc924c04591c2811ca024d62ecad4f7f6f08af8939c211438f48a16bd23602", size = 4764319, upload-time = "2026-09-30T15:29:36.149Z" }, + { url = "https://files.pythonhosted.org/packages/3c/3f/86ff33ce34cc0de6847fb96e035a1a760d81652e38643f617c02ad32ef7a/cryptography-50.0.2-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:a6557e5f38e065ca9fbdaf7cfc7435ecb1d113aa81a022d1b51921ee7432e227", size = 5338560, upload-time = "2026-09-30T15:29:39.053Z" }, + { url = "https://files.pythonhosted.org/packages/40/cf/6b5c8e2fd9202d98988ab7cb5cc5c991704c4ad55f492ff408e4969f83f1/cryptography-50.0.2-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:1981f1db4630889b9ef7803fadef12b056f428cb6b85c27ba57b774793b6093c", size = 4780973, upload-time = "2026-09-30T15:29:41.251Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/8d6ebc7dded797bd0f0160d52188021211f011a2b164ef0ae1dac4587465/cryptography-50.0.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7a8701d6b584d76e909e3d305b7d126b41439876a5aaf76cddc67fc230eafa2e", size = 4897738, upload-time = "2026-09-30T15:29:43.106Z" }, + { url = "https://files.pythonhosted.org/packages/d4/aa/f3f6e0de7e6253b8baa8b2d8fb9d50924fa75cee3d4624bd4bc1208ee923/cryptography-50.0.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce47f66801c20ec6c6632453bb5960fe38939e9306970b48b3a5a26de7745d94", size = 5058280, upload-time = "2026-09-30T15:29:44.827Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b6/a1faf3a27ae9405fb34b1713cc73b2d8a26b04d5c561578fa2e6ef3e5bb9/cryptography-50.0.2-cp39-abi3-win_amd64.whl", hash = "sha256:4e81d95e5bafc2d6e34e4bed780e53e4d5b9a2f928573428aa4d35fbec1eb0de", size = 3854095, upload-time = "2026-09-30T15:29:46.782Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/d36966de7304047a1001a7559fbf266c464bb5d8cc85464536ef8c9bcc32/distlib-0.4.4.tar.gz", hash = "sha256:ca4175b4ac7f71223cc30ed7248c45d2b38c2439d8ee6e498ab67ed63cf3508d", size = 621304, upload-time = "2026-10-16T13:56:34.203Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/2b/238f02a4927fa2e27aa995371d240a468b52e42eae44a678434aff736b38/distlib-0.4.4-py2.py3-none-any.whl", hash = "sha256:cf09d55b1e85a89576b036aeb71550bfd68320f3f21761ca329eadadad918638", size = 472099, upload-time = "2026-10-16T13:56:32.053Z" }, +] + +[[package]] +name = "easygui" +version = "0.98.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/ad/e35f7a30272d322be09dc98592d2f55d27cc933a7fde8baccbbeb2bd9409/easygui-0.98.3.tar.gz", hash = "sha256:d653ff79ee1f42f63b5a090f2f98ce02335d86ad8963b3ce2661805cafe99a04", size = 85583, upload-time = "2022-04-01T13:15:50.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/a7/b276ff776533b423710a285c8168b52551cb2ab0855443131fdc7fd8c16f/easygui-0.98.3-py2.py3-none-any.whl", hash = "sha256:33498710c68b5376b459cd3fc48d1d1f33822139eb3ed01defbc0528326da3ba", size = 92655, upload-time = "2022-04-01T13:15:49.568Z" }, +] + +[[package]] +name = "ebcdic" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/8d/93f35b03207b5bf9e74deed503a2803bf4aab0699dcd05cadc122e03fa00/ebcdic-2.0.1.tar.gz", hash = "sha256:3a1bedfbeee76cab2d7e4de62409ac015cd7afb25d590fe1546105c32a065cf1", size = 35355, upload-time = "2026-03-03T02:24:01.635Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/19/aaaeab02f9faf69f7a3800e80580c5e3cb36117e9f796b490f5d605907a7/ebcdic-2.0.1-py3-none-any.whl", hash = "sha256:645034983a6f4837f0e46e4bfe59d67de0b19e7c4294d33beebe74565cdefae6", size = 127069, upload-time = "2026-03-03T02:23:59.797Z" }, +] + +[[package]] +name = "extract-msg" +version = "0.58.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "compressed-rtf" }, + { name = "ebcdic" }, + { name = "olefile" }, + { name = "red-black-tree-mod" }, + { name = "rtfde" }, + { name = "tzlocal" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/12/49/a19215988ef2ded6518c75717dc73aa0a773c2efcc5b367c00b2f10ca5a4/extract_msg-0.58.2.tar.gz", hash = "sha256:83bc225a0942d80fd97a445c0724e6472b3d821b59df1a5634421bbd19e265fa", size = 355002, upload-time = "2026-11-05T23:47:51.983Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/f2/d0a4a605aa9b03ce44c4b216e99413fac72f4beb835bb58dc255817057aa/extract_msg-0.58.2-py3-none-any.whl", hash = "sha256:6211f7ebe146855a6d69aef60f14c197b583ffef00b9dc190e35644b2ea1ebd7", size = 360413, upload-time = "2026-11-05T23:47:50.567Z" }, +] + +[[package]] +name = "fastapi" +version = "0.162.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "opentelemetry-api" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/53/f6fed628a0c3d6a284125a93f9145b02ecc2c394735a878b5ad9938c8e17/fastapi-0.162.2.tar.gz", hash = "sha256:9ebd2a69b579141315b2447d8e3f518e6fd909abd6c01cac5cc6b06d5c8841f4", size = 530366, upload-time = "2026-11-07T15:41:39.838Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/fb/0dc0f819163bc6b7f9e6802d7d0b1ac180fbbe4e75dbd10655c6a4d77796/fastapi-0.162.2-py3-none-any.whl", hash = "sha256:d0584f9662317e01140df94c64f4bed1d8b059fe35496e30c9c92f70e6e5ff15", size = 151671, upload-time = "2026-11-07T15:41:38.509Z" }, +] + +[[package]] +name = "filelock" +version = "4.2.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/1d/d730c664fcb4f1d264a722722a3134cf0881854f73c1fd58abf87572f232/filelock-4.2.9.tar.gz", hash = "sha256:96530b7c538d4ea08493ab067247aab7948c54d8cd622cce711c97cccc5d9896", size = 663116, upload-time = "2026-11-04T18:37:10.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/05/76184fe08339723d643ab47887a8e4de8f2921ca4e008617ab7490af7857/filelock-4.2.9-py3-none-any.whl", hash = "sha256:a379c50a729e5b68c8519a4d26489f755d9769960a236ecd838190e2a78db2e9", size = 164734, upload-time = "2026-11-04T18:37:08.273Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httptools" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/ec/deed52912ab7ca6c0b12859330c571c60c61d7267b341b28951fcbf13694/httptools-0.9.0.tar.gz", hash = "sha256:d484ebb7e3a3f3597b0f645fbd1b85633674ca808c1f5ba11c2caf7c66f5c8b6", size = 282523, upload-time = "2026-10-09T19:57:04.301Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/04/223994f8589750d2a36ceb43203e739cf75bd9e12c226680d73567766908/httptools-0.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4fb995082fe41ec410b33c48b54fb1d44abb8a6ee762c31e8c42519e8c3a30a9", size = 117115, upload-time = "2026-10-09T19:54:53.356Z" }, + { url = "https://files.pythonhosted.org/packages/31/d8/b4407836e567a862ce79d78a628d785db99aba52e63496d68c60eed0d475/httptools-0.9.0-cp313-cp313-macosx_11_0_x86_64.whl", hash = "sha256:b9cd15cb7cf0d5cc41f649fd789aae12c56c3b83eff593f8e095c1d4555ad5c3", size = 113225, upload-time = "2026-10-09T19:54:54.81Z" }, + { url = "https://files.pythonhosted.org/packages/79/f6/0caa51b077492a7306bdbd9dfb907a2246985f0aed1fe2d086255921848b/httptools-0.9.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:088de1738e1af624466a01c35d652dbe6fb825be887c76d68aa850621d81db88", size = 520112, upload-time = "2026-10-09T19:54:56.3Z" }, + { url = "https://files.pythonhosted.org/packages/fa/da/7a47b7c2106bb10e6d4c04a139d045257a4f93c672fae6f0b9e92b1f7bc2/httptools-0.9.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b1ac7f1bc6c0dbf90684b77571a51a21b2463909fd916ce0ac9bfc4d566dc75", size = 516079, upload-time = "2026-10-09T19:54:57.938Z" }, + { url = "https://files.pythonhosted.org/packages/0f/4d/417b42d2663acf4f5aeb2718dc894ec2be4e3dcfd8caa2d3bf9ee2dce511/httptools-0.9.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9430f65db521db7962ad951571d446171213686f96c998a54dc18ed574821e2", size = 535040, upload-time = "2026-10-09T19:54:59.769Z" }, + { url = "https://files.pythonhosted.org/packages/cb/de/8df4c09a33ddaf50f697719f20201cf93631ef4b50cec05e42acf179a7c1/httptools-0.9.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:52fe0176682a25b15370f23f5b0f1366a84771df89144fb0cd979cb72a94b5ca", size = 462799, upload-time = "2026-10-09T19:55:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/e8/90/1bfe91e3fca29c541d85d7ba8ed92a406d4dd13608c281baf7ec75369fec/httptools-0.9.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:757e3f79cb865a7db94e0db5f4d0ed3284a69e39d53568f433982ea13c60cac1", size = 497596, upload-time = "2026-10-09T19:55:03.201Z" }, + { url = "https://files.pythonhosted.org/packages/b0/af/2bbd5af0dd7a0e0c3b63bfefafd87a07041eb13d7cd710fbf30708b70773/httptools-0.9.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6ff5f0ed70783dcb9562dbd20edca51c3d4d277f128223709e3da6b75986d1d4", size = 517110, upload-time = "2026-10-09T19:55:05.011Z" }, + { url = "https://files.pythonhosted.org/packages/d4/7a/9f165817c3e27df9098f3d50a675417d8721253f1073434f48a3f9d9a6c2/httptools-0.9.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0f537e5e8152e8d9cae82804024790cb973061abd3b7ef8f66f46e2b5c7bb51", size = 459198, upload-time = "2026-10-09T19:55:06.985Z" }, + { url = "https://files.pythonhosted.org/packages/93/20/b93279e334946c359d39aaf405241c6fd60f9e60da709bc4156731a4413c/httptools-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1a7f1df31829c258158be01bb04eb668c4fba7df1ddf2262131a972962e651b6", size = 502996, upload-time = "2026-10-09T19:55:08.733Z" }, + { url = "https://files.pythonhosted.org/packages/86/c9/ac3657943d40c5a9949b72565ee03151e480fb18c062c7c13c0c0276df6f/httptools-0.9.0-cp313-cp313-win32.whl", hash = "sha256:714bf348f468532d86bed670837e7d5ddff3834dd7f5d3c08066da400c86f088", size = 85878, upload-time = "2026-10-09T19:55:10.275Z" }, + { url = "https://files.pythonhosted.org/packages/74/69/d23079cd4bc16d11e49c3f51c2540c018736f26701a2a73183cae9255a1c/httptools-0.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:805b0f2618e5d4c3e28f45b731eb1a0539691ae4a2f97b4ce014de0bf96a1ff5", size = 91549, upload-time = "2026-10-09T19:55:11.701Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ed/5ff678a774b721f054c095f04d84fc536e7369ea4f4c9af3813a518d95b6/httptools-0.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:bfdabac0c6d3d6a5be8c2a100a001c92c14a39bbafd5999545a675c493626e64", size = 88043, upload-time = "2026-10-09T19:55:13.046Z" }, + { url = "https://files.pythonhosted.org/packages/31/39/0965023968452245ece67b161adbf7c5652f8d0697ac69312f9d21849411/httptools-0.9.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a4050a651e1f2faf05eb028ce9f2168abbcee9e24b209f5c1f2eb96d8c569e4", size = 118142, upload-time = "2026-10-09T19:55:14.491Z" }, + { url = "https://files.pythonhosted.org/packages/31/39/a6ec662d81059e505e953af709797038e83e489014df721e506f4fd0d3c5/httptools-0.9.0-cp314-cp314-macosx_11_0_x86_64.whl", hash = "sha256:130635fea6e611a6b2026120037965ddb88b3dafd11bb64e264b101a70a76630", size = 113943, upload-time = "2026-10-09T19:55:15.887Z" }, + { url = "https://files.pythonhosted.org/packages/72/04/4ecb7251a6c55bef61b157bb93fd44678943c35702a5966e4d5ebda2d450/httptools-0.9.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:18d800aaa2d6bff7d889df810d1b19a5fde72b1f6c0ca96e8d9f28a692fe5460", size = 514397, upload-time = "2026-10-09T19:55:17.48Z" }, + { url = "https://files.pythonhosted.org/packages/31/5a/0c26c98ee06f0f39608de715e7ca868baec942171a77feace5a0ba548ca6/httptools-0.9.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0e45def4d9ce7073e2226535572442d9d6efb4047c7a5fd8960807e877ce70a", size = 514383, upload-time = "2026-10-09T19:55:19.221Z" }, + { url = "https://files.pythonhosted.org/packages/d4/6c/0f85d4f1f579c49aea6e4946dd304e9f33a680382b5117970ab887885bc7/httptools-0.9.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1f6da814aeecbc6cb8872d6d3e85ed16e8ab1653f9557cea8658725ce212348a", size = 534993, upload-time = "2026-10-09T19:55:20.992Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/97a836533b7bc9e269fc6d075c2d27669ca9786bf43f229158b9b4b15021/httptools-0.9.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8e1e037bb57dbc549c6fe20370b763ea74bdb09413cdcf857e4f14d9e4e2fb13", size = 461494, upload-time = "2026-10-09T19:55:22.785Z" }, + { url = "https://files.pythonhosted.org/packages/67/cf/a2d5e8dc3bad9b0b966bb546170234b4614275346cccbc01f6cdb6fce3b3/httptools-0.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:cd3e55223a77d6e08d5730ebacb4930ecca5d2ce7c57e7ba10833be7e52903f1", size = 495859, upload-time = "2026-10-09T19:55:24.9Z" }, + { url = "https://files.pythonhosted.org/packages/bd/d9/7472c4ca2aa1cfe6d0f9923380784b034cb77addc88589f2e5c92fd3b4df/httptools-0.9.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:beb2c8a34cc90fb4d862b7284eafdb322030d6a8b2ee5eb6a744f84205beedc3", size = 516303, upload-time = "2026-10-09T19:55:26.84Z" }, + { url = "https://files.pythonhosted.org/packages/c1/dd/f9be002ba859714cc306fe86204b7cb12bac091be66a7e23d7bb25d259bb/httptools-0.9.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0cc339a807c156d840b54f8bf050ba0fc265eb81692c24bca8535b52fbd797c6", size = 458188, upload-time = "2026-10-09T19:55:28.571Z" }, + { url = "https://files.pythonhosted.org/packages/89/7a/ed8bb5344071afd12c87e57e8839fa65abc3895b92a5d065be79ecacb919/httptools-0.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b6ee42112d785a913dd63ec0335435a3dddbea5040c151252db815b0095cf066", size = 498356, upload-time = "2026-10-09T19:55:30.301Z" }, + { url = "https://files.pythonhosted.org/packages/04/8d/3f1390c901d4a266ad9d5b988c47c4883e322e6f6cc021c592b9a050fb19/httptools-0.9.0-cp314-cp314-win32.whl", hash = "sha256:d1e329a1866981efe0201d05a374617f6c6cf14434a501d78ab22793d1ab1fa6", size = 88479, upload-time = "2026-10-09T19:55:32.071Z" }, + { url = "https://files.pythonhosted.org/packages/99/05/7de70a4eea3b52d31a95fe64eb5775ccdead01e4913e4741b4424e9ef180/httptools-0.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:edd5aa045fa3cc57143db018dd32ce7962bd5b525d05230709015d7e570100aa", size = 94809, upload-time = "2026-10-09T19:55:33.423Z" }, + { url = "https://files.pythonhosted.org/packages/e8/79/7f6c354a8f8f74381fd473f365d2db3cd976ee8d1422b8dd7455dfc52b62/httptools-0.9.0-cp314-cp314-win_arm64.whl", hash = "sha256:6ff0145b34610e57c9fae20df4e133c8d54266447387de6fcc0bdabfe4db4569", size = 91508, upload-time = "2026-10-09T19:55:34.764Z" }, + { url = "https://files.pythonhosted.org/packages/94/0c/f9e8148ca684b41b4b5d0ced0860530b9a9bcb7c38bf727d83dcbfea42d0/httptools-0.9.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:80eae881cfb69383303e9a4d7961a478025b89c24f38f2e69b30c516fa0d57f2", size = 123684, upload-time = "2026-10-09T19:55:36.445Z" }, + { url = "https://files.pythonhosted.org/packages/3d/54/3c1d910e8f0bc9ee0ba7867b687e3272c8ae4a7da2df2fbf1b2bce77f0f9/httptools-0.9.0-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:b2ab3aad55d75d0b8df8d8a1b5920baaec9b161112cd5e95984848b4d2cd3dfe", size = 118378, upload-time = "2026-10-09T19:55:37.851Z" }, + { url = "https://files.pythonhosted.org/packages/d4/ce/3b9694880da927ae69b5629b8847cfe73d14584be2aa974a92ed2675b7da/httptools-0.9.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:db735a23ecb0f0450d2b24e0a05fb00a8a35c9db172919c4d3e023e7c7ee4c9b", size = 591295, upload-time = "2026-10-09T19:55:39.501Z" }, + { url = "https://files.pythonhosted.org/packages/3c/89/1ff2835b6adf5c08a477d3a199e72b71e7f26df55ceaaed7d7364d745a1d/httptools-0.9.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:995b52f7c260ac7023640221f27472303968753cb6fc6fce1ddfb0e9db59a398", size = 603709, upload-time = "2026-10-09T19:55:41.404Z" }, + { url = "https://files.pythonhosted.org/packages/24/40/4f59a0d9dca6d60002e7cb5dbf1441b558ced5a65b5b4131d57cbbd7c806/httptools-0.9.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3af4e45ff455fce5511fdf2653c1ce428ef09c56fe37a83eb4d924c2d474f31e", size = 607379, upload-time = "2026-10-09T19:55:43.119Z" }, + { url = "https://files.pythonhosted.org/packages/bf/19/381d444a3ba704cd5c67eb4617ae7a08e920a8239c688f23ba0de07a270b/httptools-0.9.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ce8e723b4637034b76f5382a30a6b725518c332273e8d62a6c7d46e90837c947", size = 530031, upload-time = "2026-10-09T19:55:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c5/c9ba7758bf266240f598934510af4a800edafd9c8eb1fcf15feac0427063/httptools-0.9.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:465bc1526debf53a3be92022a16ca0c38f891ea3b5c1587af4f52e44020f8a07", size = 575129, upload-time = "2026-10-09T19:55:46.536Z" }, + { url = "https://files.pythonhosted.org/packages/db/87/c17f3a53616a3849681f7c8e913ce966487b95038504bbb035c38f5f2fbe/httptools-0.9.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:8463b34ebde3f000627e9dbd8a545f995ad49fbf7ff9dd5abc0cd507da98a603", size = 582996, upload-time = "2026-10-09T19:55:48.545Z" }, + { url = "https://files.pythonhosted.org/packages/88/e3/cb33ba1348ddfa5853f96021f4c38674ac383b92c944492cf7638bd6bfd0/httptools-0.9.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f9489c1d87160c126f73b004742fe8654fa1ce37ed89e9e01330a1c10aaecde4", size = 526150, upload-time = "2026-10-09T19:55:50.261Z" }, + { url = "https://files.pythonhosted.org/packages/e9/00/af0e2f33ba5be60803a492ad377e798714d0c970e76015e313849b351ef7/httptools-0.9.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:06bfe7fad972a417269d8a5fc53b87e4eca970354abf5e9e24336fd06d64292e", size = 571731, upload-time = "2026-10-09T19:55:52.422Z" }, + { url = "https://files.pythonhosted.org/packages/b6/35/e67e9c9dd3da036ebfcbd273eec44bd39213f952d638858b09b9f3ecaf3f/httptools-0.9.0-cp314-cp314t-win32.whl", hash = "sha256:c42424213c28804f8d0e20f5692106cfb57bf72e1dbc4092b8481fb2f9e4c707", size = 94622, upload-time = "2026-10-09T19:55:53.982Z" }, + { url = "https://files.pythonhosted.org/packages/c5/5c/af620c73de59b5f3d431ae778c7412d30bba7bf56ca8b4140107a8ac0e54/httptools-0.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:bb1533541c729ad422f870a780d8b4af924f9817d45b5f580390418cda72eaa2", size = 101934, upload-time = "2026-10-09T19:55:55.417Z" }, + { url = "https://files.pythonhosted.org/packages/90/90/fc6019b5179d13007c6c3039346ea2696cf2e94369d6ca96e57f23b01989/httptools-0.9.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6f9549ca354a1d6d6167c458a1f1b12147726b968f02dd64b6a5801dba91ae0f", size = 97211, upload-time = "2026-10-09T19:55:56.878Z" }, + { url = "https://files.pythonhosted.org/packages/d2/77/e226b16a2f291f2a4ce25a24a3297e98749d80b8a713b8f3b11d8a82e904/httptools-0.9.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:d3906b5c549ff2ad2473cb711e1fc65d76715c2726a402108fbf55eab6c6b49d", size = 117817, upload-time = "2026-10-09T19:55:58.295Z" }, + { url = "https://files.pythonhosted.org/packages/ff/08/050ad8985ec34064e4401e6e5aeca7238685bc218eaff20025f7c04b0723/httptools-0.9.0-cp315-cp315-macosx_11_0_x86_64.whl", hash = "sha256:cb2bb3ac0af7fdab2311b895c9eb95442b45deb14cc949b9e65545e74aa0be69", size = 113669, upload-time = "2026-10-09T19:55:59.915Z" }, + { url = "https://files.pythonhosted.org/packages/52/0f/af812488a4963ce59d97b73a00c72bba49f5eebca1a13ab6f114372b5e82/httptools-0.9.0-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:63d38e9a9a10a20fb57593742e63c6b1e78dd7f6ef5472de8e0b1e4cf4f3db26", size = 515633, upload-time = "2026-10-09T19:56:01.529Z" }, + { url = "https://files.pythonhosted.org/packages/50/6d/73c987b84e0d02fa6c4109c7ce6ea00518d0aa3005fb92b75553ffd5ddf8/httptools-0.9.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eae4e9c7a0785a1a715de0a74fb822ab40084c060f444f18f075d05e322aa7ef", size = 516049, upload-time = "2026-10-09T19:56:03.327Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f9/74cc01fba5a0ea05501eb39eddba4baa00c10e4d1caebdb78f23eaacafe5/httptools-0.9.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0adc974916efe1fbf89d0363a86dcb2c746727643e362ff398de1a4b50b6bc77", size = 534832, upload-time = "2026-10-09T19:56:05.068Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a2/a7bb90643c059e8136c2a5fdfb0d7e1a18b2c5c4f1a78f2de14b1303184d/httptools-0.9.0-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:050f84b7ec46a6efe0e5f521cf8729e3397c1cef4384f62ed8d5d68ca0045776", size = 466489, upload-time = "2026-10-09T19:56:06.757Z" }, + { url = "https://files.pythonhosted.org/packages/5e/19/bb3f18e05cbad9628e7f1254176c475e05ac79c72697ec7c144fc2cc877f/httptools-0.9.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:9b4da5789d7cf576c7e81f0088c632f6ee3786d87d17f08e90e703c22ce15633", size = 497146, upload-time = "2026-10-09T19:56:08.641Z" }, + { url = "https://files.pythonhosted.org/packages/25/e6/90e2433d7a947bec66a5ad22e948626a26672ff62aa3ebf949899f687a3e/httptools-0.9.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:f78f7ae1c2e5aabf29583fc0d302d8081a663776f84578025662eb6f5d63a921", size = 516153, upload-time = "2026-10-09T19:56:10.415Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c7/86373edd9d800eb723b8b68d3fce0e31d3e3211f9d7b0eaf8c3deadfada0/httptools-0.9.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:b2cc6991f16f6d666d48e4b57318104e7b29109e32e2f6b86e9d44c4e6a27f4e", size = 463141, upload-time = "2026-10-09T19:56:12.406Z" }, + { url = "https://files.pythonhosted.org/packages/65/46/8dc41d9ebf78fa56f609f251ed8ac5a9f66513b0ce712040bd7ada7b19cc/httptools-0.9.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:dbc9fd1521e573045d71b6afab7398439c5cc259e8cb9d416fe62d485c4899c6", size = 499125, upload-time = "2026-10-09T19:56:14.109Z" }, + { url = "https://files.pythonhosted.org/packages/7a/41/38db94fda8b266dcde50722a4fcef825b189380a220e02c682518bc1b430/httptools-0.9.0-cp315-cp315-win32.whl", hash = "sha256:34266cec8c1d4e3e91fcca7efe38971d6bdda64a7944f2a46ab576da15173680", size = 88370, upload-time = "2026-10-09T19:56:15.873Z" }, + { url = "https://files.pythonhosted.org/packages/4a/cd/347f12eb16e20972dcdacbca907f2c52d72a36542199a5bf3ca342c92098/httptools-0.9.0-cp315-cp315-win_amd64.whl", hash = "sha256:b5a3f5f70967a1aa2bc47fec42a1e19d2fb38c61700e3ee62b63a4af4f4fd001", size = 94617, upload-time = "2026-10-09T19:56:17.257Z" }, + { url = "https://files.pythonhosted.org/packages/f3/08/086ba2f53989d504a05f4669b03673a04fc72554bc37d4696c3c6132be75/httptools-0.9.0-cp315-cp315-win_arm64.whl", hash = "sha256:e0acbd474d0af4afacc6e66c4273f8a19e25f8af4379fc816388095ea6b01371", size = 91358, upload-time = "2026-10-09T19:56:18.641Z" }, + { url = "https://files.pythonhosted.org/packages/3e/3a/9ba59ec76d45bf8eb7ad3a18f2c6e9074fa4ce5cbbd3900fffb8d840f9e7/httptools-0.9.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:02bc5b3dcb6394b9d825fd62a7bfa0b2943063a3c89abc4492ad45e334a20eb5", size = 123063, upload-time = "2026-10-09T19:56:20.023Z" }, + { url = "https://files.pythonhosted.org/packages/18/2d/49eb389bda75a8ef0d04bf025dfb8412a3646637051c8a88bdeea700e343/httptools-0.9.0-cp315-cp315t-macosx_11_0_x86_64.whl", hash = "sha256:fc1a4f9d18d32a6e0a0a0a382986a60a2126f5144dd08715be7adb8df18e8a46", size = 117328, upload-time = "2026-10-09T19:56:21.439Z" }, + { url = "https://files.pythonhosted.org/packages/a0/6b/2d6439378fd3d1f9c06272b35d61f4519e2d9bf9967611df069fa6c23044/httptools-0.9.0-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:df3867518b205be3648e2fbd522bf380c851b5c2500588047505afdd786b6669", size = 588680, upload-time = "2026-10-09T19:56:23.056Z" }, + { url = "https://files.pythonhosted.org/packages/08/65/3fb50e861bbb6103ca58fd88b4127d346fc909eb9f06d250455033a3f698/httptools-0.9.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:26e1d9629f3bf70d23f0d22238152aec51c837a7c9e384cb74f356fdccad7eb3", size = 600031, upload-time = "2026-10-09T19:56:25.216Z" }, + { url = "https://files.pythonhosted.org/packages/90/9b/40d33d4098fde007845804b1c923ddf5a27fd48aca1c8080bdbdac6c16fa/httptools-0.9.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:050f7ab098121873c8f13e35857f97ab60a76185c8302bde9a384939bb7c3b96", size = 604407, upload-time = "2026-10-09T19:56:27.04Z" }, + { url = "https://files.pythonhosted.org/packages/17/37/472afc9000aca3c7dd61a9b8ac6f3e2765900e3614f8d7f13e772c9c5438/httptools-0.9.0-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8d90d10e9b6594c28f27896a68fab97fd784c43804e9fe419dab8e8dcfcf4b02", size = 529459, upload-time = "2026-10-09T19:56:28.944Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/9956910fb1d181578249cd2cc966c0c46ad3c558b43ac2b79af50f94589f/httptools-0.9.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b928ab0ecaa664e8caecc529dcb8bc881b6b35bb2b74bf9a39ae25f982ee8812", size = 570845, upload-time = "2026-10-09T19:56:30.602Z" }, + { url = "https://files.pythonhosted.org/packages/30/8c/d1c160a3cc2c18e41a6f763c3aad979530dfb295039449312b8814e19753/httptools-0.9.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:2319858018eedd0c0b2f950a620413c0a9d1352607be4267eb28209eca8b1e3f", size = 579194, upload-time = "2026-10-09T19:56:32.353Z" }, + { url = "https://files.pythonhosted.org/packages/90/3c/3f7cc49925928a8c82f4141d504b8b8c2901c4b35cb88800211828312561/httptools-0.9.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:931f45f84e15daafec5f82cc92e6710569e1f50933f3253d206eab4132bec678", size = 524950, upload-time = "2026-10-09T19:56:34.103Z" }, + { url = "https://files.pythonhosted.org/packages/19/98/8e2154e99b8e8818fad3e6c5dd7cf21c050f6314b1bd8072e8dc29f49eb5/httptools-0.9.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f67db0ba2bedafec15b8e5330d40da1e1c7921559fa715af021252bfef81a6f8", size = 568603, upload-time = "2026-10-09T19:56:35.876Z" }, + { url = "https://files.pythonhosted.org/packages/79/a3/86fe9fef3a1bfab5db62262f8880c294cbf8a8d94cffe2a2aa8b4aeed40c/httptools-0.9.0-cp315-cp315t-win32.whl", hash = "sha256:2095207b75a83c9e947346da9c127fb7e4fb29f41589df2643764f06b750989c", size = 94042, upload-time = "2026-10-09T19:56:37.441Z" }, + { url = "https://files.pythonhosted.org/packages/54/4d/f2d88782251467325a62ec4ad704249bb1b09c21aacb997181a9f4421f30/httptools-0.9.0-cp315-cp315t-win_amd64.whl", hash = "sha256:bca180cbe84e4fba7807eb408a8655295f697928512324517e30a091ede522a8", size = 100837, upload-time = "2026-10-09T19:56:38.831Z" }, + { url = "https://files.pythonhosted.org/packages/00/4b/5e96c4e0d171f959a0064971c3fced9cea5a19e5fab7a8e7d57aceb80506/httptools-0.9.0-cp315-cp315t-win_arm64.whl", hash = "sha256:4a4d8c2c7e73ba5967be74d7c3a5ff81fde815ee1b48d9c5c0f14de8463a847b", size = 95947, upload-time = "2026-10-09T19:56:40.562Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "identify" +version = "2.6.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/35/d70c0006c7cee65999ea94a6273e60b2094f600a3d8b71b04318253fc643/identify-2.6.20.tar.gz", hash = "sha256:ad729860a923858d26917c2f4fb0a1d83d27a75b1e090c06440c573f048f3285", size = 99681, upload-time = "2026-09-26T20:29:07.187Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/70/fffc9613501877c0a10a1ef73a165e6ded3e53f6e7502227fef56d973933/identify-2.6.20-py2.py3-none-any.whl", hash = "sha256:6a16b69b93187244e0548cbfd25b3e4a6f9a7a2ad784625c3bec2b8d27b81aaa", size = 99506, upload-time = "2026-09-26T20:29:06.054Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, +] + +[[package]] +name = "mail-parser" +version = "4.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/cc/20a5331698cc23ffe0e45955e12d57f1cc93c2ceb3873573757514f726b5/mail_parser-4.10.0.tar.gz", hash = "sha256:2099f2620462342effe87aea7c6062cb87ddf8bdd05f1f718d5315d4476a4b75", size = 3011269, upload-time = "2026-10-30T22:21:37.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/c4/21ff43fe0a950c4886830bbffe5071e512dc6e42693ed2a80e8d27c77227/mail_parser-4.10.0-py3-none-any.whl", hash = "sha256:8c6939e83d9b7d3fc153720fc49d876534de4a5d40bfee06730ef173052496f2", size = 70965, upload-time = "2026-10-30T22:21:36.341Z" }, +] + +[package.optional-dependencies] +outlook = [ + { name = "extract-msg" }, +] + +[[package]] +name = "mail-parser-api" +source = { editable = "." } +dependencies = [ + { name = "fastapi" }, + { name = "mail-parser", extra = ["outlook"] }, + { name = "uvicorn", extra = ["standard"] }, +] + +[package.dev-dependencies] +dev = [ + { name = "httpx" }, + { name = "pre-commit" }, + { name = "pyright" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "fastapi", specifier = ">=0.115.0" }, + { name = "mail-parser", extras = ["outlook"], specifier = ">=4.10.0" }, + { name = "uvicorn", extras = ["standard"], specifier = ">=0.30.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "httpx", specifier = ">=0.27.0" }, + { name = "pre-commit", specifier = ">=4.0" }, + { name = "pyright", specifier = ">=1.1" }, + { name = "pytest", specifier = ">=8.0" }, + { name = "pytest-cov", specifier = ">=6.0" }, + { name = "ruff", specifier = ">=0.17.0" }, +] + +[[package]] +name = "msoffcrypto-tool" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "olefile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/f3/4256235af3e868097dc270627159c672a8d00573833c91669526d025c810/msoffcrypto_tool-6.1.0.tar.gz", hash = "sha256:e2d7dfca6ff69cf3da0a7225329e6c26febb4360f329db4937d6ee527fdd2569", size = 41025, upload-time = "2026-11-03T18:19:38.15Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/9e/d6a7b1e343d8cea4ac63a1b672ca7eed491ef5fce1813308942d96fca8e1/msoffcrypto_tool-6.1.0-py3-none-any.whl", hash = "sha256:32ced1299858018e6c1ca3d0007127335dbcff90e777a77eb52f92d5112869f8", size = 49366, upload-time = "2026-11-03T18:19:39.431Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/99/d27cfc9518f49e4cbc25c683ec7cf8704a9d31311341c291c0e78ddf791b/nodeenv-1.12.0.tar.gz", hash = "sha256:4ea7f88339310afebc3253f2c7a91b94bacf97d73a36a5c108962abdfaca501e", size = 131292, upload-time = "2026-10-31T19:03:18.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/6a/8a9ac7d5e2f7cf53c459bfef90ebc17a2f8cd54b665af96799d4c534840e/nodeenv-1.12.0-py3-none-any.whl", hash = "sha256:80644d65c10cc2be12e3e4b54b3367ff288c7ad24ae75c2dcc65454fc7449d4d", size = 39442, upload-time = "2026-10-31T19:03:17.427Z" }, +] + +[[package]] +name = "olefile" +version = "0.47" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/1b/077b508e3e500e1629d366249c3ccb32f95e50258b231705c09e3c7a4366/olefile-0.47.zip", hash = "sha256:599383381a0bf3dfbd932ca0ca6515acd174ed48870cbf7fee123d698c192c1c", size = 112240, upload-time = "2023-12-01T16:22:53.025Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/d3/b64c356a907242d719fc668b71befd73324e47ab46c8ebbbede252c154b2/olefile-0.47-py2.py3-none-any.whl", hash = "sha256:543c7da2a7adadf21214938bb79c83ea12b473a4b6ee4ad4bf854e7715e13d1f", size = 114565, upload-time = "2023-12-01T16:22:51.518Z" }, +] + +[[package]] +name = "oletools" +version = "0.60.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorclass" }, + { name = "easygui" }, + { name = "msoffcrypto-tool", marker = "(platform_python_implementation != 'PyPy' and sys_platform == 'darwin') or (platform_python_implementation != 'PyPy' and sys_platform == 'win32') or (sys_platform != 'darwin' and sys_platform != 'win32')" }, + { name = "olefile" }, + { name = "pcodedmp" }, + { name = "pyparsing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2f/037f40e44706d542b94a2312ccc33ee2701ebfc9a83b46b55263d49ce55a/oletools-0.60.2.zip", hash = "sha256:ad452099f4695ffd8855113f453348200d195ee9fa341a09e197d66ee7e0b2c3", size = 3433750, upload-time = "2024-07-02T14:50:38.242Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/ff/05257b7183279b80ecec6333744de23f48f0faeeba46c93e6d13ce835515/oletools-0.60.2-py2.py3-none-any.whl", hash = "sha256:72ad8bd748fd0c4e7b5b4733af770d11543ebb2bf2697455f99f975fcd50cc96", size = 989449, upload-time = "2024-07-02T14:50:29.122Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.45.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/cf3a6b6448849656e1e5f4e2101f3988dc6789724050096aba1bc5ccf592/opentelemetry_api-1.45.2.tar.gz", hash = "sha256:d7b0008e21e5fd61cbe7a7f34ca3b6905a78ab677d9bc395e299359c75cda6b4", size = 73277, upload-time = "2026-10-29T17:29:37.888Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/2d/610db864d7513158cebb8f36cc88e67e73bd6c7aa1905ef18d89e1281c81/opentelemetry_api-1.45.2-py3-none-any.whl", hash = "sha256:2cbd737377e710ee740d261c94e93fa0f08e6d037c18f17513cc0a2d94479a34", size = 60335, upload-time = "2026-10-29T17:29:06.955Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pcodedmp" +version = "1.2.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "oletools" }, + { name = "win-unicode-console", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/20/6d461e29135f474408d0d7f95b2456a9ba245560768ee51b788af10f7429/pcodedmp-1.2.6.tar.gz", hash = "sha256:025f8c809a126f45a082ffa820893e6a8d990d9d7ddb68694b5a9f0a6dbcd955", size = 35549, upload-time = "2019-07-30T18:05:42.516Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/72/b380fb5c89d89c3afafac8cf02a71a45f4f4a4f35531ca949a34683962d1/pcodedmp-1.2.6-py2.py3-none-any.whl", hash = "sha256:4441f7c0ab4cbda27bd4668db3b14f36261d86e5059ce06c0828602cbe1c4278", size = 30939, upload-time = "2019-07-30T18:05:40.483Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.14.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/9a/8475be631fb33ca1466915e70fd594c42a4e84b512db650eaa14f90fe75d/platformdirs-4.14.5.tar.gz", hash = "sha256:32e9921db7385aa8169bee4fe9501923e5715ba9fb7ea3b9c69b0d8e0639f7a1", size = 71464, upload-time = "2026-11-04T16:54:50.358Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/ae/ecbbbfd0e4343a6a521d49b3c8656fb4643dee2a4f6eaf941cf3280391a8/platformdirs-4.14.5-py3-none-any.whl", hash = "sha256:8e778c6fa421516f4d3369449f8df3b0e1b72c0e0005fe88e3ec772d0a14e750", size = 35402, upload-time = "2026-11-04T16:54:48.875Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/c3/6965c2690ddce885ec75121572d065a5b94c5a5d8d3e657927ecda9fd715/pre_commit-4.7.0.tar.gz", hash = "sha256:1f3deee12b914c8fa184bd2b5953391c2e4f36763e403d4a23dc9983fa7c6e86", size = 198120, upload-time = "2026-10-12T20:45:40.32Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/83/ce0a196e4f7b20b11ce3aa1fc72fb973f64b7628d51c1b8aebad37fb7f81/pre_commit-4.7.0-py2.py3-none-any.whl", hash = "sha256:2e229038ad3656081b70c27913157e4b636ef306f643f024a8a8e3f0f7b2f877", size = 226261, upload-time = "2026-10-12T20:45:38.858Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + +[[package]] +name = "pydantic" +version = "2.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b4/fc/1203d011145c98ddce3cd2f505bb54375ef8d43223053df6bfcf3c746f46/pydantic-2.14.3.tar.gz", hash = "sha256:1054f237f4d4733e5a30e1e2333bd33a2004ab9ab1510bd053a9a31bb48e232d", size = 925636, upload-time = "2026-11-05T09:17:04.686Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/b8/b864503789ef5c58597d2a7b4adbee62c26440ab1e682581fc6838df8947/pydantic-2.14.3-py3-none-any.whl", hash = "sha256:3f7b347782ab7e4cf4c798496ae3a82787d9f21ec12676a9c564355eeef8daa8", size = 494071, upload-time = "2026-11-05T09:17:02.426Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.50.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/0f/34f9ce4ba701dd0b815033ef94d99b56f66200e578ee6052aa3ac26f064e/pydantic_core-2.50.4.tar.gz", hash = "sha256:aead3b74b68396bf0feab5d57e050b730ded7df55853c1e048a87e00aaf033c6", size = 522249, upload-time = "2026-11-05T09:15:26.774Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/21/39f8d97e7ea8e3083606ee9bb1d7f3ec70ded780bb6a872aad76c7eb08b2/pydantic_core-2.50.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:0f87ae9db5ba8d8de40dcb93982cf8dd544e6552a80d3345af51941cc2146b80", size = 2232841, upload-time = "2026-11-05T09:12:32.617Z" }, + { url = "https://files.pythonhosted.org/packages/90/a9/fc89a632331882c4cb91b949003418e6f5085ddcf2c9b875d499682bca91/pydantic_core-2.50.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1239daaf063e62213ca1f34d96663900bd7510c42a786e843fd328af70e46445", size = 2108326, upload-time = "2026-11-05T09:12:34.419Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6d/4f6d00e9e4ba2a7bfb206ae49cb32a3ea90c4d658e62f8775277d75e8291/pydantic_core-2.50.4-cp313-cp313-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:1afefe44ec042fbabfb4483ea258c04cf75ff4ff328d754f09b321fdaa232aca", size = 2256276, upload-time = "2026-11-05T09:12:36.212Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b8/936cb0d85a4082e902c7397db0f05c4372eac08372c8bd2d0b43088fcf17/pydantic_core-2.50.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a9ee990bf2cfbd81574c5d4f9f6c9d480a14b5b43d2c4f2ca13f4c6f48089394", size = 2125469, upload-time = "2026-11-05T09:12:37.913Z" }, + { url = "https://files.pythonhosted.org/packages/66/a1/f3b551ce233dcac73286b8b2ae45c23232a9f41c68663e2dcce4bb2dbcfa/pydantic_core-2.50.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:ab2822bcdcefb54d1e8ca29f5e3ec3afe160fb794bb3a3a73b09d11ed2671104", size = 2196397, upload-time = "2026-11-05T09:12:39.725Z" }, + { url = "https://files.pythonhosted.org/packages/3d/93/a8a6e7e20826567a73e6f52416667698aa3de704804d7a49d25272246af4/pydantic_core-2.50.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:0001d6920e3a5d92758cda460d6dc9f918a78ad6d5d092f1c8b5395e6b775356", size = 2380442, upload-time = "2026-11-05T09:12:41.196Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ba/921d90c9d8ddfa653a35a92f2bbdcd650a9493f5c43f39cdfe4c56659cfa/pydantic_core-2.50.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:ad92d255a165cde5f9882ff69699eaf5495e0a1f32e97566bbbb80f11e46781f", size = 2457747, upload-time = "2026-11-05T09:12:42.723Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/1c8f2c8f1b03d3fe2fdd7962df8f5a744fe48c90b4c49615e4eb77d04141/pydantic_core-2.50.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fb2bb5b557080da398b866408117d98fe9731a12334afd0cdff221b458cdc5dc", size = 2260946, upload-time = "2026-11-05T09:12:44.185Z" }, + { url = "https://files.pythonhosted.org/packages/07/ab/5b78a78f0c0f11c8b54fac214ed49cbb4795c34881aa5e5a15715917936f/pydantic_core-2.50.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:92f8f63df729061bb14558ed740e7a222f6e2aa6c2e6a5bcfb4e706676562049", size = 2261921, upload-time = "2026-11-05T09:12:45.706Z" }, + { url = "https://files.pythonhosted.org/packages/b3/e8/dd5d154cf3401f836d8754fdc1b82ecadd37944e4355d855e5b54c7d8ae5/pydantic_core-2.50.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:2a60ec2a57ac3ef3767e526e9bf706ec75aa3d79c4ea134d9d4fcf7c62a297a7", size = 2298475, upload-time = "2026-11-05T09:12:47.183Z" }, + { url = "https://files.pythonhosted.org/packages/b7/49/af059d9c4483cba168b17e5f84f1090a3e4547a02fc7698ebc231d48298a/pydantic_core-2.50.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:a2f8716344bbbd10443391be0b1f2003b34949e3c4e6883005c2bc498ab6b64b", size = 2473226, upload-time = "2026-11-05T09:12:48.785Z" }, + { url = "https://files.pythonhosted.org/packages/71/ba/4e8cc3064e8bc2ea272cf80dfc57fa4e455f6835c1def21609a9b4f94135/pydantic_core-2.50.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:b300a30304c4c6aeab03ed06809819d9eceacdd58441d3c7dffe41edfd006091", size = 2498764, upload-time = "2026-11-05T09:12:50.316Z" }, + { url = "https://files.pythonhosted.org/packages/bf/96/0878499cfa88eb0b07762b488d3cc1b64cb156a4905db99a0d12096b2e17/pydantic_core-2.50.4-cp313-cp313-win32.whl", hash = "sha256:ef8a9ddb2e2a4eae4abb72dc0710eca6c2726779b0664bd10c3ce9fcfaed8c4e", size = 2119158, upload-time = "2026-11-05T09:12:51.834Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e0/95b651213e79ffe0cbee855590bf5cfdf8e3a0d90a7fc73a080e63f7cc38/pydantic_core-2.50.4-cp313-cp313-win_amd64.whl", hash = "sha256:4c29b8f2d6417069bb1f257e6b9113f5d64dc2f554cc200ea90b4fe2c5cdb733", size = 2262887, upload-time = "2026-11-05T09:12:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/08/d3/c3801dc75844a0b13d000bd575bf1b3b3a8aca9f63d19e1809f69c9c5121/pydantic_core-2.50.4-cp313-cp313-win_arm64.whl", hash = "sha256:a0c5210d038418a115e7cf8706bfa611bd14add2f5787274dba45aadca3155e0", size = 2167878, upload-time = "2026-11-05T09:12:54.677Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ed/c9a4982ac3bbc78f27498d9efb85b3dabd739a1724db53c35cc4c018e1de/pydantic_core-2.50.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:5c074454dc6d4f6f4ba6561a56bf33a14db7651d882a5a5321ba3ae8868e082d", size = 2236841, upload-time = "2026-11-05T09:12:56.111Z" }, + { url = "https://files.pythonhosted.org/packages/56/32/92c174c17bfc5fc52d0c064e6a7969a727731e25829ede752fba8bacce0f/pydantic_core-2.50.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a4bb174bd65f795c39ad6642d9d5bdc43351b306b7d0a654ab0d0abb38be245f", size = 2108348, upload-time = "2026-11-05T09:12:57.638Z" }, + { url = "https://files.pythonhosted.org/packages/cb/cb/9f637d424a04d3edce7dd527da941950cce05a74b025eef3d54427b86c8e/pydantic_core-2.50.4-cp314-cp314-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:0ec20aca2b067369913716847f7dfe5f4dddf16a46965b7a70bbad5defaaba86", size = 2261331, upload-time = "2026-11-05T09:12:59.154Z" }, + { url = "https://files.pythonhosted.org/packages/91/ff/1117a3cccabb67305bd98d992a84eaf275939a9a043b4f14126ed7252e4f/pydantic_core-2.50.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:70dbc9f83c41f37a4faa62dae5203853847223a891da446f48ef2efcfd5df806", size = 2128667, upload-time = "2026-11-05T09:13:00.614Z" }, + { url = "https://files.pythonhosted.org/packages/93/45/6de1b4a6e8c415cd547f90d1408a711e7975116423e3eb3046061c62d7c7/pydantic_core-2.50.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:3de6c2a4df2af0ac9ab4dc1488746fe8b1a90e27955d870d9edda3187d20092b", size = 2198183, upload-time = "2026-11-05T09:13:02.259Z" }, + { url = "https://files.pythonhosted.org/packages/d0/bd/c6e64c315d35cc0783a0ea033a3dca062bc368905d0217eab6f6f63007de/pydantic_core-2.50.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3a48a5254d15a0ad050318bfc7a9566d4ec740118187e8f303e47a6840287eb7", size = 2386279, upload-time = "2026-11-05T09:13:03.988Z" }, + { url = "https://files.pythonhosted.org/packages/33/ab/0d56280c89d3841381e9c699c3fa80e3dd3288edf5e7fe4d149136835dca/pydantic_core-2.50.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:0af56dbf8822ba9f4efcbbfdc15478f8b6fb08f1609860cb50aa2cc8476b3c34", size = 2464343, upload-time = "2026-11-05T09:13:05.98Z" }, + { url = "https://files.pythonhosted.org/packages/56/9c/621ad8f88590a92a086b1168dce09369d9c5e079e2e635e6646d248af55b/pydantic_core-2.50.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f1d62fb172db35c6478c9323da34ff37d1f3d37d7d44337a9d94ba8c583e5730", size = 2265388, upload-time = "2026-11-05T09:13:07.808Z" }, + { url = "https://files.pythonhosted.org/packages/f3/7b/cef68a667bf29b86e293a80a601d488a84c8f45508915ad6201fcfe1a798/pydantic_core-2.50.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:5c1013647be741647895c102831dcf79c34209662dbb683df9efb864417ed7d5", size = 2267012, upload-time = "2026-11-05T09:13:09.273Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9f/3ae4d163d8feda2b52de88b5cd96b1c40f79d11503003b061136d2ece6ab/pydantic_core-2.50.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:aeb2e123cbf978a905e9f55155c1b8316fbbfa7cf64d04521fe174bab302d100", size = 2300478, upload-time = "2026-11-05T09:13:10.758Z" }, + { url = "https://files.pythonhosted.org/packages/e8/72/41881d31f6452430ed6792679c5391795910f0a27a6aebd424683e504ed6/pydantic_core-2.50.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:523466eba8ee10f7480f3c2057563145978011c583130d2cc01fb1e7af808e25", size = 2474874, upload-time = "2026-11-05T09:13:12.188Z" }, + { url = "https://files.pythonhosted.org/packages/05/ef/099874dd6d5ca1e49987dea87eecc05610183249450b1fff883d87f1e8eb/pydantic_core-2.50.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:c9e70012926e97069cdd09221861aff412aa94e4cac2e019055cdb79485b150c", size = 2502771, upload-time = "2026-11-05T09:13:13.981Z" }, + { url = "https://files.pythonhosted.org/packages/c6/07/a7d8615b8677bf69e24666bbce431299850c95a7b084649342582a1c3210/pydantic_core-2.50.4-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:e6da138a1ecc1341c8b788a5ee822670b03788e1f5decf7af9d461de6e508b8e", size = 1496509, upload-time = "2026-11-05T09:13:15.704Z" }, + { url = "https://files.pythonhosted.org/packages/ab/71/fdf2c25c3a4f89968263c1d896c933809ca8d2fb13443626648a17b2e296/pydantic_core-2.50.4-cp314-cp314-win32.whl", hash = "sha256:13b6dd62b5279f5b9d72f3bf918a35443ee8bd549241d9dc52d79a2c3b6d7016", size = 2122015, upload-time = "2026-11-05T09:13:17.09Z" }, + { url = "https://files.pythonhosted.org/packages/3a/9f/3554f0148b01ddaa5e678bf5fbce4679873534e5c0985cdf6c59c41dc9a9/pydantic_core-2.50.4-cp314-cp314-win_amd64.whl", hash = "sha256:b0cdb655fbd1562c2dfc9986f9103a106f7058cd0915afc6e656d4b1d73f3387", size = 2265109, upload-time = "2026-11-05T09:13:18.702Z" }, + { url = "https://files.pythonhosted.org/packages/ed/3c/196ef237d9ec5cca5ea9b773911dee1a387b9b1d4bfea05625b3e191a338/pydantic_core-2.50.4-cp314-cp314-win_arm64.whl", hash = "sha256:df1c174796cd63eb6b139f7daf783affe1f3ed659605850e843b24764c21bfc5", size = 2165745, upload-time = "2026-11-05T09:13:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/36/12/0ee82a41a3995f0b531cf14e0b823dc2365ba4a22330670fccaa72753f12/pydantic_core-2.50.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:edbca8789fd10f0de534b660a6b4c71f1fd18039679c918dad392ab044bb37e4", size = 2223917, upload-time = "2026-11-05T09:13:21.623Z" }, + { url = "https://files.pythonhosted.org/packages/90/2c/592f8404abbcc65a70e6a802d1dc8f11412af44913e5146cf5c345370074/pydantic_core-2.50.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:33b21f69540a12c2053cd1d95766d8bd9667a3897f7c712a642de8aa37eb0865", size = 2087372, upload-time = "2026-11-05T09:13:23.16Z" }, + { url = "https://files.pythonhosted.org/packages/ea/1d/c7111757c84b5b8c19b1e39ceb5e131e6e48e14169ec6004e0f8f28f43f3/pydantic_core-2.50.4-cp314-cp314t-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:ffb616d8d55965839670301dc3bae3abacff560a7e137a89056058a8a9da4d96", size = 2275190, upload-time = "2026-11-05T09:13:24.634Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ae/6c49cc9b8e66e61adee782d1763894bf64a357cddae82f725059b85bdc98/pydantic_core-2.50.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6c5687b59b6ba0f663c4f2f15470f68507d6b45ccd3a19ee6d224f95cbee70d8", size = 2110343, upload-time = "2026-11-05T09:13:26.168Z" }, + { url = "https://files.pythonhosted.org/packages/ed/39/0ee5261d1daa9ad526371181c13696add0565251b2823f6e00a9a9af397d/pydantic_core-2.50.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:c733087ecf7dde06b1d071679bfd5f3ba03266ba77814c1c7253bc48c9adedd9", size = 2207887, upload-time = "2026-11-05T09:13:27.681Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b5/a0652c0e99590107e111088b6d059044380a787da9ffdd0b458ab4cd9453/pydantic_core-2.50.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:94733cb447c37b0ce6f71b39ca1288d5f966a084023a5617b4cc35a852586859", size = 2404171, upload-time = "2026-11-05T09:13:29.864Z" }, + { url = "https://files.pythonhosted.org/packages/a3/85/d49f0b8e09a0ffc40dcefb604f9e6020e0d61b51a5f64a504f382fa84c39/pydantic_core-2.50.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b26f39a5be3cd91a2035818be3d0ffdf5282c3e1f5f53d3b80b7024021acee52", size = 2466049, upload-time = "2026-11-05T09:13:31.658Z" }, + { url = "https://files.pythonhosted.org/packages/e6/76/f2b04d7c53edfd8136053c812ea49914fbf4091196cb7baf9ea326fa2ff8/pydantic_core-2.50.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c856e439a9d54d514e81a7131229ba151cdf81df7c408e0f6c89340e5003dfe2", size = 2262062, upload-time = "2026-11-05T09:13:33.806Z" }, + { url = "https://files.pythonhosted.org/packages/24/60/016f14cea883adc33df90b8df220df934de49ded9640f45c8e92bb298494/pydantic_core-2.50.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:cbf0777d54672990b10cb8ca9b0523499e182d7e2ea39f86b138519a902aa601", size = 2263713, upload-time = "2026-11-05T09:13:35.337Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3f/b05828e978512973e7e215bab69e65e70d223d6309a17bf48084a50692f4/pydantic_core-2.50.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:edc17549ab592e33cfcaf285f047bb75fcd98f608aa9309af1187fd736ce9641", size = 2305044, upload-time = "2026-11-05T09:13:37.043Z" }, + { url = "https://files.pythonhosted.org/packages/91/c1/fca6c5f623ac45ba284713c614b30173aa0794899a0a457f866fa6f5e886/pydantic_core-2.50.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:23a9ba564b2db709ff16eca990992ba95a19069972b34bff87c81d4b473cd755", size = 2483506, upload-time = "2026-11-05T09:13:40.524Z" }, + { url = "https://files.pythonhosted.org/packages/94/c2/ec41f68d1208e53e1a73ead940c050c4316bbb555ba42676a5e949fd529e/pydantic_core-2.50.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:41f4f8ae714e4fea1d635880f8a1af715ecf080eed4d13c5b04a0f3210f9c61a", size = 2512832, upload-time = "2026-11-05T09:13:43.361Z" }, + { url = "https://files.pythonhosted.org/packages/43/22/58583b86309f70cce854e0e77c412839a56ac6c682d6060f5794afeff315/pydantic_core-2.50.4-cp314-cp314t-win32.whl", hash = "sha256:601fce6cea9ddeaa85329e12e7f351def38d233075f42a3012b9c48071b02941", size = 2101977, upload-time = "2026-11-05T09:13:45.735Z" }, + { url = "https://files.pythonhosted.org/packages/6b/28/193bc0994f7fe15f2874c1dfe2f3bc7872aed8283ffda2cf05fb9a5a06b4/pydantic_core-2.50.4-cp314-cp314t-win_amd64.whl", hash = "sha256:22e874666bdbd96d6bf629d32cd8ab376fedf1fd62585b52a42b9fa9fa6c20b6", size = 2240461, upload-time = "2026-11-05T09:13:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/00/ed/5615cfdd5620a4926440eb1a2b73db0dc895824ba565ccaa8d9eb3a8e974/pydantic_core-2.50.4-cp314-cp314t-win_arm64.whl", hash = "sha256:71395a43da5584bb70556f380387e15f845c0dcf76373c1afbfa0025737576ac", size = 2168505, upload-time = "2026-11-05T09:13:50.762Z" }, + { url = "https://files.pythonhosted.org/packages/6d/9f/e6673535165d965a11c1d5339f53995f90234019827eaecb41a57e6e463d/pydantic_core-2.50.4-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:7ac2769a7ddd661e07e26c12220adc31b17014c48234b2a5a88993b8d4109e09", size = 2241950, upload-time = "2026-11-05T09:13:53.055Z" }, + { url = "https://files.pythonhosted.org/packages/6f/02/65951efadbf7826e6a270843f97e3da2ef726de2b6d9cd7c5dfa4c48807e/pydantic_core-2.50.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:930ad463d3fb7a340d323bcc496ec32dae469ec9974c29ff569f19806b6b03b4", size = 2112412, upload-time = "2026-11-05T09:13:55.309Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d3/4fb6e2e4a9e4951f1e05b198366ed5330e0874e83d52077e8b985350fe0e/pydantic_core-2.50.4-cp315-cp315-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:b867f9fd183d76977f810c626d539265183c25b2284762893a31e8d6cacc81c0", size = 2263220, upload-time = "2026-11-05T09:13:57.555Z" }, + { url = "https://files.pythonhosted.org/packages/63/83/42e70436c523357b49393b73f161f2741acf36003c8efd2f941d2be56bae/pydantic_core-2.50.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49eb1241a969a5994db6880c18c012b6cbe2340343d8f529721571806583e500", size = 2134716, upload-time = "2026-11-05T09:13:59.413Z" }, + { url = "https://files.pythonhosted.org/packages/36/66/ed9b87f4751fd07e472c62cfe151f575abdf4c452fab943d35ba8efdc6c4/pydantic_core-2.50.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:477af785d1846e4e96bf56983b92ea7553aaeccdeb8acdaa55c7cee9eda0ae32", size = 2201901, upload-time = "2026-11-05T09:14:01.472Z" }, + { url = "https://files.pythonhosted.org/packages/2b/21/ff2e6ac7202b6d326e9f007c6082f6e6f3aaa063790ea2a355bdc985addc/pydantic_core-2.50.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:29358a8ca74e7d81158d14e2b10c904bd18773293ae3788716c0626fe0342347", size = 2389670, upload-time = "2026-11-05T09:14:03.431Z" }, + { url = "https://files.pythonhosted.org/packages/b9/34/e9348bc13d549641791a51843ed140fbb311d9066628e27477343412d5ad/pydantic_core-2.50.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:300753f71c73302e218124baf995f00058e085cd01869bd9610bcbd0bd4500c1", size = 2468951, upload-time = "2026-11-05T09:14:05.028Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5e/145a02bf2b9f66981108caf6cc9e78917e31e4caca14d1e3ccd3ff2c7293/pydantic_core-2.50.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:26cb012c4b8ca9f847bd0ac15978bd3d0f55b050bfbe6c47355edfc7e945029b", size = 2272957, upload-time = "2026-11-05T09:14:06.587Z" }, + { url = "https://files.pythonhosted.org/packages/fd/38/b71c5b245e923f6cf144e948ed2a9d6b7fb97d8905784db8d860f5176b8b/pydantic_core-2.50.4-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:9be1cfe715ecaa060ffd5d599ef410b94ef2697a0eed4cee562f788a2aa2175b", size = 2275028, upload-time = "2026-11-05T09:14:08.219Z" }, + { url = "https://files.pythonhosted.org/packages/ba/71/2504dacdc5cd3ea3ec5e68c9b6e097c979500bcff220b97046cc8ea3c1ad/pydantic_core-2.50.4-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:c81e35862aced259177a537ce1a6264c3a97bae1ced184ca9dc10ea754563688", size = 2305447, upload-time = "2026-11-05T09:14:09.795Z" }, + { url = "https://files.pythonhosted.org/packages/2c/90/904233a6c148bcac9f30bb96a2761e5fb52682d0d6de31a40c74a3714ceb/pydantic_core-2.50.4-cp315-cp315-musllinux_1_1_armv7l.whl", hash = "sha256:b2f2d13239487cecaae98c9f4d5904ad0737643cdf8873c88ec6a78b12214f20", size = 2477852, upload-time = "2026-11-05T09:14:11.443Z" }, + { url = "https://files.pythonhosted.org/packages/72/33/1cbdcbf343ca23b507e967b21dddc4c8bf17a74c8b5cad59228c85ba4efc/pydantic_core-2.50.4-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:e6b4b08d09054310a4dc389fa61ee22a7a5a292cb23ab8a985136ca8828bf924", size = 2506352, upload-time = "2026-11-05T09:14:13.165Z" }, + { url = "https://files.pythonhosted.org/packages/91/24/3ad9ea0876e6624c90967e5f1446e751b275cfdfaaf798a0d8e0b30025bc/pydantic_core-2.50.4-cp315-cp315-win32.whl", hash = "sha256:6619d49a89a15cd04334f76fec530c155923bfc60da74ff5d815a52629e1aa6c", size = 2127780, upload-time = "2026-11-05T09:14:17.52Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3c/0582532b90a12492471977bdbca1317eca5144f6342ea581d2cee73ccd35/pydantic_core-2.50.4-cp315-cp315-win_amd64.whl", hash = "sha256:e5bd109d095aaae989a0463d5ef0fcc43e9ddd5de125e656d3c119a79e466380", size = 2270596, upload-time = "2026-11-05T09:14:20.955Z" }, + { url = "https://files.pythonhosted.org/packages/6c/50/967cfe4f7043a993c0c80cd3563c598b5281d2276aa775d0f6ff7f714271/pydantic_core-2.50.4-cp315-cp315-win_arm64.whl", hash = "sha256:6118e5a5550e36582e19bac1a403711a748f9f18251b054c326d3db02aaa7a18", size = 2170880, upload-time = "2026-11-05T09:14:24.822Z" }, + { url = "https://files.pythonhosted.org/packages/9e/71/3ec5bd8a82f792482f16d79fdbe8ce85aa71bf7147e556c5fc5f8546818d/pydantic_core-2.50.4-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:d8201c9f9035520cdcc7dcad383b039ec8123969b87e01cf27c3dd883c02313b", size = 2233053, upload-time = "2026-11-05T09:14:27.942Z" }, + { url = "https://files.pythonhosted.org/packages/6e/2e/614dc37aedf8e9f811c1f2eedaf8eb09a7c196e2d137fe82bcc9d5662ca2/pydantic_core-2.50.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:1de7be9a66fc8536770481ab64a05aae5067c725f2b29a09543af00e6a417b97", size = 2090776, upload-time = "2026-11-05T09:14:30.281Z" }, + { url = "https://files.pythonhosted.org/packages/f9/14/aefc14e3e05013070ee959fc0b8703f6860a2776ed6e75b9c748f61aced0/pydantic_core-2.50.4-cp315-cp315t-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:789a6453e5ffd18a7ab6b8c3a0dd8403053829197ec258ecb90c604c21ffcc99", size = 2272481, upload-time = "2026-11-05T09:14:32.578Z" }, + { url = "https://files.pythonhosted.org/packages/13/c9/d56999aa7236dc9303091db2b1ef7303f0b022baf25ebf33cd200c0cb933/pydantic_core-2.50.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6348ad12fa741bcc9c2f173e99fbf27cbc038826d8c31a4a7d836eca27878ba2", size = 2113069, upload-time = "2026-11-05T09:14:34.69Z" }, + { url = "https://files.pythonhosted.org/packages/b7/d5/a62da9e72f272f198f6118c5457332bbd4b9fdc4b77858448120569756de/pydantic_core-2.50.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:d49127f137f871cde3c5650af33bbbdcee02679dae76e020902fa106f522b8ae", size = 2202754, upload-time = "2026-11-05T09:14:36.49Z" }, + { url = "https://files.pythonhosted.org/packages/37/4a/e7f21577f96e42ac3082cd014df398c1c913d482afac1c8ef17b9e039198/pydantic_core-2.50.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:2f5cc5bcb94063fbbdfd285a2b302da34af07491337c10bb35de1d5220fa1583", size = 2411472, upload-time = "2026-11-05T09:14:38.63Z" }, + { url = "https://files.pythonhosted.org/packages/38/ad/c57c5e13bbfd3404ec1af519764aadbc52ee01e39f9f9ae9d28317f982f2/pydantic_core-2.50.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b99bed995ed7c41515c11fe2beb86f8a6cc298e5537cae2f736de2f982f74ef0", size = 2475330, upload-time = "2026-11-05T09:14:40.519Z" }, + { url = "https://files.pythonhosted.org/packages/6e/63/65cf0e1f1fd8cfaafee3c005712b8020e063b0f3e3571493ea68db5ec44f/pydantic_core-2.50.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:faa4e96385c820ce9d7f7a623486e23d4134ae3c9ba2071e44e0ab5a5a5002c4", size = 2265718, upload-time = "2026-11-05T09:14:42.379Z" }, + { url = "https://files.pythonhosted.org/packages/72/5d/fd9fdec9b25e2ef1f788970a84f749f0e28f166573c87654fd5387d8e5ce/pydantic_core-2.50.4-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:d6a166978f22f10cb91413f70519861605219346decf65bc79008f9257c94afe", size = 2273454, upload-time = "2026-11-05T09:14:44.286Z" }, + { url = "https://files.pythonhosted.org/packages/34/8c/19705c6d5eb72ff8c25006df8a375da7466176a5968781789e5415384f65/pydantic_core-2.50.4-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:a70d5effebd81ebd8e15a8aabdc7980832367b2b00c36543bac378977004cc80", size = 2314862, upload-time = "2026-11-05T09:14:45.97Z" }, + { url = "https://files.pythonhosted.org/packages/b8/fb/acefa27031aba2646b0d3026c4a1602e526489d39395ab17bc47f03234e3/pydantic_core-2.50.4-cp315-cp315t-musllinux_1_1_armv7l.whl", hash = "sha256:f8fd23653a252cefabea11cd041efd7b80bdf403e43a36dea53f9cb0aaa21f0f", size = 2479073, upload-time = "2026-11-05T09:14:47.526Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e1/db08fa1e5edf1779fa0612f8d09f9030bdc513f593687c883cb781b86caa/pydantic_core-2.50.4-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:7646353a5a7c553c04167aca628e2550b538f492765b03ccf34321a560acc43c", size = 2521328, upload-time = "2026-11-05T09:14:49.042Z" }, + { url = "https://files.pythonhosted.org/packages/0d/51/bf1ec5b96c076d8d514b08f3bcffb3397df7a0fcc729eb960838a8bbe27f/pydantic_core-2.50.4-cp315-cp315t-win32.whl", hash = "sha256:65376dbe1ab4dbc768ca2b72b7c13993562c035f5925fd3bc7ff9c8c585c515d", size = 2107629, upload-time = "2026-11-05T09:14:50.891Z" }, + { url = "https://files.pythonhosted.org/packages/18/32/43d5db1824ec2314f737ff8d9962ff59954a74616d8656a8cc78790e45f1/pydantic_core-2.50.4-cp315-cp315t-win_amd64.whl", hash = "sha256:f08ee8248aad2d054e5bc4c73554d4505464698f6d754f16198dbc5764e9821d", size = 2244906, upload-time = "2026-11-05T09:14:53.056Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c0/38c505004969c4641c3a077a8e72e354f02d5c06d8f51d7a103699704772/pydantic_core-2.50.4-cp315-cp315t-win_arm64.whl", hash = "sha256:da779ae50b46f3f7d1e1b5f362fdc0ad376a49fd55f6f3122dc2b6149936cdf7", size = 2179018, upload-time = "2026-11-05T09:14:54.448Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3a/d405a50e02ea81cd95e93fc97f43d351eeaa1707c28aa6fb58a9f1c1efa9/pydantic_core-2.50.4-graalpy313-graalpy253_313_native-macosx_11_0_arm64.whl", hash = "sha256:71e03d2ea1a221d020cfc5b6cc8bbbedef23a06704c70fcf4d0afb42965b22d1", size = 2049324, upload-time = "2026-11-05T09:15:02.379Z" }, + { url = "https://files.pythonhosted.org/packages/8f/3b/03e7992115e17cae4131ecd71aadb8fd5e4a04cc2aead72c3c27e9b453d1/pydantic_core-2.50.4-graalpy313-graalpy253_313_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09450778e3ab58d3f565899fcfbf6c82926e31af29e28e799d1d50941316e0cb", size = 2119802, upload-time = "2026-11-05T09:15:03.901Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d5/b76fc647e473377ca6e693c21549ee3a4a7677e4962c28ae4659337c5114/pydantic_core-2.50.4-graalpy313-graalpy253_313_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4eb15be588407148ef5937dc8d9256a71f6b115e6cddadb7aa20b6ee384680dc", size = 2280639, upload-time = "2026-11-05T09:15:05.374Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/11/b213bebff182584360cb8d17c72c1677fec5c5c228de439e63bcf8ab1c8f/pyparsing-3.3.3.tar.gz", hash = "sha256:928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36", size = 1050487, upload-time = "2026-09-20T20:59:05.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/bb/d215ee7c73b61497b28a5503f9f53523f294fcc936762b7caf90e0c1c2b5/pyparsing-3.3.3-py3-none-any.whl", hash = "sha256:ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4", size = 126420, upload-time = "2026-09-20T20:59:04.025Z" }, +] + +[[package]] +name = "pyright" +version = "1.1.414" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nodeenv" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/1b/244c7b710031ada80f27e579ec20d28a2285dfc318fed0339866b1047f12/pyright-1.1.414.tar.gz", hash = "sha256:523c0a97c60da6333234955c277730c9cf4f5bd6d5399e7b7d2b0fc5d3599524", size = 4154638, upload-time = "2026-09-10T12:26:53.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/ba/18b6e682ead424ad24bcc134339ae5d1b931cd9ae260540592a058a91279/pyright-1.1.414-py3-none-any.whl", hash = "sha256:2a6b4b3298c9eec174c5ed83bd338de6eee82df2992f3e1930e6199d381be36f", size = 6225049, upload-time = "2026-09-10T12:26:51.427Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage" }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, +] + +[[package]] +name = "python-discovery" +version = "1.9.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/55/70b46fae646bc6f5cb5e82569949d925cff1c7b5ce20ec4a11e0d977f8c6/python_discovery-1.9.5.tar.gz", hash = "sha256:86279f5d2728bc067de28b7ddc571be2eacc2ae0e7048f8629d2481a0f8848a2", size = 141121, upload-time = "2026-11-06T15:32:11.331Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/35/25bd092ca8a7e71192afdca67fbff4f797da74408e74ac3626e13b409ec0/python_discovery-1.9.5-py3-none-any.whl", hash = "sha256:a1fae8fca11e4bc61e38491c2aafff29e430b3c5e272d51ae52fb895bc4c0fac", size = 44377, upload-time = "2026-11-06T15:32:09.821Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "red-black-tree-mod" +version = "1.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/48/75/bfa342a2ebfc9623b701f1c6995b9906fd6dd2cedf6bce777d09e23303ac/red-black-tree-mod-1.22.tar.gz", hash = "sha256:38e3652903a2bf96379c27c2082ca0b7b905158662dd7ef0c97f4fd93a9aa908", size = 34173, upload-time = "2023-12-26T14:00:22.056Z" } + +[[package]] +name = "rtfde" +version = "0.1.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, + { name = "oletools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/5c/116a016b38af589e8141160bc9b034b73dde2e50c22a921751f4d982a7ca/rtfde-0.1.2.2.tar.gz", hash = "sha256:2f0cd6ecd644071e39452e6fc4f4a1435453af0ec7c90ea86fb4fc96010c7f1b", size = 33408, upload-time = "2025-12-09T17:10:31.805Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/24/5a653278259be44c1845ddd56dd30cfa7265281ba149b9342b79f9d4f788/rtfde-0.1.2.2-py3-none-any.whl", hash = "sha256:d43868c74f21ae9ea5acbfd4176d5de1f2cfae0ff7f267698471c606287c04ec", size = 36713, upload-time = "2025-12-09T17:10:30.893Z" }, +] + +[[package]] +name = "ruff" +version = "0.17.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/0e/3d154514b5bad104f7e1c13169c2d09aa9959fccdc06eb47610ccdfa83ed/ruff-0.17.4.tar.gz", hash = "sha256:f32d178b50e826e00f6c6c1be3f56333068acb9b67fe167143527fa9b81e890d", size = 5357750, upload-time = "2026-11-05T18:52:17.638Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/61/c83c78bbb6108f6c6270a106cf12b54175f4f42da088b9bb880f18e31289/ruff-0.17.4-py3-none-linux_armv6l.whl", hash = "sha256:2b08c4ff98dc234f4a3871a3105353b922fa875ea1073ca31001eb8c06bb4d89", size = 10252195, upload-time = "2026-11-05T18:51:36.594Z" }, + { url = "https://files.pythonhosted.org/packages/0a/12/dd158708378866e8b53e145a465dbc51a7cccb9fa197a74d67eaedde7234/ruff-0.17.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:13e781c3c5f663e7fba737eaaeb70dd943dd55171daf316afb25cd5268cfe0c7", size = 10266044, upload-time = "2026-11-05T18:51:39.502Z" }, + { url = "https://files.pythonhosted.org/packages/28/32/89a94a8eb11fd505a381ae6f04e190d038d9958695209dc1786ce5cfcda3/ruff-0.17.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ed2f416349944f908f9574215994602242b0836844eba48eec61473033afca0", size = 9432227, upload-time = "2026-11-05T18:51:41.968Z" }, + { url = "https://files.pythonhosted.org/packages/58/de/a392dc38b215798ae72e639d228b7f6c02d826a95d1c0ad7c4c0ee49ef5b/ruff-0.17.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ea6e0017c785f7282092b11e46338e4ebed1b9e575ebf2e55a8a1eda968241a", size = 10136900, upload-time = "2026-11-05T18:51:44.562Z" }, + { url = "https://files.pythonhosted.org/packages/b7/8f/a880f60f42005f6ffdf58f77af34c7ee327000b5607f48a2f6a69d8b242c/ruff-0.17.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7e061dcc0933c7031a616ac8d66ac540309b2aa21ab558101a8f53e9ac7a1185", size = 10051245, upload-time = "2026-11-05T18:51:46.7Z" }, + { url = "https://files.pythonhosted.org/packages/09/55/98844264108af7d5ec27ca3a9cd5a989094ca657a14599c4b69a537a0e9a/ruff-0.17.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f99e95a1515161138be3cbd1b06c06e739d8feb38ade35564556999fffc3686e", size = 10704341, upload-time = "2026-11-05T18:51:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/28/a2/5edf97659c3ac7c73f978003bd314936f671037fdac6b978e9de3e4b2b65/ruff-0.17.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f28cf0dd37cb172fa5a8d2e92e6ada3a9dbd0609f094ed24039929eef0b7524", size = 11394465, upload-time = "2026-11-05T18:51:51.534Z" }, + { url = "https://files.pythonhosted.org/packages/f2/8f/51371ae856b2bef4d15a044a574695fbc0f6ae63aafa42a2a22428070fb6/ruff-0.17.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b21c771b296888e8a35c6f48555f4b44e4483f61675d6ed51810a5203469ce6", size = 10988262, upload-time = "2026-11-05T18:51:53.91Z" }, + { url = "https://files.pythonhosted.org/packages/af/1b/62874f14c7873f27c7887d2b1ea41de990e14ba9518801ffe8eacb5d51a6/ruff-0.17.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2cd025509b2e15721b426fc70fd946d71f43b3db3b08e946dfec2d696d911690", size = 10572829, upload-time = "2026-11-05T18:51:56.129Z" }, + { url = "https://files.pythonhosted.org/packages/98/30/860b9dae67432b16b88558a9cb2d3194825fa62838f8b9cc49f5d9022095/ruff-0.17.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:49b77f7b3921669466882a4881168801bdb06ec2cd83fb936049016cf5fdece1", size = 10617545, upload-time = "2026-11-05T18:51:58.172Z" }, + { url = "https://files.pythonhosted.org/packages/0f/08/781a4b41a1c83fd6e30fea610d6502a6f94e49cf94693fd37bdcbc6bfe11/ruff-0.17.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e3b84eb74f260d1c2dbd236fd9d4c011d4fdd0a52bdf8aea57a10e3a1b71fca5", size = 10111955, upload-time = "2026-11-05T18:52:00.59Z" }, + { url = "https://files.pythonhosted.org/packages/3c/e9/94b1c7b677120f30839254518924f73a8157e9bcfa200edcd5796fecdb99/ruff-0.17.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:20e43d7a08e712e33067ba887e6574546c79bd4831596ce8f16803ac7ff9ad90", size = 10058355, upload-time = "2026-11-05T18:52:03.61Z" }, + { url = "https://files.pythonhosted.org/packages/27/5f/a825910b9f309336dc33cb8c0774126662c1d2f765699b3e0a1bd538d01f/ruff-0.17.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0d1f4848fd2ec0499be4046db9b7dfcc952666885f00233cc7033515282556a8", size = 10415932, upload-time = "2026-11-05T18:52:06.264Z" }, + { url = "https://files.pythonhosted.org/packages/8b/b8/0796468423413ea4df1a6e2442ae26cf49b8f7dda0eecf246e0d5d0dde54/ruff-0.17.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6007e7f3a0e55b0fbdb947af69cf24c21b4928df6be8ef3e767c69b5ccccf496", size = 10826033, upload-time = "2026-11-05T18:52:08.675Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ab/d8e407669ffe5014429baf780c2df47e001968a6e4c17f615e2e7b13a9ba/ruff-0.17.4-py3-none-win32.whl", hash = "sha256:3971a78cba76298b284c8321e6d40d93045ed348bec5c369d85099efc97fb7cf", size = 9931993, upload-time = "2026-11-05T18:52:11.169Z" }, + { url = "https://files.pythonhosted.org/packages/bd/15/42af8a72d8946e3c9efd2bbf6641e462b6832783b0d043d63ef5b280ba7f/ruff-0.17.4-py3-none-win_amd64.whl", hash = "sha256:67c5a894fc054cf41f75f7afa24815de5a74329d97634126c2a1015740ff4e8c", size = 10292922, upload-time = "2026-11-05T18:52:13.436Z" }, + { url = "https://files.pythonhosted.org/packages/68/9e/f1dbffcfb8ff25dadbc21f87a8b73c3848abe4abada9d4b08ccef8bec40c/ruff-0.17.4-py3-none-win_arm64.whl", hash = "sha256:181ae38a9a8fb94925bf7d0794327b48d7fd7f4b50cfd84c0e999cc09ef8d131", size = 9889396, upload-time = "2026-11-05T18:52:15.549Z" }, +] + +[[package]] +name = "soupsieve" +version = "4.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/7c/a64eedae0b7776cb9602d2da9cb8f8caae8e1b4c1da5e8e87bf1e68121ec/soupsieve-4.0.1.tar.gz", hash = "sha256:7621e3c5f6b371ed2c5eabaac5de300ac3d66d05e6d7f34783e31b63c4f90c75", size = 153302, upload-time = "2026-11-04T16:36:27.749Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/5c/4f68370847b561a389dd9a2d7eb3d19fd8cbb8acbae543a0c6b8d0d9700b/soupsieve-4.0.1-py3-none-any.whl", hash = "sha256:2e68cf7dd5a0f29d81f9d485275ccf294e6475f615e211895d91cb81f8614f04", size = 50688, upload-time = "2026-11-04T16:36:26.158Z" }, +] + +[[package]] +name = "starlette" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/bb/3d8757f21e9a53d9035c9eb039a777047139a16bfdbedfc7a58241c3d914/starlette-1.10.0.tar.gz", hash = "sha256:b8399098d4c1e3522734f7235dc79b1fc967f96cf139c81e0fa30479e0685f9b", size = 2734356, upload-time = "2026-10-24T15:04:12.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/2e/947cfe02def9371c07cd5bf5b6b61c829e9aecb9904db02a66cfafbc1eec/starlette-1.10.0-py3-none-any.whl", hash = "sha256:478c0ab3b4ced6e82719849c118fa406f0278a3499c1a898cd15cd31bdc38ce4", size = 80571, upload-time = "2026-10-24T15:04:10.371Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ff/50/0195198eb1d75bab716bb0a813abea4cc394bfa17a92a189f021a34859af/typing_inspection-0.4.5.tar.gz", hash = "sha256:7f16c411e7930dc79596d42ab44672a3fe5f60eb34b781a1647e7872363120c7", size = 81194, upload-time = "2026-11-04T14:13:23.774Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/0c/ea2544850a7c135e15033a5c7a8e7211136184b7ae63e2239d557c2b3019/typing_inspection-0.4.5-py3-none-any.whl", hash = "sha256:bc210535442b39e1bf2805e0c7a17dfd6a4ace760c84c7f7d16245d23a6b1c39", size = 14874, upload-time = "2026-11-04T14:13:22.616Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7a/29/6a1391d31cd00ff9e927215a224a880e1e84e826b64ba80a499e51c074d8/tzdata-2026.6.tar.gz", hash = "sha256:85d2cd9c09f81f0bb29db27759fc83af4f1e620efb814f8c5bf8b4cc4feece6d", size = 201017, upload-time = "2026-10-28T09:57:09.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/66/9a06c2227fedfd4919f0eaaa8b94377d9730882a7e4f95823c9a331ab5e1/tzdata-2026.6-py2.py3-none-any.whl", hash = "sha256:0a10eec6e13ef16b627fabed9a5f2ba61a62b1c67f327305f4e7e412a70b4aec", size = 348210, upload-time = "2026-10-28T09:57:07.276Z" }, +] + +[[package]] +name = "tzlocal" +version = "5.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/89/2bd035df331499589fc92e59375c17c6cea6a500453b2c5f6a6ec9572825/tzlocal-5.4.5.tar.gz", hash = "sha256:ba976898bad27945178c9ca25c222c19e322b30c10342b9f40b46714f70d2d5f", size = 31483, upload-time = "2026-10-22T09:09:26.38Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/c1/9be4e1a8a30db8729a86628073910e56f85aaf8a659e053f376a2e6ea5a8/tzlocal-5.4.5-py3-none-any.whl", hash = "sha256:ecab534f6d65d9deb4c4ea52c121ab6dd5958e9b878e71dcb102578269752454", size = 18215, upload-time = "2026-10-22T09:09:24.447Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.54.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/34/30e9280707135d2cfc589dfff3cb796bd07a3aeb1a3e415ba09dd89d7bb4/uvicorn-0.54.0.tar.gz", hash = "sha256:a2e33cbfaa0306f8e6b0c13e0cb89d7d7a2da3e62b90c66e18c33d9807b28620", size = 112283, upload-time = "2026-09-25T06:52:37.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/0c/b54a4fdd7f90a3af8b02ebc9ce6712c2c208b7926a2f7bad95c33ebbe943/uvicorn-0.54.0-py3-none-any.whl", hash = "sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf", size = 87427, upload-time = "2026-09-25T06:52:35.829Z" }, +] + +[package.optional-dependencies] +standard = [ + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/42/02c739ce85fb2ee8d99212c61417da8140c6b87e9d97c430bea520d76044/uvloop-0.23.0.tar.gz", hash = "sha256:28d160f51ab4da3b187063652e643dea6831072add4adc1e6d62afbe73b6be27", size = 2559185, upload-time = "2026-10-01T03:17:04.4Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/83/eb980d64e6dd5da46d4dc35755fa6afd6b5b47141437cf89615f1117c5a6/uvloop-0.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2dcff2d69be43e6559e5dad2c5a7a2dbfb60e05a77311b6c4b7a4a8123d86c65", size = 1412726, upload-time = "2026-10-01T03:15:52.49Z" }, + { url = "https://files.pythonhosted.org/packages/04/c1/02a725e7698134c647904bdee6589e2be14a0e7fc9942c74f86e2b90d48b/uvloop-0.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:19c64108b507cd0bc140e400e3396bacebd9d504956aa7726272bf6de7d9aabb", size = 779071, upload-time = "2026-10-01T03:15:54.02Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1d/cde53c79e8c01884ad1cdca8e407e086d523362cfe4139e2c2a8dde27304/uvloop-0.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1748321e3c59a14a75404b1ae8d5a8d81c4e201803ea0e14c1b6fd84421024b5", size = 4395323, upload-time = "2026-10-01T03:15:55.549Z" }, + { url = "https://files.pythonhosted.org/packages/98/54/b12915bebbf99d7ae0796211e7f5977b95f069830dca45dc1a346d84125d/uvloop-0.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2cba180d6451822763eda8364f342435a873bcfb3849cbd82fdeca248ca65eb", size = 4480449, upload-time = "2026-10-01T03:15:57.362Z" }, + { url = "https://files.pythonhosted.org/packages/f7/8e/da6de68c31549a052a105fc76f5a9a204f6df22cb0909440aa4dbb06f9a2/uvloop-0.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dc61e4f9e37b507069dc7e659ae28bca7adcb04c993c3508214315d12c63f848", size = 4219177, upload-time = "2026-10-01T03:15:59.351Z" }, + { url = "https://files.pythonhosted.org/packages/a1/c3/1b53c6a89dc9c9d5cb75eb9a0b891ad69b32e1421ad3aa01617a9cbdcc78/uvloop-0.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7337b06a9f9ed9ea3049f04b76f65819db9b19bb832ee598e97b388eadf25e5f", size = 4346132, upload-time = "2026-10-01T03:16:01.064Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a4/00e85345871c59c834a23c136c1771205856028ecc8ba940b3951178e59b/uvloop-0.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b90397a50ad6332ed3e459c648ac20d182cce24a557354363ad85fc9ea4a17cd", size = 1421363, upload-time = "2026-10-01T03:16:02.599Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a9/e5f0f3cfde30af3ec32eba8ec07bccdba2b5116afbd1ecc53edfeb0a0790/uvloop-0.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:be53e1d5f83de43dc175c87612ecc128d444b38e5c56cb3f807f5a73d6887476", size = 785177, upload-time = "2026-10-01T03:16:04.018Z" }, + { url = "https://files.pythonhosted.org/packages/9e/79/9ddf78f8cd75a15c14a09a57f59c587b8cd9d82802c5c8368b9c3ebefa0b/uvloop-0.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b3cbc4f96ddfa1fb88a78a69dd851369825b7816d9702eee8c4461505ba172e", size = 4381060, upload-time = "2026-10-01T03:16:05.642Z" }, + { url = "https://files.pythonhosted.org/packages/1e/20/57d63c44d32326878fcad5c63854afc9deb394ed95673c1b1a429178c79d/uvloop-0.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31e0cf90bc8fd88784f6802cdba968a51fb1aec1cc3feec74d862b2d371d1330", size = 4418891, upload-time = "2026-10-01T03:16:07.326Z" }, + { url = "https://files.pythonhosted.org/packages/12/c5/0795abecda2cc3dfe41033f880a32a9ff103be4e6b177ac736833c153a0e/uvloop-0.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa8ed556fcc87a4091cf61587ef172fa104323dc89ecc085a618ba7ff8629a8f", size = 4214811, upload-time = "2026-10-01T03:16:09.13Z" }, + { url = "https://files.pythonhosted.org/packages/20/18/9010dacd5221eec1bd79a4a83ac68f3db6a42d7bb657f7b640c4838ca6b6/uvloop-0.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f3fbfe82829d8e381426a289b87e59e585278728361db9ce975b88b51f64f410", size = 4294876, upload-time = "2026-10-01T03:16:10.875Z" }, + { url = "https://files.pythonhosted.org/packages/b1/08/f6384a03c771d00067cba4f542a69b2fc1a982e9fd78b357c2f788678d72/uvloop-0.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:7e35c9bc977760981693e1a7a51493b58ee5a501f9ebb1e547565ee40b6c6208", size = 1494811, upload-time = "2026-10-01T03:16:12.399Z" }, + { url = "https://files.pythonhosted.org/packages/ac/01/756a4fb24a449f313cf4a153eb0c6210b49cfe5539255ec9fb1e17d2c4ef/uvloop-0.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5bb9be71d9ee39b4359b832f9569518ec9bc08704194034e79e4958e6bc4d46d", size = 819396, upload-time = "2026-10-01T03:16:14.094Z" }, + { url = "https://files.pythonhosted.org/packages/3e/45/e314b0c600b14f53dad3a3c2d7a922a249a88225fd727652b53e1854b9dd/uvloop-0.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e84575f11873c109cf3962ad0bdf679094466184125f4cadcc41a73febff41f", size = 4734966, upload-time = "2026-10-01T03:16:15.815Z" }, + { url = "https://files.pythonhosted.org/packages/66/0d/8686a7f0b1b2d55ebd770ba21f8e0e4ffa0cde5ab738f43ffb8264499052/uvloop-0.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbbdb8fcd5e7062e546eec1ac78c28bb21ae7df54c18f8e4b06e15a18d661a49", size = 4584963, upload-time = "2026-10-01T03:16:18.198Z" }, + { url = "https://files.pythonhosted.org/packages/78/b2/034a2d47e435ac02357c42956246887167bdc0357bdd6ad31c5f6d94497b/uvloop-0.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:76345f51367fb1f23e08605c6efb18374f669be5b223658fbab6b17627950507", size = 4421388, upload-time = "2026-10-01T03:16:19.953Z" }, + { url = "https://files.pythonhosted.org/packages/f0/77/131f4b583e6b4b715c404a66b51c812d701db20f25c9018b188a2b00062c/uvloop-0.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c7ef4701a96553514b2688e342ef1bf2beae6cfd172d89a76c768292aabf405", size = 4402414, upload-time = "2026-10-01T03:16:21.716Z" }, + { url = "https://files.pythonhosted.org/packages/58/3d/ee11f4718ea1280595c67ed25c83d4c92115dc100bbdfd192d3ed9339168/uvloop-0.23.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:f1341c6abcee1c31277cfe28d34e46196f2143ec3d755e6efe7452126e1f626d", size = 1418095, upload-time = "2026-10-01T03:16:23.241Z" }, + { url = "https://files.pythonhosted.org/packages/f8/0c/7ca516a0671418517d79a09d3ff2ccbb44af94c75711afa6e4cf58aa6f65/uvloop-0.23.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e095f9e105af76593b4c183bb0bcbdae64bd913a59ec595732dc108b48730ab5", size = 784837, upload-time = "2026-10-01T03:16:24.666Z" }, + { url = "https://files.pythonhosted.org/packages/35/95/75d4e28e596d505b7ae11de517646b4ca3d369fb8537ba755410380da11a/uvloop-0.23.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f673d835bdb1a60229cc3609a113fd2c9ce3f4a3c75ad4eaed111180c00199d2", size = 4380276, upload-time = "2026-10-01T03:16:26.389Z" }, + { url = "https://files.pythonhosted.org/packages/10/99/68daf827ad62efaf4667d1f3fda127046d42161178396bdd93aab3684082/uvloop-0.23.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c3f23f403a273900d57de6ee5ca0614c650f7f58563065dad1a4744498960e53", size = 4451496, upload-time = "2026-10-01T03:16:28.364Z" }, + { url = "https://files.pythonhosted.org/packages/71/69/f67e696ee688f426a96f99099bae26fec14a1d0fa75dccdd6518ee267c0c/uvloop-0.23.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cbe8d03d4efcccdb7fcedecbaa1e1fa02913eaf3a74cb933634a6bc6d2ea9e2a", size = 4212541, upload-time = "2026-10-01T03:16:30.014Z" }, + { url = "https://files.pythonhosted.org/packages/f1/6a/c8c436a9d7453297b4be70bdf6a9f9fc9400da45e0059ddf7b28ab63f4c7/uvloop-0.23.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:4f1798f56c6f4ba5ac11fa2869e5717926e4470d97a1dd42b4f59219d43b5027", size = 4319377, upload-time = "2026-10-01T03:16:31.705Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2c/8fc15a03489299aab8a6212dfe0f137dc39836f915c87f7fd9d9ddd814de/uvloop-0.23.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:098a85e1393ef5202767b7e5fb41a32cd8bd81e6ee4af364c179801c4aa3f6d4", size = 1493428, upload-time = "2026-10-01T03:16:33.859Z" }, + { url = "https://files.pythonhosted.org/packages/b7/7c/05e4a210790229607f71460fcb2ed4a2c7bc72668d8a928ce577c22e38f8/uvloop-0.23.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:5a2bbad3a63007f7e9524d4903ba04fee252557c2acd86f9a3d4f91786695254", size = 818115, upload-time = "2026-10-01T03:16:35.45Z" }, + { url = "https://files.pythonhosted.org/packages/65/14/a40b11c6c024213803b13955664a15754c72f64c873a33d986b26ec9ff5b/uvloop-0.23.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a08875543bbd4519faf30497506c9cda8a48470467ffdf967c7313c7a5981a8", size = 4734149, upload-time = "2026-10-01T03:16:37.025Z" }, + { url = "https://files.pythonhosted.org/packages/9f/83/f421a077712c1e87603bfec62744c3cd3a2f4b47378025db3d740df9af0d/uvloop-0.23.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:12634f15e6625f78b3f2922f91404c4d7173487eba11746764153f556e9852dc", size = 4661763, upload-time = "2026-10-01T03:16:38.719Z" }, + { url = "https://files.pythonhosted.org/packages/f5/62/25dcaa6b7e7b48f82ce633854ce96597ab768f9650931f4f86c572de392c/uvloop-0.23.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:378188efbb1524f2219d05246a3e1e5907217848d2882144dff59585f1b81d55", size = 4421324, upload-time = "2026-10-01T03:16:40.488Z" }, + { url = "https://files.pythonhosted.org/packages/05/46/04628239b43dcef703af314202a3307d6060918e2d76aa86c5b1188f5551/uvloop-0.23.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4b8e207c67d207a8608fec57e116511030af3495dc0109b8c333cf9cb412b16f", size = 4462501, upload-time = "2026-10-01T03:16:42.359Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.15.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "python-discovery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/bd/e40ad2df6a9efc1f859ea23d63fd7371cff68252833f182ca9af819bb4d3/virtualenv-21.15.6.tar.gz", hash = "sha256:c8b65c7d206ca6ef18de9352c160b3f04f66fff9f6b0ec8fd31f14688eba52c4", size = 5641659, upload-time = "2026-11-06T18:17:32.46Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/63/fd514dee3159f74a96ac01beb8f460b65e4ef0b972f63f4fe9f0cd2aa0e3/virtualenv-21.15.6-py3-none-any.whl", hash = "sha256:4b99ab9b95ff11043939bb4cad2fa0449175fa5a478372864f62160cb6c1a7ed", size = 5680963, upload-time = "2026-11-06T18:17:30.128Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/68/e6aa0b77d217b31f8f486ec0cdfe5e00e6e38dc0be657e7d85819b9faf0a/watchfiles-1.3.0.tar.gz", hash = "sha256:99aee4a07847c06820765fd7b1b49ceac4f3f711ccb7d104655a33231de1c207", size = 108119, upload-time = "2026-09-21T09:08:55.664Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/fa/c0b840d5d8bafe640925408ce11095948c8945bb61be1e67d0ab629b872a/watchfiles-1.3.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:000b9688fc8133037a8b075c8ebf98f32844ff8964dda61e85c1db547dafc441", size = 399703, upload-time = "2026-09-21T09:08:13.518Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8a/894799b485fe9473ad10422a0d9668e53fb78e3a2b5cc6061159572844ad/watchfiles-1.3.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:bbc1198edfdc90fda0600f825aa94150f428dfcbf8138746f55998e0e660d64c", size = 397647, upload-time = "2026-09-21T09:08:15.16Z" }, + { url = "https://files.pythonhosted.org/packages/5a/61/f277cd5ead05f5d37b98b41fbdd0c943ee0c04d49738f62e902cb291cf43/watchfiles-1.3.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4af9c464d410e8c44b58ddf1cbec7c3a02c1cb2c6c80df9c74659ba2fbda0ab5", size = 454994, upload-time = "2026-09-21T09:08:16.587Z" }, + { url = "https://files.pythonhosted.org/packages/46/66/ea4c01382975e53b1ac1b0a0ea1b353416b8127fb6e04f5c1c313119aab6/watchfiles-1.3.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb94e40b9a0db19636b5e3fed0a9803452ecc7381df13b385272abb779ee83ca", size = 460105, upload-time = "2026-09-21T09:08:17.961Z" }, + { url = "https://files.pythonhosted.org/packages/31/c3/1a501b597817096c9831c255f6270c124ce0e2faeb74124be24dcc93b86d/watchfiles-1.3.0-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7398930a2b76b9dc67a4e6b8bfc7baf30946892a86f417a3920c07bdd6febc30", size = 493761, upload-time = "2026-09-21T09:08:19.327Z" }, + { url = "https://files.pythonhosted.org/packages/5a/16/77352d05e152c7786a016e9f1decdb4507e8aa5bcf3343c72142a0413d14/watchfiles-1.3.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:025b108f2d5cc2799cb941f79380df3e8b22bfb589c218e801767fe78d598c95", size = 577500, upload-time = "2026-09-21T09:08:20.723Z" }, + { url = "https://files.pythonhosted.org/packages/95/fe/81001c55b24466fe9911135e50269fd3a29f43e446627a92adfab54553b6/watchfiles-1.3.0-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:be9ef3cd403d756a304a0a08a112163c63da7ec72c8c9d083c98818291ff8f29", size = 469209, upload-time = "2026-09-21T09:08:22.346Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cf/e3ad894ed5909a7c44b0707e89bc25d19a3d78b3a7aec846119443b6ae56/watchfiles-1.3.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5768b49e426fd5b550b012c866db347cdf15c398ef98dc557b6e6b72fa74cd1", size = 458353, upload-time = "2026-09-21T09:08:23.7Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f5/2f106829e6e2bc91ad74614730f6df484202b9a4d20d927dbf2f08d37d44/watchfiles-1.3.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:d36c72fcdc08f143d87316a4c4c3b064e340da2c7383d39803950740ed418935", size = 468707, upload-time = "2026-09-21T09:08:25.167Z" }, + { url = "https://files.pythonhosted.org/packages/15/37/2741ab776b978669c1f3bba1e573f1a184f727ab8b4d3a6d9c61090800ed/watchfiles-1.3.0-cp310-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:f0c9865240e065a2247f4b5248528ae3d01e0e8ae071462c250c884dc16e3ee3", size = 632510, upload-time = "2026-09-21T09:08:26.532Z" }, + { url = "https://files.pythonhosted.org/packages/48/64/db4a4684275fe9b696ee5118c194705c1423b3d42181c3f8ee70194d5c73/watchfiles-1.3.0-cp310-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:380f513d26cc2e598266b88d66456e07d67ef4be8f0f435a1154d9c44b43d509", size = 661723, upload-time = "2026-09-21T09:08:28.004Z" }, + { url = "https://files.pythonhosted.org/packages/52/80/95ddb24f6a2f595c031c24432ab7b8aa7d6d1ada0c6d63a552166e06e8d1/watchfiles-1.3.0-cp310-abi3-win32.whl", hash = "sha256:509d9f74d2bec5c1f4cd868ddcfe0c9601f7ea53066dfcb19d8ede742c4de661", size = 277761, upload-time = "2026-09-21T09:08:29.335Z" }, + { url = "https://files.pythonhosted.org/packages/48/a1/1c4a1b3c8030cd03206232612be8a6e8799093490c220b0fcb935d02b75a/watchfiles-1.3.0-cp310-abi3-win_amd64.whl", hash = "sha256:1acabde19b67e673274e89a04d613b7fb1f122e2c4b8ec9a581e59c149264b61", size = 290643, upload-time = "2026-09-21T09:08:30.45Z" }, + { url = "https://files.pythonhosted.org/packages/82/e0/d2db577c632d26d08078c4390dd870b8555c4e558df25d22270f0166c71f/watchfiles-1.3.0-cp310-abi3-win_arm64.whl", hash = "sha256:d978cc1dd7ba44f5590d7de74f7a9c8be7262d9e469c2c0efb8bbfc2574321dc", size = 285510, upload-time = "2026-09-21T09:08:31.561Z" }, + { url = "https://files.pythonhosted.org/packages/4f/55/a122743607939429ab6a7272672f49303aa02bbd34c3f06676765a3861de/watchfiles-1.3.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:e0204f90677b7fb8d3a824279a71a01166bea9f6e53923b8056592d87b33b0b6", size = 395978, upload-time = "2026-09-21T09:08:32.747Z" }, + { url = "https://files.pythonhosted.org/packages/3e/9d/0ee1b0ea42acfe72afa2484f0222e2386dd09992e9034a81e63cc3cdab0a/watchfiles-1.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7c1125e99f84934a92996ae343501285617373acd66f16b59fd5654b27ad8d80", size = 387997, upload-time = "2026-09-21T09:08:33.953Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f2/4319c6b683e8bd28465dfc53c750617a2a07f072eb2e3ab0182ccf812229/watchfiles-1.3.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a85e243c87109d9f48a2e0d10d6abdee8768cc114848b32281ec83d7f81d86ef", size = 448067, upload-time = "2026-09-21T09:08:35.104Z" }, + { url = "https://files.pythonhosted.org/packages/b7/71/9f37ac192a51a24de3a2d7fe9aac1e99b2b2668300674ff7a9f85d95beb1/watchfiles-1.3.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dd538c71766c59c732e2c5cedc39323c99c11897b99f93eac773438e54af206a", size = 452881, upload-time = "2026-09-21T09:08:36.238Z" }, + { url = "https://files.pythonhosted.org/packages/34/07/1224667c32a4a96876ddd642da69733cbfe6a15897db0865aec5a882cebc/watchfiles-1.3.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da213822ec9082b62cadf3008e07a8c690ec7a3c89f6dc5e55a8cf07b56a1b26", size = 484802, upload-time = "2026-09-21T09:08:37.717Z" }, + { url = "https://files.pythonhosted.org/packages/bd/4d/7f29cd87e1f826df86fc0418d0b8f370ca0311c29c618406dc492aad9951/watchfiles-1.3.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d4593392e87669836670f87d62fc754059eaeb0e6157af44060a46558cebe5a3", size = 567522, upload-time = "2026-09-21T09:08:38.94Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ac/3aa1f84abd4dbbfbae99a817dd931f77b439261c911189cad4c30fdfd470/watchfiles-1.3.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26b81bc515a0f03f66a69a6fea86eea54c8eca4173c46dd7222569f79dd2f977", size = 461997, upload-time = "2026-09-21T09:08:40.142Z" }, + { url = "https://files.pythonhosted.org/packages/82/1c/27c66764d5b0dbb70a36770a32eca217eba739c28b24e8583a035087a3d7/watchfiles-1.3.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca39661934749df580d89f3dde266f2af7c6968f4c21c72ce2dc387d299e6aa7", size = 451856, upload-time = "2026-09-21T09:08:41.305Z" }, + { url = "https://files.pythonhosted.org/packages/1e/b3/a45827084d953c1d0dd3d75abf85dcac26a0f5d115ad2fe0b7e9e931573b/watchfiles-1.3.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:04c5500faa725d69a99b0f63750e80795e455bb951849e9c98a811b4324997c4", size = 459889, upload-time = "2026-09-21T09:08:42.58Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3d/07740d23ce2bb23419bb24055c435a9abe5fe03efdaea1ba0720b831aab6/watchfiles-1.3.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:ec3cd4bb181a7b6329134204c2277c7144ab5f62cce9c5335d6f901ee7ce8d6a", size = 624482, upload-time = "2026-09-21T09:08:44.064Z" }, + { url = "https://files.pythonhosted.org/packages/91/46/9540f8123eaec86df989f26d7704cad0448d9fb7271763a4f8f9fe23617d/watchfiles-1.3.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:e5871d4a7f788a9f64fb06f5793389d29d171e5c32d37c3ebfd520b017cc7694", size = 653724, upload-time = "2026-09-21T09:08:45.257Z" }, + { url = "https://files.pythonhosted.org/packages/25/9d/b9deb52f1e4528ffe44338c5ebab95c32ed79203082da661de50288e130a/watchfiles-1.3.0-cp314-cp314t-win32.whl", hash = "sha256:81c989d7267bfb7b676cd32c83bec97914e396870983cbf493e29415037bff5e", size = 270863, upload-time = "2026-09-21T09:08:46.518Z" }, + { url = "https://files.pythonhosted.org/packages/59/59/8b1881afccbafda06248be4185e28034dd73c80c85e4da24f2cb0c1321eb/watchfiles-1.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d754e049006e81a9be49dc78ba7802081cee426e968cbc63ee19e164fa2d0e39", size = 286879, upload-time = "2026-09-21T09:08:47.874Z" }, + { url = "https://files.pythonhosted.org/packages/46/dd/41c12ae9745d5d72f709333287679d71cbba68ad7678fed872207bba94f4/watchfiles-1.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:a5b631db08fd3032db57ec6a92d1777cd60f88803287e4e941a4858c53aab1e0", size = 276924, upload-time = "2026-09-21T09:08:48.976Z" }, +] + +[[package]] +name = "websockets" +version = "17.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/75/79/590c5f0cc7d1661195aeefccb0e342b79f4c77d368d526d028821a390332/websockets-17.4.tar.gz", hash = "sha256:09d3939b70df0c8ad2da145ebd50978bccaee1d565e838b0e7921a34d38571eb", size = 191391, upload-time = "2026-10-30T15:10:35.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cd/58/eaf27fce59e3f5b9997cd7c77749ef214e077daeffac95479be6ff9f5cfa/websockets-17.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f24bed98595b9d854da8d6debaf82754abf3e8fe63ec90505ef560566814df7e", size = 218769, upload-time = "2026-10-30T15:07:42.558Z" }, + { url = "https://files.pythonhosted.org/packages/13/8e/287eca6d399a953253492189153976676994dfba1b7e82f0f992d14c1404/websockets-17.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:156221ad7638b5abccefd6f798916bf3f8ffd6ac51480eb4ba5b05df914ccbf3", size = 216454, upload-time = "2026-10-30T15:07:43.874Z" }, + { url = "https://files.pythonhosted.org/packages/b3/65/098fd4d221d691395492fcba88c895dde19a51d371b06b8d0be71d3f781b/websockets-17.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:74e46409666c358b93fce0d8c6f4cb107d8dd7cba1302a38d49adf6fa8193c7e", size = 216715, upload-time = "2026-10-30T15:07:45.409Z" }, + { url = "https://files.pythonhosted.org/packages/e9/29/9f9833bc83c1bf2e5597d1ef374d3ccd6467b9b45400cff399c85331ef6c/websockets-17.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e3e80cad85ba68c07c1e8d4ccc9cf51e63bf6a73d6bf631640be947bd72b6b63", size = 226096, upload-time = "2026-10-30T15:07:46.929Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/6a95f93661bba2f1a4ec82eb26c6d30e6ba253569ecabb7a675139db6051/websockets-17.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:25eb661d8ba7e2b85ebb4e7a1bb9f6a3280910ed10b84330a7abfb5ed32d2764", size = 226382, upload-time = "2026-10-30T15:07:48.332Z" }, + { url = "https://files.pythonhosted.org/packages/80/b0/b0d9427dde0609e2727a9a966fb5fc5c6ef6aa7eba4cfc98791f8b7f1b75/websockets-17.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c74954409ea5789f7a60daa5f94580c00ad0b60b20751c47b35c4784877b5057", size = 227617, upload-time = "2026-10-30T15:07:49.799Z" }, + { url = "https://files.pythonhosted.org/packages/3b/00/fb1016d850d61676d1732434e2361d116c1de369078e59d21f4713115a19/websockets-17.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:47beedf07a706140b50786457e082497ee6b5970c41e49bcd1572ee3f4c73f80", size = 229054, upload-time = "2026-10-30T15:07:51.258Z" }, + { url = "https://files.pythonhosted.org/packages/77/c4/bb666e196541e42237fdb625303ad099005cc835c4e2e0a5d97bb9c4185c/websockets-17.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e282f35ece8895b9fa5af406fc6a4cb42f01e1009525cf46641de584781c83b", size = 228243, upload-time = "2026-10-30T15:07:52.975Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f1/32ae0f45d8464e1606ef3f6a54318d8754b27889de18bb1b2176a19bea39/websockets-17.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:361f9a21a33191d5287e7a75f508fc3b9bf47aaffb0241198d6b7be3384f294e", size = 226995, upload-time = "2026-10-30T15:07:54.574Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9f/5680151ef10e0bfb6f3bf09a992ce6c3e93bbb84fc8ec5d03ad570ac6532/websockets-17.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4073ab7cefe5a2e7dc368c1f01eb27716dc8ea8f1c69e9b7725ebce05aa53cf7", size = 224244, upload-time = "2026-10-30T15:07:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/e2/66/409117b6882b91960598d62b95fac33d70a7aa2e1e1e854c6b64e76712f6/websockets-17.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a50bd9b44dd9b7b845802030b4d88610c01c7f95571b4cbd3a1aeec17a34c9fd", size = 227058, upload-time = "2026-10-30T15:07:57.539Z" }, + { url = "https://files.pythonhosted.org/packages/35/e6/34cab5913bea9d011ae2592a7672340179ff14fb98e889e5e41b071d8134/websockets-17.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ad2e9e152bec6c4f7e4cdb4adcea6b708400090eec04bfe5ee5b30d368ffd721", size = 225654, upload-time = "2026-10-30T15:07:59.044Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b0/6cfe18e12f23618a3d69723c828037c1282fee7ffce006ae7b5cc0e58ca4/websockets-17.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5830f94a7190a33e55d06d89242ea951ee2009c3a27fc31538f3ac9386b27edd", size = 226425, upload-time = "2026-10-30T15:08:00.492Z" }, + { url = "https://files.pythonhosted.org/packages/c9/71/14d31ea34bafc07c6d96b362a44b301b9a0f2fb260490a8a6cb7db682bc4/websockets-17.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c0cc2cb47face4dae64bd70a9268dbebddb3e48c1b48cf6d7b6ac1471609fd88", size = 227532, upload-time = "2026-10-30T15:08:01.932Z" }, + { url = "https://files.pythonhosted.org/packages/28/69/df3398ca1320a8b76e57ee41053d5c09955383cf60888ffa5771f51a4cc8/websockets-17.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d0b6a9bd86f865ebc9d847a1eb0a655a0e2b447cbcde743dda97c4298415cc0b", size = 225090, upload-time = "2026-10-30T15:08:03.328Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/06afe778cf9893e9ac10209c0d4c70aaf0b72289245a8b7efb92cc80927c/websockets-17.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7a7e9321822ca59ba56fa8744c3e3f01ef74d547aafe0d383d000d7a4d11eb79", size = 226041, upload-time = "2026-10-30T15:08:04.714Z" }, + { url = "https://files.pythonhosted.org/packages/c6/7a/28e9822dbf0bc63341dc45d8d5f1f1f7f375991fc8895bc731105fbde371/websockets-17.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:de29795f23833cdfb68ba45c8a5cc0ec49778ea5deb670188f4465bba5930d25", size = 226323, upload-time = "2026-10-30T15:08:06.103Z" }, + { url = "https://files.pythonhosted.org/packages/5a/d8/606c9c404e82731e4520f6397c8c16549e9cbd39ac583e7ea7d8972a6ae7/websockets-17.4-cp313-cp313-win32.whl", hash = "sha256:37ed7782972545e67d97ef9a172e9499d25459b1e32cb99d1c2a30c572f2441b", size = 219248, upload-time = "2026-10-30T15:08:07.617Z" }, + { url = "https://files.pythonhosted.org/packages/60/a1/17e507dadbfccb755758ba977b165fec92924dfc4a8d2573b4fc1561b0cd/websockets-17.4-cp313-cp313-win_amd64.whl", hash = "sha256:203e42eb77e06f85778a908b34c5ad032f34e98a68ef33920d6685c1e65a9420", size = 219560, upload-time = "2026-10-30T15:08:09.108Z" }, + { url = "https://files.pythonhosted.org/packages/01/ba/4f51fe8db73889ea3ecfdeee283d4ac3b7ad7a609c0e4c1fc6de04078021/websockets-17.4-cp313-cp313-win_arm64.whl", hash = "sha256:d8255971f6789cf0cb365e3e22b9b166eba978548a26241eaa5b7af0440d885a", size = 219496, upload-time = "2026-10-30T15:08:10.574Z" }, + { url = "https://files.pythonhosted.org/packages/1f/5b/085530961668661300de7248f9bf3ba84e98f47875f0fcc87637d024f82b/websockets-17.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:d0f943b53bb1d7389d72a5380078670e5fcc34a1328142148b72d20fd82031c7", size = 218810, upload-time = "2026-10-30T15:08:12.14Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fb/5a29e9569f74988822b7bc076287dd7f9f5b68a2070cf5eb4cfada5863d8/websockets-17.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2fd562372d4afaf18d1c7f1c68e39bd32818bb16d5f57f778a4a4ed88eedcaae", size = 216506, upload-time = "2026-10-30T15:08:13.561Z" }, + { url = "https://files.pythonhosted.org/packages/df/73/eb8544367c13cd87df39d41b74853741fb7182e2a4bb659ad7d36f9066c8/websockets-17.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a0457561e8a87a6a3b509e21c35084d7d207ced262139de3f738e9676a476bbd", size = 216719, upload-time = "2026-10-30T15:08:15.08Z" }, + { url = "https://files.pythonhosted.org/packages/24/fe/c3707e426d9bd779dfad9f319b2b431e5e60d563d7547d3780cbd1646028/websockets-17.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7b4ee34acefa9ba1333f02b817982f1e4127f6f9b975017a707c4e738d7f9fb9", size = 226098, upload-time = "2026-10-30T15:08:16.581Z" }, + { url = "https://files.pythonhosted.org/packages/c1/24/d203439f909ffbf37260ca28a3432381412d2e79912ebf98be572e63055e/websockets-17.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ef03fb4b3685df0ed9dc6a074a090f030345cad2c23c61818da3e08e693a9caa", size = 226449, upload-time = "2026-10-30T15:08:18.29Z" }, + { url = "https://files.pythonhosted.org/packages/4b/17/3ae5d9486a170a222dd0437b4f2bc02ecf324177498a942dcac200e65d05/websockets-17.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5e970d3996c597186c9dbb6e77a8048737a834ac03cb13186a54999e0e1c31e", size = 227695, upload-time = "2026-10-30T15:08:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/34/37/1307a8e30a961726f2350982fc01b0b3498db29b030c78c566e65ba64487/websockets-17.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6afc32a7a1a40b071070419537df3559d26907086556769683fa97b7b6e90fd5", size = 229069, upload-time = "2026-10-30T15:08:21.682Z" }, + { url = "https://files.pythonhosted.org/packages/9c/bd/4c6167744e202d20a3c770bcde8fae5d427317b1885712c2e02718cd8133/websockets-17.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5da7f7f1ecf866186f195f7ecc374c915e1838496b86f2f3b41da27c798a25c3", size = 228296, upload-time = "2026-10-30T15:08:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/14/b3/3438eee41b39afb44c3c6e45dd686b88a7f8d742b96877b77de4fe0e0255/websockets-17.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:043945a43873c7c11a3f75238d475c95f902e967de329eb8763704546cfaa6b6", size = 227045, upload-time = "2026-10-30T15:08:24.749Z" }, + { url = "https://files.pythonhosted.org/packages/46/39/0bac9052d402efaad1b202ff2f1a57b6334aa624d20f509312765601b507/websockets-17.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:927d602fb8fb595a69e6b1ae998a6ec19851d0fb9391759456e6425090996647", size = 224297, upload-time = "2026-10-30T15:08:26.275Z" }, + { url = "https://files.pythonhosted.org/packages/a1/7f/5809f6ba5a7d1065301800daf605bdb661a9db5ef868ed189dbf691122ac/websockets-17.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:769e4f7b090e10cae4c082e3e39b9458ec2444505df84953c16c0468b16539c4", size = 227169, upload-time = "2026-10-30T15:08:27.703Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f7/c8f6771e7cc2a038cf78bb12d04d29dbbbabf2a84d76999bcc94532f3020/websockets-17.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:03ddf4eb76ced8725dcbb000ff60b0fb8d7330ed011f6dc725a1925c5fe02051", size = 225632, upload-time = "2026-10-30T15:08:29.441Z" }, + { url = "https://files.pythonhosted.org/packages/2c/2f/9104786d952978ca2d011321109e35c05be24c3937ef2a62b4d6e25f7515/websockets-17.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:94622cf24e80d03054ceb69a06a86c950e12fe993ed06b933f7895232cacbc3e", size = 226415, upload-time = "2026-10-30T15:08:30.962Z" }, + { url = "https://files.pythonhosted.org/packages/ae/a7/2e1606b3d616b86bb6c70a62d5f87fc9a3dbd81f0bbe24c4706ace76751d/websockets-17.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bc581579885728bb54ef15000295c20e6a64a200b1b73d5cfca71879a3eb3e1f", size = 227594, upload-time = "2026-10-30T15:08:32.443Z" }, + { url = "https://files.pythonhosted.org/packages/67/2d/78ca44e2be6d397aee63a4e68d3a99a33bb14bb3405e94688bc5a2160db5/websockets-17.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f42671900e0b602d05a074c52fd3d757c2f8e5c4f73f771794dae1aa4aea5f0e", size = 225146, upload-time = "2026-10-30T15:08:33.888Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/6dad684e54fc8e09d70c9a095506db5c836207d8e846e3cb1e79424e3492/websockets-17.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:2b23dacf7a8a88afe92f77bcdbf4cf043a84692bac2f2da02f4011c687e19b48", size = 226095, upload-time = "2026-10-30T15:08:35.285Z" }, + { url = "https://files.pythonhosted.org/packages/d9/e5/7b04bad7c11c1f92238429352defbac1406743338049afe1328c7a7f95c0/websockets-17.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d48795c7d64ca1c42e3d61fcc6478cb15a19b6ad3f9c882bc8d8dee49d4a420f", size = 226395, upload-time = "2026-10-30T15:08:36.8Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/4eb29c4b12f77b3139470063308ae1e6a0860b9073b1d27d56e8ce19c512/websockets-17.4-cp314-cp314-win32.whl", hash = "sha256:8588edf317fbe4f16a949bc5a6ccdd22b6e6fd5b4745d128bc40bccf31024ce5", size = 218784, upload-time = "2026-10-30T15:08:38.263Z" }, + { url = "https://files.pythonhosted.org/packages/6d/85/2496a24de80c215b55a15f037bc368a2ed0ce7ecb1e909039ff4e76395de/websockets-17.4-cp314-cp314-win_amd64.whl", hash = "sha256:70293c25d79d1f084fdd665894481547575e429d2a75e8d72caec2f6b6b07af8", size = 219137, upload-time = "2026-10-30T15:08:40.112Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a3/cfe95d4eb569035e5a1d2e5cbeb4ccf0eb15a19e1ef2ad819a85960bf375/websockets-17.4-cp314-cp314-win_arm64.whl", hash = "sha256:adc30e5d064c9e33049e825408fa4e952f4e8a0cf4c329dc2ded72e1bb5bae08", size = 219017, upload-time = "2026-10-30T15:08:41.778Z" }, + { url = "https://files.pythonhosted.org/packages/2b/dd/4143048a2b27303e7de8ef53d7d0ee3987734fbf93e09491d5a1b0a55187/websockets-17.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:bbb6bed49f083e2ec8ae0bb21c00c7c5171ab8e08a8b008c61a43fc6c944fdac", size = 219141, upload-time = "2026-10-30T15:08:43.184Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3e/a63b5f3a5c24be2898eb22a3093a56d4ac4cd24ae79e7ab7a1b971ed4611/websockets-17.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c7a56140fcbf4662cb263754a754c651a16fe2196cae1fd232d18f89acd30c83", size = 216675, upload-time = "2026-10-30T15:08:44.682Z" }, + { url = "https://files.pythonhosted.org/packages/d6/80/f238a10f0b23853c665c602a42784023995ac26674e480252c21af39f4f8/websockets-17.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:18d3710becc612ec6f0229425bd6495133dfcbf30f7b6569585acc8ed2f1b452", size = 216880, upload-time = "2026-10-30T15:08:46.304Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b1/899b69aba1e8d65ac5bfe90b97ada22a815f1dcd3840bf188104738aac33/websockets-17.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:00ad98e4bb0df7a6711c645eec16d5a9fdf99f0692bd4f5b6cb85a68677ba8df", size = 226462, upload-time = "2026-10-30T15:08:47.723Z" }, + { url = "https://files.pythonhosted.org/packages/28/a8/598c2b2a22dfe14d352400df804db8b78a68c1498b3f775a658f07f21618/websockets-17.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7849a096d6fdba3f2bdf849eb89f2d233a24400c92faa3efb25fa8dc615b706c", size = 226741, upload-time = "2026-10-30T15:08:49.314Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ad/84a6de3cc3dd4ee336428c31f89a82e002299f83e10d967f0e9a5cbaf591/websockets-17.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e30550965c78223439815dbdf40c93eb8931dfbf12427110dcfcaeebef76feb6", size = 227914, upload-time = "2026-10-30T15:08:50.746Z" }, + { url = "https://files.pythonhosted.org/packages/69/ab/1e191b97d60a934c071b7b73c39c5db39721a925cc53acd929c615f85550/websockets-17.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:725be1aff55f1c873a79cea0f612df9dff21a9d2c2e05783665b824b8aa7c24e", size = 230059, upload-time = "2026-10-30T15:08:52.596Z" }, + { url = "https://files.pythonhosted.org/packages/f2/57/ef8a64732ef4367091ab05f9b22c1ee4c28657d4a0d088a644198eb5ded6/websockets-17.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b6c7f91520c29420639925fd1cecceac9ca07366b50c09ea24eac1cd116b4866", size = 228486, upload-time = "2026-10-30T15:08:53.967Z" }, + { url = "https://files.pythonhosted.org/packages/48/1f/dbad3afcacf2c52d1fdf83b611d849598f0a047d7333ff476266532877b8/websockets-17.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6531540aa63e6864cb0615a3a5da70ae03191334507852a5385320bb7916df3f", size = 227216, upload-time = "2026-10-30T15:08:55.687Z" }, + { url = "https://files.pythonhosted.org/packages/5b/47/59e325d6ca3e04ba5cc7a139d891ef83cad3fb460a183c8f359f378b69a9/websockets-17.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a57b99f2e28922b5a2434317580fd23fdf118caff4c5b752f5452836426205a", size = 224755, upload-time = "2026-10-30T15:08:57.203Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b6/28a471318dfb0060b58c47d0a252cb5078528a1aa1fdf5e6e88e2a61cf18/websockets-17.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8fd30d217a4275107667fe1d4f601e2d50c797d0727148cfbb384536d65f04d3", size = 227508, upload-time = "2026-10-30T15:08:58.597Z" }, + { url = "https://files.pythonhosted.org/packages/ee/29/7485ac6fc4b342b43964811381f56276fec967cae6a851ae4b815613b10c/websockets-17.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cc0cd4065a65ac98f3e2742ee9f314da9d224db49b07dc17d3a20cef0d79658d", size = 225961, upload-time = "2026-10-30T15:09:00.414Z" }, + { url = "https://files.pythonhosted.org/packages/95/a6/520e1f7aa9644ddf58f5a51fc37f46e15293a68cd35b70d5b81b7331ca1e/websockets-17.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:71f76bb8e59be847330b8a8d3753f85397677e128f9f9692c215f8cf721cefc7", size = 226851, upload-time = "2026-10-30T15:09:01.979Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0d/444799abe7418f361da8c201c6858b64b4e8d47265f90851e5cb68b4d90f/websockets-17.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:c2db7b9e2d726f7e051bedb67abcf460b84b11437b2f9fdacda7e6931dace85b", size = 227869, upload-time = "2026-10-30T15:09:03.405Z" }, + { url = "https://files.pythonhosted.org/packages/cb/86/6da20322a07364a0ab0787a2b0d4367770f59404fdab6e35122413a7f63e/websockets-17.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:332b88022d0acd47c44158bcd43f47f14eaddcd979247f242b1a33291c45cdd1", size = 225562, upload-time = "2026-10-30T15:09:04.891Z" }, + { url = "https://files.pythonhosted.org/packages/2a/da/53e44d96238dc207011ad5d93b0540c58e1c680a86f48dc3fa8e5138b343/websockets-17.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5cec3e7fbc911ff4fcf43b24aaf1b96906381ad36030f42897def3ff4b78729e", size = 226334, upload-time = "2026-10-30T15:09:06.42Z" }, + { url = "https://files.pythonhosted.org/packages/18/08/82cea972a87f229ee1903e9adf74c17d1e6c4371d581ebb11ccbed4e3a7b/websockets-17.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cbdf4b42f4514422051889424fd03bc269be8c5d751bf39ec29ad761590bd10d", size = 226767, upload-time = "2026-10-30T15:09:07.837Z" }, + { url = "https://files.pythonhosted.org/packages/96/f3/ee6afff802e39e8d6ef29ee4bdc30f8272aaa38295c19a911fad91fe95fc/websockets-17.4-cp314-cp314t-win32.whl", hash = "sha256:16550e24ac22c27e0a728100d8de196b5f054bab6748ef9f0b168fb8b3c32e35", size = 218918, upload-time = "2026-10-30T15:09:09.31Z" }, + { url = "https://files.pythonhosted.org/packages/11/56/b0b07917f9c85a4d24a37300f4ae888bfa7c20f08902dd6a5c61a0d1b26f/websockets-17.4-cp314-cp314t-win_amd64.whl", hash = "sha256:5ec906bb21b35e66cfdcc2ea0133f249f52b7d89e3e45ec8d2bd2d84a0255d7d", size = 219260, upload-time = "2026-10-30T15:09:10.832Z" }, + { url = "https://files.pythonhosted.org/packages/19/a6/a63113909ea602d3d22b0f32a7a9950d8d18b725cfdce735eab9b5f5d198/websockets-17.4-cp314-cp314t-win_arm64.whl", hash = "sha256:c00f0c45851a2c61efffd03dde8fb4d594026b5cc18196c94e15460f1225f2ed", size = 219176, upload-time = "2026-10-30T15:09:12.444Z" }, + { url = "https://files.pythonhosted.org/packages/ee/be/4032fde05e62d1c52edd250fda475e910cac0cd180e377690bff24147b5e/websockets-17.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:8c51ac7b31578a7275650f580aac985940985b6d2e57247ac6d5e07f2c936cd6", size = 218740, upload-time = "2026-10-30T15:09:13.833Z" }, + { url = "https://files.pythonhosted.org/packages/74/1c/b47f5786eb45599072411571651606fb22f6e825d522d627daad974ea636/websockets-17.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:023dc13bdc42a55e152acc81c39c90ec6cc4159ed17d23c6d73460fa2a73ab16", size = 216470, upload-time = "2026-10-30T15:09:15.394Z" }, + { url = "https://files.pythonhosted.org/packages/70/98/0021f55de633617b4a8390cca17e700c9ba5d99323103128412dc2c15aca/websockets-17.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6fd8cac4907fec8302726d49e6969acfffaf720bc39b1cee23f473b81f4dce01", size = 216695, upload-time = "2026-10-30T15:09:17.185Z" }, + { url = "https://files.pythonhosted.org/packages/28/56/2c67389b47c4b9e9e9318d9b3e4bb52a2fef3749ff00b0b151a342c4d42d/websockets-17.4-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4441d655a53185ef1b01b1d42ad9b3a96b905110a9219043e3fdaec855ba3b6e", size = 226134, upload-time = "2026-10-30T15:09:19.156Z" }, + { url = "https://files.pythonhosted.org/packages/75/bd/ee3a679a10741a0cdd7aa8bdd6d03999069672826aa7a6495fdf589ed961/websockets-17.4-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3acc45494c08a4d27375a2c28474537f68910219f42624a08011221b04623d04", size = 226569, upload-time = "2026-10-30T15:09:20.587Z" }, + { url = "https://files.pythonhosted.org/packages/c4/42/b293a5d07099549797138d09fda5bf878d302b4980e61678981c8dfdc98f/websockets-17.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b78b39377630a70aa2198e5f03be416e690364a046b1d8af80a9263733083d0", size = 227726, upload-time = "2026-10-30T15:09:22.015Z" }, + { url = "https://files.pythonhosted.org/packages/2d/81/d048ff83c4d0fc386f6008529d12690d0dcb410f73570430f13fe4d543f0/websockets-17.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6cf4c002268da5c11cae9083aec71ac943bce9d95e0f83c8bf9a95a3ce421fbb", size = 229426, upload-time = "2026-10-30T15:09:23.444Z" }, + { url = "https://files.pythonhosted.org/packages/e6/21/1df51f94047dfb76c32fd7508036e4b55352d0f04fd0e3bee525a2122225/websockets-17.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed7fe197b8bb66eef4f62c052e33752d456d2fdda74805469d4bd954950ab339", size = 228211, upload-time = "2026-10-30T15:09:24.902Z" }, + { url = "https://files.pythonhosted.org/packages/cf/13/33d6a28471da4c30a98a2313c76f984be2056a703c5c532225dc28f5dba3/websockets-17.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f0494d3d97502e270282cc6a1f8648cd7335b4fe8d5c452006e5b7f9d62b8892", size = 227106, upload-time = "2026-10-30T15:09:26.315Z" }, + { url = "https://files.pythonhosted.org/packages/4a/86/ff8441e56ca677e51f9c826868fccde2a82bafe0ffa337fd38823b64253a/websockets-17.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ab9e4bd60796866c578e3afa0a17c98636887827a39c2e238a61989c18fd8e7b", size = 224499, upload-time = "2026-10-30T15:09:28.116Z" }, + { url = "https://files.pythonhosted.org/packages/da/91/470d7a619ce4aa837ff5b6a5836227c43bdfdc42ef837cce48f508992438/websockets-17.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:8d148b4b295224d3a19e7bd9f02ebe7344de254b3b2c4d0628ce42ade0bca119", size = 227213, upload-time = "2026-10-30T15:09:29.847Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ba/55ed1422d6c73b5b81996ca195f2a256a339b26c553f5686afc2a926bc2b/websockets-17.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:6597a1f7413189b4bc58437babcdf39b79da416e5c477ae98323a88ecc108188", size = 225876, upload-time = "2026-10-30T15:09:31.249Z" }, + { url = "https://files.pythonhosted.org/packages/e9/59/f133d260e7a48d3e231c3a495eeb6114b880c1e96bfc781a949c1f73991c/websockets-17.4-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:a9b0026538719f7a532998d84640ab2e91ca1a051ce4b8d924fdcb607307e921", size = 226403, upload-time = "2026-10-30T15:09:33.199Z" }, + { url = "https://files.pythonhosted.org/packages/45/16/bb3355453ffdc31d3a14ddc0b50e058f13a97d2ed019ba6c380e03456169/websockets-17.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:a703f23ca15a51251fc94f1774683f5aa511588a7ad6bbb83960cdb2a4dcd978", size = 227558, upload-time = "2026-10-30T15:09:34.703Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/f3d55a83c2a4daa8bf62594b00a721dc8767518ccb833f932b0178eb6c19/websockets-17.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:6b061ea7ca94966af7cd7a87cb189ff15972c103244611a2b1e8408c04f1dbe6", size = 225369, upload-time = "2026-10-30T15:09:36.204Z" }, + { url = "https://files.pythonhosted.org/packages/88/66/3a320bfb718d9ae1eff15ba7790979c0e6fdec74e388430f426e6647d7f4/websockets-17.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:e6d2a185ec4ff0478089305abd833da3a9fda8803eb77325b89ebeae5585a3b7", size = 226268, upload-time = "2026-10-30T15:09:37.565Z" }, + { url = "https://files.pythonhosted.org/packages/da/ee/1f9cdeeaaa2d5e158b7a40f971e74b641b35f977674b46229a5bb14e270a/websockets-17.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:9a4e95d56994a45ac76541853796720436ffe462957d0b1b89e87ff3d3b1627e", size = 226530, upload-time = "2026-10-30T15:09:39.171Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/506406ef09e6e168796f0187bdac0767f38a560e6785c4ee26e583aaaf76/websockets-17.4-cp315-cp315-win32.whl", hash = "sha256:b7ea61af293a153f2d67430038cf0efc10140caa623f2bdf5a9f5a457ff20f57", size = 218751, upload-time = "2026-10-30T15:09:40.748Z" }, + { url = "https://files.pythonhosted.org/packages/25/a6/818647a9a9b3ee8bf131e9ab4fa1f2db9c6539f08e7084dd57549e0bd49d/websockets-17.4-cp315-cp315-win_amd64.whl", hash = "sha256:8b45d40f07081b377f0b837ddbfba4a9ab4a89a7b569d3c095436564e767a27b", size = 219045, upload-time = "2026-10-30T15:09:42.251Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b2/0338a9abec3df8556627af987352657ce1c8456f2060b54741570b174122/websockets-17.4-cp315-cp315-win_arm64.whl", hash = "sha256:29b615c2d5dd883f89c107a782681b73a7aa8b2bd894130310e45eb09b143913", size = 218957, upload-time = "2026-10-30T15:09:43.866Z" }, + { url = "https://files.pythonhosted.org/packages/68/92/22e83d003cdbd22be5d35e28c260203e9fbb6c73b17a8e1509f4ad49e74d/websockets-17.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:c568e72f5425a74616daeb824afe28da460cbeea036432f41c6af5380b83300d", size = 219056, upload-time = "2026-10-30T15:09:45.528Z" }, + { url = "https://files.pythonhosted.org/packages/2f/ca/071d38e7237f6ada4f577b74f7cbf5bc2ff7e1f9360ebd2837e74a22dfd4/websockets-17.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:bfc86dff091104eec770c29ea1831dbe191968a70aa2d8ae8eda3240d863970a", size = 216630, upload-time = "2026-10-30T15:09:46.951Z" }, + { url = "https://files.pythonhosted.org/packages/fa/76/22d4523f92d88b8f5ebfd3df7ab5e825146af100f7e2caeae7d359ae51ea/websockets-17.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:f5f06f59e19aa0770aaf651ce91c196fa620b35aed49a7e6c36e7335f3f83db7", size = 216841, upload-time = "2026-10-30T15:09:48.285Z" }, + { url = "https://files.pythonhosted.org/packages/87/29/bc94be4a8bc19ef518e9efecd90a992f2991b7cfc6eb8a7430c4e2dc097c/websockets-17.4-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8f32a6cb0b101170abc2d8053af1473a2a29ef2a06d7130994ee8455a50f5dbf", size = 226992, upload-time = "2026-10-30T15:09:49.776Z" }, + { url = "https://files.pythonhosted.org/packages/fa/25/58f69b5fec064764ddf5b88045397433cdb028f5b17c82fbe047fd31fff7/websockets-17.4-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:72d0a731eccf482d5661c6711abfcd5921f3dbfbbb0789061e1918ef4bc89c70", size = 227258, upload-time = "2026-10-30T15:09:51.172Z" }, + { url = "https://files.pythonhosted.org/packages/21/7c/bc932a54c5f1bd78461574aea539fc562fd2de494738a2c0675c4de860be/websockets-17.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48c83103f82fce36191a9e3a8a80731d4340e2da544eae8c5aaaf6a45280e7d0", size = 228589, upload-time = "2026-10-30T15:09:52.628Z" }, + { url = "https://files.pythonhosted.org/packages/c4/92/57ec83066d0bfa8a9b9f594bc61951073c4a86e34c562a5292604118dab6/websockets-17.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c8052c3058c402d53602583da5ddcf1a15a63ab1efe0222f47c7be59944e6463", size = 230217, upload-time = "2026-10-30T15:09:54.058Z" }, + { url = "https://files.pythonhosted.org/packages/6e/fc/0f2fe533b5b4dc22ac704b3357f5c99fa60a3837218b3c6c6ad63a60120e/websockets-17.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0c22a9c6b2349204f56123dd0ca7779e989d68e336d0dc02ad823485d44925de", size = 229026, upload-time = "2026-10-30T15:09:55.727Z" }, + { url = "https://files.pythonhosted.org/packages/7c/cc/ed28307835106a9a2dbd1a5efc597e8befa3d0a5f2b46a4c1e466b2f4759/websockets-17.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0dcce83837328e6795225ead920d3aa8d867cc9d6922aa558b0e9111599fdbb9", size = 227904, upload-time = "2026-10-30T15:09:57.221Z" }, + { url = "https://files.pythonhosted.org/packages/39/4d/24ad7deddc7b31c3e430acc1c00c7b384ae42f1f973e9cc01aa42d19628f/websockets-17.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4b79ea31cf277c72d2307c6cb8bd32a2c151959e80a2f24fa85df620c5f2860c", size = 225253, upload-time = "2026-10-30T15:09:58.624Z" }, + { url = "https://files.pythonhosted.org/packages/93/f6/9c92230ebfab42fee482b236c45c32ed34b24f7360080b400cce6cfcac11/websockets-17.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:3d27153a0413696767b98b5d96173a2a7e27cbfca02000a6069cea7b977765a7", size = 228089, upload-time = "2026-10-30T15:10:00.308Z" }, + { url = "https://files.pythonhosted.org/packages/fe/7a/f523830e562da9b1d7a610174752753720c5e47e84b59b5fc47721d416bd/websockets-17.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:e0feb03a338f8f5e819ae23a73aabb7b46fd3b73f15f7df782dd12d99e2b02ad", size = 226743, upload-time = "2026-10-30T15:10:01.744Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e6/d1a56495cb7b1a0a4688145131be38cfd0c1342bde8125e136a6e6ee494e/websockets-17.4-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9ff89e36451a19775e7556d95ebfa4a0b24b84cc87565d6b5d0ec8ea82bf3f2c", size = 227237, upload-time = "2026-10-30T15:10:03.417Z" }, + { url = "https://files.pythonhosted.org/packages/44/41/c4e53f7ad63838d7eba6e82c5d743827e91dafe5e48c88a58f7e90043945/websockets-17.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:ee6c4e0085bff5f6621bf9c53452584dcb91ebd993ce841e1f4061ac12b6b556", size = 228348, upload-time = "2026-10-30T15:10:05.149Z" }, + { url = "https://files.pythonhosted.org/packages/ca/01/f6f78c3edeb8ad2b3c35a8c4117ec2cf9346215afaed8155af1e7933818b/websockets-17.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1962f3bfde085af18878f1bb1aafb300c9a6ac33da886d0b0d97e33c9ce7a222", size = 226099, upload-time = "2026-10-30T15:10:06.588Z" }, + { url = "https://files.pythonhosted.org/packages/8d/01/d8c11740231b63d1aba6bad6b1d4e72e8384b26c5448801da238ebe82c92/websockets-17.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:42d7a6e818214336cf7af9a3aae5c6923f94f09fa07ac5aab98268ba2a98a6d5", size = 226956, upload-time = "2026-10-30T15:10:08.141Z" }, + { url = "https://files.pythonhosted.org/packages/99/87/dbfd43ae01ea8fdb7478a1b3d58b32aca83bb9c4aa61ebe187d1e188ac8e/websockets-17.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c9f8fdb7bbefc4907c2bb3593f810f2b67a2d5329e1d38724a1aa3d763cf63eb", size = 227253, upload-time = "2026-10-30T15:10:09.533Z" }, + { url = "https://files.pythonhosted.org/packages/bf/8e/fbd968a75428063560ada02d564de8d6c49ca34ec29dfb78e5d900f4b0ef/websockets-17.4-cp315-cp315t-win32.whl", hash = "sha256:506623128d7a55b726a5a46e4c9a8eae4c9dd0f04ff60b041fe7df85b9d034fe", size = 218877, upload-time = "2026-10-30T15:10:10.925Z" }, + { url = "https://files.pythonhosted.org/packages/f9/53/8f37a3943517bba77fc86f7c4162c455018c5b6d760c5e9c9a11de9e37f7/websockets-17.4-cp315-cp315t-win_amd64.whl", hash = "sha256:6e6558efbb256b532c9f06a21ba42bcac729718e365c505819f181f25e5c0eca", size = 219195, upload-time = "2026-10-30T15:10:12.336Z" }, + { url = "https://files.pythonhosted.org/packages/69/35/cf33cba7248fcd80cfe5911ffe67aa2637f50c2bfaada123b1e9d2aeca90/websockets-17.4-cp315-cp315t-win_arm64.whl", hash = "sha256:fcac44d917672ad6257ad64b80b5168306f168a78cab5c0612e4c699caed18cf", size = 219117, upload-time = "2026-10-30T15:10:13.771Z" }, + { url = "https://files.pythonhosted.org/packages/eb/27/9db924cb0dbf22eade78d98fbae77790f9bf6bc729e6ab29aef9d68e4156/websockets-17.4-py3-none-any.whl", hash = "sha256:c6bd2c9781915592b209160d0f017d4c7c82ad53075e6b0c24d2a89299e7f9e9", size = 212900, upload-time = "2026-10-30T15:10:34.482Z" }, +] + +[[package]] +name = "win-unicode-console" +version = "0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/89/8d/7aad74930380c8972ab282304a2ff45f3d4927108bb6693cabcc9fc6a099/win_unicode_console-0.5.zip", hash = "sha256:d4142d4d56d46f449d6f00536a73625a871cba040f0bc1a2e305a04578f07d1e", size = 31420, upload-time = "2016-06-25T19:48:54.05Z" }